morpheus-cli 0.7.7 → 0.8.2

package/README.md

@@ -9,9 +9,10 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 
 ## Why Morpheus
 - Local-first persistence (sessions, messages, usage, tasks).
-- Multi-agent architecture (Oracle, Neo, Apoc, Sati, Trinity).
+- Multi-agent architecture (Oracle, Neo, Apoc, Sati, Trinity, Smith).
 - Async task execution with queue + worker + notifier.
 - Chronos temporal scheduler for recurring and one-time Oracle executions.
+- Smith remote agent system for DevKit execution on isolated machines via WebSocket.
 - Multi-channel output via ChannelRegistry (Telegram, Discord) with per-job routing.
 - Rich operational visibility in UI (chat traces, tasks, usage, logs).
 
@@ -23,6 +24,7 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 - `Trinity`: database specialist. Executes queries, introspects schemas, and manages registered databases (PostgreSQL, MySQL, SQLite, MongoDB).
 - `Chronos`: temporal scheduler. Runs Oracle prompts on a recurring or one-time schedule.
 - `Keymaker`: skill executor. Runs user-defined skills with full tool access (DevKit + MCP + internal tools).
+- `Smith`: remote DevKit executor. Runs DevKit operations on isolated machines (Docker, VMs, cloud) via WebSocket.
 
 ## Installation
 
@@ -169,10 +171,10 @@ docker run -d \
 Morpheus uses asynchronous delegation by default:
 
 1. Oracle receives user request.
-2. If execution is needed, Oracle calls `neo_delegate`, `apoc_delegate`, or `trinity_delegate`.
+2. If execution is needed, Oracle calls `neo_delegate`, `apoc_delegate`, `trinity_delegate`, or `smith_delegate`.
 3. Delegate tool creates a row in `tasks` table with origin metadata (`channel`, `session`, `message`, `user`).
 4. Oracle immediately acknowledges task creation.
-5. `TaskWorker` executes pending tasks (routes `trinit` tasks to Trinity agent).
+5. `TaskWorker` executes pending tasks (routes `trinit` tasks to Trinity agent, `smith` tasks to Smith delegator).
 6. `TaskNotifier` sends completion/failure through `TaskDispatcher`.
 
 Important behavior:
@@ -217,6 +219,44 @@ Chronos lets you schedule any Oracle prompt to run at a fixed time or on a recur
 - `POST /api/chronos/preview` — preview next N run timestamps
 - `GET/POST/DELETE /api/config/chronos`
 
+## Smith — Remote Agent System
+
+Smith enables remote DevKit execution on isolated machines (Docker, VMs, cloud) via WebSocket.
+
+**Architecture:**
+- `SmithRegistry` manages WebSocket connections to remote Smith instances (singleton, non-blocking startup).
+- `SmithDelegator` creates a LangChain ReactAgent with **proxy tools** — local DevKit tools built for schema extraction, filtered by Smith's declared capabilities, wrapped in proxies that forward execution to the remote Smith via WebSocket.
+- Oracle delegates via `smith_delegate` tool (sync or async, like other subagents).
+
+**Config (`zaion.yaml`):**
+```yaml
+smiths:
+  enabled: true
+  execution_mode: sync    # or async
+  entries:
+    - name: smith1
+      host: localhost
+      port: 7778
+      auth_token: secret-token
+```
+
+**Key behaviors:**
+- **Hot-reload:** Config changes connect/disconnect Smiths without restart (via `PUT /api/smiths/config` or `smith_manage` tool).
+- **Reconnection:** Max 3 attempts. 401 auth failures stop retries immediately.
+- **Non-blocking startup:** Smith connection failures don't block daemon boot.
+
+**Oracle tools:** `smith_list` (list Smiths + state), `smith_manage` (add/remove/ping/enable/disable)
+
+**API endpoints (protected):**
+- `GET /api/smiths` — list all Smiths with status
+- `GET /api/smiths/config` — get Smiths configuration
+- `PUT /api/smiths/config` — update config (hot-reload)
+- `GET /api/smiths/:name` — get specific Smith details
+- `POST /api/smiths/:name/ping` — ping a Smith
+- `DELETE /api/smiths/:name` — remove a Smith
+
+> **Learn more:** The Smith standalone agent has its own repository with setup instructions, Docker support, and protocol documentation at [github.com/marcosnunesmbs/smith](https://github.com/marcosnunesmbs/smith).
+
 ## Telegram Experience
 
 Telegram responses use rich HTML formatting conversion with:
@@ -276,7 +316,7 @@ Adding a new channel requires only implementing `IChannelAdapter` (`channel`, `s
 The dashboard includes:
 - Chat with session management
 - Tasks page (stats, filters, details, retry)
-- Agent settings (Oracle/Sati/Neo/Apoc/Trinity)
+- Agent settings (Oracle/Sati/Neo/Apoc/Trinity/Smiths)
 - MCP manager (add/edit/delete/toggle/reload)
 - Sati memories (search, bulk delete)
 - Usage stats and model pricing
@@ -337,6 +377,14 @@ chronos:
   check_interval_ms: 60000   # polling interval in ms (minimum 60000)
   default_timezone: UTC      # IANA timezone used when none is specified
 
+smiths:
+  enabled: false
+  execution_mode: async      # 'sync' = inline response, 'async' = background task
+  heartbeat_interval_ms: 30000
+  connection_timeout_ms: 10000
+  task_timeout_ms: 300000
+  entries: []                # list of { name, host, port, auth_token }
+
 runtime:
   async_tasks:
     enabled: true
@@ -593,11 +641,12 @@ Authenticated endpoints (`x-architect-pass`):
 - Sessions: `/api/sessions*`
 - Chat: `POST /api/chat`
 - Tasks: `GET /api/tasks`, `GET /api/tasks/stats`, `GET /api/tasks/:id`, `POST /api/tasks/:id/retry`
-- Config: `/api/config`, `/api/config/sati`, `/api/config/neo`, `/api/config/apoc`, `/api/config/trinity`, `/api/config/chronos`
+- Config: `/api/config`, `/api/config/sati`, `/api/config/neo`, `/api/config/apoc`, `/api/config/trinity`, `/api/config/chronos`, `/api/config/smiths`
 - MCP: `/api/mcp/*` (servers CRUD + reload + status)
 - Sati memories: `/api/sati/memories*`
 - Trinity databases: `GET/POST/PUT/DELETE /api/trinity/databases`, `POST /api/trinity/databases/:id/test`, `POST /api/trinity/databases/:id/refresh-schema`
 - Chronos: `GET/POST /api/chronos`, `GET/PUT/DELETE /api/chronos/:id`, `PATCH /api/chronos/:id/enable`, `PATCH /api/chronos/:id/disable`, `GET /api/chronos/:id/executions`, `POST /api/chronos/preview`
+- Smiths: `GET /api/smiths`, `GET/PUT /api/smiths/config`, `GET/DELETE /api/smiths/:name`, `POST /api/smiths/:name/ping`
 - Usage/model pricing/logs/restart
 - Webhook management and webhook notifications
 
@@ -711,6 +760,10 @@ src/
       worker.ts           # polling timer and job execution
       repository.ts       # SQLite-backed job and execution store
       parser.ts           # natural-language schedule parser
+    smiths/
+      registry.ts         # SmithRegistry — manages all connections
+      connection.ts       # WebSocket client per Smith instance
+      delegator.ts        # LLM agent with proxy tools for remote execution
     memory/
     tasks/
     tools/

package/dist/cli/commands/smiths.js

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { ConfigManager } from '../../config/manager.js';
+export const smithsCommand = new Command('smiths')
+    .description('Manage remote Smith agents')
+    .action(async () => {
+    // Default action: list all Smiths
+    await ConfigManager.getInstance().load();
+    const config = ConfigManager.getInstance().getSmithsConfig();
+    if (!config.enabled) {
+        console.log(chalk.yellow('⚠') + ' Smiths subsystem is disabled.');
+        console.log(chalk.gray('  Enable it in zaion.yaml: smiths.enabled: true'));
+        return;
+    }
+    if (config.entries.length === 0) {
+        console.log(chalk.yellow('⚠') + ' No Smiths configured.');
+        console.log(chalk.gray('  Add entries in zaion.yaml under smiths.entries'));
+        return;
+    }
+    console.log(chalk.bold('Registered Smiths'));
+    console.log(chalk.gray('═══════════════════'));
+    for (const entry of config.entries) {
+        const stateIcon = '⚪'; // Offline by default (not connected via CLI)
+        console.log(`  ${stateIcon} ${chalk.cyan(entry.name)} — ${entry.host}:${entry.port}`);
+    }
+    console.log();
+    console.log(chalk.gray(`  Execution mode: ${config.execution_mode}`));
+    console.log(chalk.gray(`  Heartbeat: ${config.heartbeat_interval_ms}ms`));
+    console.log(chalk.gray(`  Total: ${config.entries.length} smith(s)`));
+});
+smithsCommand
+    .command('list')
+    .description('List all configured Smiths')
+    .action(async () => {
+    await ConfigManager.getInstance().load();
+    const config = ConfigManager.getInstance().getSmithsConfig();
+    if (config.entries.length === 0) {
+        console.log('No Smiths configured.');
+        return;
+    }
+    console.log(chalk.bold('Name            Host                    Port'));
+    console.log(chalk.gray('────────────────────────────────────────────'));
+    for (const entry of config.entries) {
+        const name = entry.name.padEnd(16);
+        const host = entry.host.padEnd(24);
+        console.log(`${chalk.cyan(name)}${host}${entry.port}`);
+    }
+});
+smithsCommand
+    .command('ping <name>')
+    .description('Test connectivity to a Smith')
+    .action(async (name) => {
+    await ConfigManager.getInstance().load();
+    const config = ConfigManager.getInstance().getSmithsConfig();
+    const entry = config.entries.find(e => e.name === name);
+    if (!entry) {
+        console.log(chalk.red(`✗ Smith '${name}' not found in configuration.`));
+        const available = config.entries.map(e => e.name).join(', ');
+        if (available)
+            console.log(chalk.gray(`  Available: ${available}`));
+        process.exit(1);
+        return;
+    }
+    console.log(chalk.gray(`Pinging ${entry.name} at ${entry.host}:${entry.port}...`));
+    try {
+        // Simple TCP connectivity check
+        const { createConnection } = await import('net');
+        const socket = createConnection({ host: entry.host, port: entry.port, timeout: 5000 });
+        await new Promise((resolve, reject) => {
+            socket.on('connect', () => {
+                const latency = Date.now();
+                console.log(chalk.green('✓') + ` Smith '${name}' is reachable at ${entry.host}:${entry.port}`);
+                socket.end();
+                resolve();
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                reject(new Error('Connection timeout'));
+            });
+            socket.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    catch (err) {
+        console.log(chalk.red('✗') + ` Smith '${name}' is unreachable: ${err.message}`);
+        process.exit(1);
+    }
+});
+smithsCommand
+    .command('remove <name>')
+    .description('Remove a Smith from configuration')
+    .action(async (name) => {
+    const configManager = ConfigManager.getInstance();
+    await configManager.load();
+    const config = configManager.get();
+    const entries = config.smiths?.entries ?? [];
+    const idx = entries.findIndex(e => e.name === name);
+    if (idx === -1) {
+        console.log(chalk.red(`✗ Smith '${name}' not found in configuration.`));
+        process.exit(1);
+        return;
+    }
+    entries.splice(idx, 1);
+    await configManager.save({
+        ...config,
+        smiths: { ...config.smiths, entries },
+    });
+    console.log(chalk.green('✓') + ` Smith '${name}' removed from configuration.`);
+});

package/dist/cli/commands/start.js

@@ -25,6 +25,7 @@ import { ChronosWorker } from '../../runtime/chronos/worker.js';
 import { ChronosRepository } from '../../runtime/chronos/repository.js';
 import { SkillRegistry } from '../../runtime/skills/index.js';
 import { MCPToolCache } from '../../runtime/tools/cache.js';
+import { SmithRegistry } from '../../runtime/smiths/registry.js';
 // Load .env file explicitly in start command
 const envPath = path.join(process.cwd(), '.env');
 if (fs.existsSync(envPath)) {
@@ -158,6 +159,20 @@ export const startCommand = new Command('start')
             display.stopSpinner();
             display.log(chalk.yellow(`MCP cache warning: ${err.message}`), { source: 'MCP' });
         }
+        // Initialize SmithRegistry before Oracle (so Smiths are available in system prompt)
+        try {
+            const smithsConfig = config.smiths;
+            if (smithsConfig?.enabled && smithsConfig.entries.length > 0) {
+                const smithRegistry = SmithRegistry.getInstance();
+                await smithRegistry.connectAll();
+                const online = smithRegistry.getOnline().length;
+                const total = smithRegistry.list().length;
+                display.log(chalk.green(`✓ Smiths connected: ${online}/${total}`), { source: 'Smiths' });
+            }
+        }
+        catch (err) {
+            display.log(chalk.yellow(`Smiths initialization warning: ${err.message}`), { source: 'Smiths' });
+        }
         // Initialize Oracle
         const oracle = new Oracle(config);
         try {
@@ -267,6 +282,11 @@ export const startCommand = new Command('start')
                 taskWorker.stop();
                 taskNotifier.stop();
             }
+            // Disconnect all Smiths
+            try {
+                await SmithRegistry.getInstance().disconnectAll();
+            }
+            catch { }
             await clearPid();
             process.exit(0);
         };

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
 import { restartCommand } from './commands/restart.js';
 import { sessionCommand } from './commands/session.js';
+import { smithsCommand } from './commands/smiths.js';
 import { scaffold } from '../runtime/scaffold.js';
 import { getVersion } from './utils/version.js';
 export async function cli() {
@@ -26,6 +27,7 @@ export async function cli() {
     program.addCommand(configCommand);
     program.addCommand(doctorCommand);
     program.addCommand(sessionCommand);
+    program.addCommand(smithsCommand);
     await program.parseAsync(process.argv);
 }
 // Support direct execution via tsx

package/dist/config/manager.js

@@ -317,6 +317,14 @@ export class ConfigManager {
             memory: memoryConfig,
             chronos: chronosConfig,
             devkit: devkitConfig,
+            smiths: {
+                enabled: resolveBoolean('MORPHEUS_SMITHS_ENABLED', config.smiths?.enabled, false),
+                execution_mode: resolveString('MORPHEUS_SMITHS_EXECUTION_MODE', config.smiths?.execution_mode, 'async'),
+                heartbeat_interval_ms: resolveNumeric('MORPHEUS_SMITHS_HEARTBEAT_INTERVAL_MS', config.smiths?.heartbeat_interval_ms, 30000),
+                connection_timeout_ms: resolveNumeric('MORPHEUS_SMITHS_CONNECTION_TIMEOUT_MS', config.smiths?.connection_timeout_ms, 10000),
+                task_timeout_ms: resolveNumeric('MORPHEUS_SMITHS_TASK_TIMEOUT_MS', config.smiths?.task_timeout_ms, 60000),
+                entries: config.smiths?.entries ?? [],
+            },
             verbose_mode: resolveBoolean('MORPHEUS_VERBOSE_MODE', config.verbose_mode, true),
         };
     }
@@ -401,6 +409,20 @@ export class ConfigManager {
         }
         return defaults;
     }
+    getSmithsConfig() {
+        const defaults = {
+            enabled: false,
+            execution_mode: 'async',
+            heartbeat_interval_ms: 30000,
+            connection_timeout_ms: 10000,
+            task_timeout_ms: 60000,
+            entries: [],
+        };
+        if (this.config.smiths) {
+            return { ...defaults, ...this.config.smiths };
+        }
+        return defaults;
+    }
     getDevKitConfig() {
         const defaults = {
             sandbox_dir: process.cwd(),

package/dist/config/schemas.js

@@ -54,6 +54,21 @@ export const DevKitConfigSchema = z.object({
     enable_network: z.boolean().default(true),
     timeout_ms: z.number().int().positive().default(30000),
 });
+export const SmithEntrySchema = z.object({
+    name: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/, 'Smith name must be lowercase alphanumeric with hyphens/underscores'),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535).default(7900),
+    auth_token: z.string().min(1),
+    tls: z.boolean().default(false),
+});
+export const SmithsConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    execution_mode: z.enum(['sync', 'async']).default('async'),
+    heartbeat_interval_ms: z.number().int().min(5000).default(30000),
+    connection_timeout_ms: z.number().int().min(1000).default(10000),
+    task_timeout_ms: z.number().int().min(1000).default(60000),
+    entries: z.array(SmithEntrySchema).default([]),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
@@ -78,6 +93,7 @@ export const ConfigSchema = z.object({
     }).optional(),
     chronos: ChronosConfigSchema.optional(),
     devkit: DevKitConfigSchema.optional(),
+    smiths: SmithsConfigSchema.optional(),
     verbose_mode: z.boolean().default(true),
     channels: z.object({
         telegram: z.object({

package/dist/http/api.js

@@ -19,6 +19,7 @@ import { ChronosRepository } from '../runtime/chronos/repository.js';
 import { ChronosWorker } from '../runtime/chronos/worker.js';
 import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
 import { createSkillsRouter } from './routers/skills.js';
+import { createSmithsRouter } from './routers/smiths.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 import { hotReloadConfig, getRestartRequiredChanges } from '../runtime/hot-reload.js';
 async function readLastLines(filePath, n) {
@@ -45,6 +46,8 @@ export function createApiRouter(oracle, chronosWorker) {
     }
     // Mount Skills router
     router.use('/skills', createSkillsRouter());
+    // Mount Smiths router
+    router.use('/smiths', createSmithsRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {

package/dist/http/routers/smiths.js

@@ -0,0 +1,188 @@
+import { Router } from 'express';
+import { SmithRegistry } from '../../runtime/smiths/registry.js';
+import { SmithDelegator } from '../../runtime/smiths/delegator.js';
+import { ConfigManager } from '../../config/manager.js';
+import { DisplayManager } from '../../runtime/display.js';
+/**
+ * Creates the Smiths API router.
+ * Follows the factory-function pattern from chronos.ts.
+ */
+export function createSmithsRouter() {
+    const router = Router();
+    const registry = SmithRegistry.getInstance();
+    const delegator = SmithDelegator.getInstance();
+    const display = DisplayManager.getInstance();
+    /**
+     * GET /api/smiths — List all registered Smiths with status
+     */
+    router.get('/', (_req, res) => {
+        try {
+            const smiths = registry.list().map(s => ({
+                name: s.name,
+                host: s.host,
+                port: s.port,
+                state: s.state,
+                capabilities: s.capabilities,
+                stats: s.stats ?? null,
+                lastSeen: s.lastSeen?.toISOString() ?? null,
+                error: s.error ?? null,
+            }));
+            res.json({
+                enabled: ConfigManager.getInstance().getSmithsConfig().enabled,
+                total: smiths.length,
+                online: smiths.filter(s => s.state === 'online').length,
+                smiths,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/smiths/config — Get Smiths configuration
+     * NOTE: Must be defined BEFORE /:name to avoid "config" matching as a name param.
+     */
+    router.get('/config', (_req, res) => {
+        try {
+            const config = ConfigManager.getInstance().getSmithsConfig();
+            // Omit auth_tokens from response for security
+            const safeEntries = config.entries.map(({ auth_token, ...rest }) => ({
+                ...rest,
+                auth_token: '***',
+            }));
+            res.json({
+                enabled: config.enabled,
+                execution_mode: config.execution_mode,
+                heartbeat_interval_ms: config.heartbeat_interval_ms,
+                connection_timeout_ms: config.connection_timeout_ms,
+                task_timeout_ms: config.task_timeout_ms,
+                entries: safeEntries,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * PUT /api/smiths/config — Update Smiths configuration
+     */
+    router.put('/config', async (req, res) => {
+        try {
+            const configManager = ConfigManager.getInstance();
+            const currentConfig = configManager.get();
+            // Preserve masked auth_tokens: if UI sends '***', keep the existing token
+            const incomingEntries = req.body.entries;
+            if (Array.isArray(incomingEntries)) {
+                const existingEntries = currentConfig.smiths?.entries ?? [];
+                req.body.entries = incomingEntries.map((entry) => {
+                    // Preserve existing token when UI sends sentinel '***' or leaves field blank
+                    if (entry.auth_token === '***' || entry.auth_token === '') {
+                        const existing = existingEntries.find((e) => e.name === entry.name);
+                        return { ...entry, auth_token: existing?.auth_token ?? '' };
+                    }
+                    return entry;
+                });
+            }
+            const updated = {
+                ...currentConfig,
+                smiths: {
+                    ...currentConfig.smiths,
+                    ...req.body,
+                },
+            };
+            await configManager.save(updated);
+            // Hot-reload: connect new Smiths, disconnect removed ones
+            const { added, removed } = await registry.reload();
+            res.json({ status: 'updated', added, removed });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/smiths/:name — Get a specific Smith's details
+     */
+    router.get('/:name', (req, res) => {
+        try {
+            const smith = registry.get(req.params.name);
+            if (!smith) {
+                return res.status(404).json({ error: `Smith '${req.params.name}' not found` });
+            }
+            res.json({
+                name: smith.name,
+                host: smith.host,
+                port: smith.port,
+                state: smith.state,
+                capabilities: smith.capabilities,
+                stats: smith.stats ?? null,
+                lastSeen: smith.lastSeen?.toISOString() ?? null,
+                error: smith.error ?? null,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/smiths/register — Self-registration endpoint (Smith calls this on boot)
+     */
+    router.post('/register', (req, res) => {
+        try {
+            const { name, host, port, auth_token, capabilities } = req.body;
+            if (!name || !host || !auth_token) {
+                return res.status(400).json({ error: 'Missing required fields: name, host, auth_token' });
+            }
+            // Validate auth token against configured entries
+            const config = ConfigManager.getInstance().getSmithsConfig();
+            const configEntry = config.entries.find(e => e.name === name);
+            if (configEntry && configEntry.auth_token !== auth_token) {
+                display.log(`Smith '${name}' registration rejected: invalid auth token`, {
+                    source: 'SmithsAPI',
+                    level: 'warning',
+                });
+                return res.status(401).json({ error: 'Invalid authentication token' });
+            }
+            registry.registerFromHandshake(name, host, port ?? 7900, capabilities ?? []);
+            display.log(`Smith '${name}' registered via HTTP handshake`, {
+                source: 'SmithsAPI',
+                level: 'info',
+            });
+            res.json({ status: 'registered', name });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/smiths/:name/ping — Manual ping to test connectivity
+     */
+    router.post('/:name/ping', async (req, res) => {
+        try {
+            const result = await delegator.ping(req.params.name);
+            res.json({
+                online: result.online,
+                latency_ms: result.latencyMs ?? null,
+                error: result.error ?? null,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * DELETE /api/smiths/:name — Remove a Smith
+     */
+    router.delete('/:name', (req, res) => {
+        try {
+            const removed = registry.unregister(req.params.name);
+            if (!removed) {
+                return res.status(404).json({ error: `Smith '${req.params.name}' not found` });
+            }
+            res.json({ status: 'removed', name: req.params.name });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/runtime/display.js

@@ -101,6 +101,9 @@ export class DisplayManager {
             else if (options.source === 'Chronos') {
                 color = chalk.hex('#a855f7');
             }
+            else if (options.source === 'SmithDelegateTool' || options.source === 'SmithRegistry' || options.source === 'Smiths' || options.source === 'SmithConnection' || options.source === 'SmithDelegator') {
+                color = chalk.hex('#ff007f');
+            }
             prefix = color(`[${options.source}] `);
         }
         let formattedMessage = message;

package/dist/runtime/oracle.js

@@ -13,10 +13,12 @@ import { Trinity } from "./trinity.js";
 import { NeoDelegateTool } from "./tools/neo-tool.js";
 import { ApocDelegateTool } from "./tools/apoc-tool.js";
 import { TrinityDelegateTool } from "./tools/trinity-tool.js";
+import { SmithDelegateTool } from "./tools/smith-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { Construtor } from "./tools/factory.js";
 import { MCPManager } from "../config/mcp-manager.js";
 import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
+import { SmithRegistry } from "./smiths/registry.js";
 export class Oracle {
     provider;
     config;
@@ -110,7 +112,7 @@ export class Oracle {
             const toolCalls = msg.tool_calls ?? [];
             if (!Array.isArray(toolCalls))
                 continue;
-            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate")) {
+            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate" || tc?.name === "smith_delegate")) {
                 return true;
             }
         }
@@ -146,7 +148,13 @@ export class Oracle {
             await Neo.refreshDelegateCatalog().catch(() => { });
             await Trinity.refreshDelegateCatalog().catch(() => { });
             updateSkillToolDescriptions();
-            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools]);
+            // Build tool list — conditionally include SmithDelegateTool based on config
+            const coreTools = [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools];
+            const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
+            if (smithsConfig.enabled && smithsConfig.entries.length > 0) {
+                coreTools.push(SmithDelegateTool);
+            }
+            this.provider = await ProviderFactory.create(this.config.llm, coreTools);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -266,7 +274,11 @@ Use ONLY when user provides a cron expression or very specific recurring pattern
 - "toda segunda e quarta às 3pm" → cron, "0 15 * * 1,3"
 
 **IMPORTANT**: Default to "once" for reminders unless user explicitly indicates recurrence with "a cada", "todo", "diariamente", etc.
-
+**ALWAYS** set the expression Schedule Expression "literal" when user say the specif day and/or hour, dont parse the timezone or full datetime.
+  Ex: - "me lembre de algo às 17h" → schedule_type: "once", expression: "today at 17:00"
+      - "me lembre de algo hoje às 9h" → schedule_type: "once", expression: "today at 9:00"
+      - "me lembre de algo amanhã às 14h" → schedule_type: "once", expression: "tomorrow at 14:00"
+      - "me lembre de algo na próxima segunda às 8h" → schedule_type: "once", expression: "next Monday at 8:00"
 ## Chronos Scheduled Execution
 When the current user message starts with [CHRONOS EXECUTION], it means a Chronos scheduled job has just fired. The content after the prefix is the **job's saved prompt**, not a new live request from the user.
 
@@ -308,6 +320,7 @@ bad:
 - delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
 
 ${SkillRegistry.getInstance().getSystemPromptSection()}
+${SmithRegistry.getInstance().getSystemPromptSection()}
 `);
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await this.history.getMessages();