morpheus-cli 0.5.5 → 0.6.0

package/README.md

@@ -9,8 +9,9 @@ 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).
+- Multi-agent architecture (Oracle, Neo, Apoc, Sati, Trinity).
 - Async task execution with queue + worker + notifier.
+- Chronos temporal scheduler for recurring and one-time Oracle executions.
 - Rich operational visibility in UI (chat traces, tasks, usage, logs).
 
 ## Multi-Agent Roles
@@ -19,6 +20,7 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 - `Apoc`: DevTools/browser execution (filesystem, shell, git, network, packages, processes, system, browser automation).
 - `Sati`: long-term memory retrieval/evaluation.
 - `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.
 
 ## Installation
 
@@ -156,6 +158,36 @@ Important behavior:
 - Duplicate/fabricated task acknowledgements are blocked by validation against DB.
 - Status follow-ups are handled by Oracle through `task_query` (no delegation required).
 
+## Chronos — Temporal Scheduler
+
+Chronos lets you schedule any Oracle prompt to run at a fixed time or on a recurring schedule.
+
+**Schedule types:**
+- `once` — run once at a specific time: `"in 30 minutes"`, `"tomorrow at 9am"`, `"2026-03-01T09:00:00"`
+- `interval` — recurring natural language: `"every day at 9am"`, `"every weekday"`, `"every monday and friday at 8am"`, `"every 30 minutes"`
+- `cron` — raw 5-field cron: `"0 9 * * 1-5"`
+
+**Execution model:**
+- Jobs run inside the currently active Oracle session — no isolated sessions are created per job.
+- Chronos injects context as an AI message before invoking `oracle.chat()`, keeping conversation history clean.
+- Delegated tasks spawned during Chronos execution carry `origin_channel: 'telegram'` when a Telegram notify function is registered, so task results are delivered to you.
+
+**Oracle tools:** `chronos_schedule`, `chronos_list`, `chronos_cancel`, `chronos_preview`
+
+**Telegram commands:**
+- `/chronos <prompt> @ <schedule>` — create a job
+- `/chronos_list` — list all jobs (🟢 active / 🔴 disabled)
+- `/chronos_view <id>` — view job details and last 5 executions
+- `/chronos_enable <id>` / `/chronos_disable <id>` / `/chronos_delete <id>`
+
+**API endpoints (protected):**
+- `GET/POST /api/chronos` — list / create jobs
+- `GET/PUT/DELETE /api/chronos/:id` — read / update / delete
+- `PATCH /api/chronos/:id/enable` / `.../disable`
+- `GET /api/chronos/:id/executions`
+- `POST /api/chronos/preview` — preview next N run timestamps
+- `GET/POST/DELETE /api/config/chronos`
+
 ## Telegram Experience
 
 Telegram responses use rich HTML formatting conversion with:
@@ -175,6 +207,7 @@ The dashboard includes:
 - Sati memories (search, bulk delete)
 - Usage stats and model pricing
 - Trinity databases (register/test/refresh schema)
+- Chronos scheduler (create/edit/delete jobs, execution history)
 - Webhooks and notification inbox
 - Logs viewer
 
@@ -223,6 +256,10 @@ trinity:
   model: gpt-4o-mini
   temperature: 0.2
 
+chronos:
+  check_interval_ms: 60000   # polling interval in ms (minimum 60000)
+  default_timezone: UTC      # IANA timezone used when none is specified
+
 runtime:
   async_tasks:
     enabled: true
@@ -352,10 +389,11 @@ 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`
+- Config: `/api/config`, `/api/config/sati`, `/api/config/neo`, `/api/config/apoc`, `/api/config/trinity`, `/api/config/chronos`
 - 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`
 - Usage/model pricing/logs/restart
 - Webhook management and webhook notifications
 
@@ -462,6 +500,10 @@ src/
     trinity.ts
     trinity-connector.ts  # PostgreSQL/MySQL/SQLite/MongoDB drivers
     trinity-crypto.ts     # AES-256-GCM encryption for DB passwords
+    chronos/
+      worker.ts           # polling timer and job execution
+      repository.ts       # SQLite-backed job and execution store
+      parser.ts           # natural-language schedule parser
     memory/
     tasks/
     tools/

package/dist/channels/telegram.js

@@ -123,6 +123,14 @@ function escMd(value) {
     // The - must be at end of character class to avoid being treated as a range.
     return String(value).replace(/([.!?(){}#+~|=>$@\\-])/g, '\\$1');
 }
+/**
+ * Full MarkdownV2 escape — escapes ALL special characters including * _ ` [ ].
+ * Use for untrusted/user-generated content (session titles, prompts, etc.)
+ * placed inside bold/italic markers or anywhere in a MarkdownV2 message.
+ */
+function escMdRaw(value) {
+    return String(value).replace(/([_*[\]()~`>#+=|{}.!\\-])/g, '\\$1');
+}
 export class TelegramAdapter {
     bot = null;
     isConnected = false;
@@ -135,6 +143,8 @@ export class TelegramAdapter {
     history = new SQLiteChatMessageHistory({ sessionId: '' });
     RATE_LIMIT_MS = 3000; // minimum ms between requests per user
     rateLimiter = new Map(); // userId -> last request timestamp
+    // Pending Chronos create confirmations (userId -> job data + expiry)
+    pendingChronosCreate = new Map();
     isRateLimited(userId) {
         const now = Date.now();
         const last = this.rateLimiter.get(userId);
@@ -155,7 +165,13 @@ export class TelegramAdapter {
 /sessions \\- List all sessions with titles and switch between them
 /restart \\- Restart the Morpheus agent
 /mcpreload \\- Reload MCP servers without restarting
-/mcp or /mcps \\- List registered MCP servers`;
+/mcp or /mcps \\- List registered MCP servers
+/chronos <prompt \\+ time\\> \\- Schedule a prompt for the Oracle
+/chronos\\_list \\- List all active Chronos jobs
+/chronos\\_view <id\\> \\- View a Chronos job and its last executions
+/chronos\\_disable <id\\> \\- Disable a Chronos job
+/chronos\\_enable <id\\> \\- Enable a Chronos job
+/chronos\\_delete <id\\> \\- Delete a Chronos job`;
     constructor(oracle) {
         this.oracle = oracle;
     }
@@ -187,6 +203,22 @@ export class TelegramAdapter {
                     await this.handleSystemCommand(ctx, text, user);
                     return;
                 }
+                // Check for pending Chronos create confirmation
+                const pendingChronos = this.pendingChronosCreate.get(userId);
+                if (pendingChronos) {
+                    const lower = text.trim().toLowerCase();
+                    if (lower === 'yes' || lower === 'confirm' || lower === 'y') {
+                        clearTimeout(pendingChronos.timer);
+                        this.pendingChronosCreate.delete(userId);
+                        await this.confirmChronosCreate(ctx, userId, pendingChronos);
+                    }
+                    else {
+                        clearTimeout(pendingChronos.timer);
+                        this.pendingChronosCreate.delete(userId);
+                        await ctx.reply('Cancelled.');
+                    }
+                    return;
+                }
                 // Rate limit check
                 if (this.isRateLimited(userId)) {
                     await ctx.reply('Please wait a moment before sending another message.');
@@ -738,10 +770,234 @@ export class TelegramAdapter {
             case '/sessions':
                 await this.handleSessionStatusCommand(ctx, user);
                 break;
+            case '/chronos': {
+                const userId = ctx.from?.id?.toString() ?? user;
+                const fullText = text.slice('/chronos'.length).trim();
+                await this.handleChronosCreate(ctx, userId, fullText);
+                break;
+            }
+            case '/chronos_list':
+                await this.handleChronosList(ctx);
+                break;
+            case '/chronos_view': {
+                const id = args[0] ?? '';
+                await this.handleChronosView(ctx, id);
+                break;
+            }
+            case '/chronos_disable': {
+                const id = args[0] ?? '';
+                await this.handleChronosDisable(ctx, id);
+                break;
+            }
+            case '/chronos_enable': {
+                const id = args[0] ?? '';
+                await this.handleChronosEnable(ctx, id);
+                break;
+            }
+            case '/chronos_delete': {
+                const id = args[0] ?? '';
+                await this.handleChronosDelete(ctx, id);
+                break;
+            }
             default:
                 await this.handleDefaultCommand(ctx, user, command);
         }
     }
+    // ─── Chronos Command Handlers ────────────────────────────────────────────────
+    async handleChronosCreate(ctx, userId, fullText) {
+        if (!fullText) {
+            await ctx.reply('Usage: /chronos <prompt + time expression>\nExample: /chronos Check disk space tomorrow at 9am');
+            return;
+        }
+        try {
+            const { parse: chronoParse } = await import('chrono-node');
+            const results = chronoParse(fullText);
+            if (!results.length) {
+                await ctx.reply('Could not detect a time expression. Try: `/chronos Check disk space tomorrow at 9am`', { parse_mode: 'Markdown' });
+                return;
+            }
+            // Extract the first matched datetime fragment and derive the prompt
+            const match = results[0];
+            const matchedText = fullText.slice(match.index, match.index + match.text.length);
+            const prompt = (fullText.slice(0, match.index) + fullText.slice(match.index + match.text.length)).replace(/\s+/g, ' ').trim() || fullText;
+            const globalTz = this.config.getChronosConfig().timezone;
+            const { parseScheduleExpression } = await import('../runtime/chronos/parser.js');
+            const schedule = parseScheduleExpression(matchedText, 'once', { timezone: globalTz });
+            const formatted = new Date(schedule.next_run_at).toLocaleString('en-US', {
+                timeZone: globalTz, year: 'numeric', month: 'short', day: 'numeric',
+                hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+            });
+            const timer = setTimeout(() => {
+                this.pendingChronosCreate.delete(userId);
+            }, 5 * 60 * 1000);
+            this.pendingChronosCreate.set(userId, {
+                prompt,
+                schedule_expression: matchedText,
+                human_readable: schedule.human_readable,
+                timezone: globalTz,
+                expiresAt: Date.now() + 5 * 60 * 1000,
+                timer,
+            });
+            await ctx.reply(`📅 *${prompt}*\n${schedule.human_readable} (${formatted})\n\nConfirm? Reply \`yes\` or \`no\``, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async confirmChronosCreate(ctx, _userId, pending) {
+        if (Date.now() > pending.expiresAt) {
+            await ctx.reply('Confirmation expired. Please run /chronos again.');
+            return;
+        }
+        try {
+            const { parseScheduleExpression } = await import('../runtime/chronos/parser.js');
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const schedule = parseScheduleExpression(pending.schedule_expression, 'once', {
+                timezone: pending.timezone,
+            });
+            const repo = ChronosRepository.getInstance();
+            const job = repo.createJob({
+                prompt: pending.prompt,
+                schedule_type: 'once',
+                schedule_expression: pending.schedule_expression,
+                cron_normalized: schedule.cron_normalized,
+                timezone: pending.timezone,
+                next_run_at: schedule.next_run_at,
+                created_by: 'telegram',
+            });
+            const formatted = new Date(schedule.next_run_at).toLocaleString('en-US', {
+                timeZone: pending.timezone, year: 'numeric', month: 'short', day: 'numeric',
+                hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+            });
+            await ctx.reply(`✅ Job created (ID: \`${job.id.slice(0, 8)}\`)\n${schedule.human_readable}\n${formatted}`, {
+                parse_mode: 'Markdown',
+            });
+        }
+        catch (err) {
+            await ctx.reply(`Failed to create job: ${err.message}`);
+        }
+    }
+    async handleChronosList(ctx) {
+        try {
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const repo = ChronosRepository.getInstance();
+            const jobs = repo.listJobs();
+            if (!jobs.length) {
+                await ctx.reply('No Chronos jobs found.');
+                return;
+            }
+            const lines = jobs.map((j, i) => {
+                const status = j.enabled ? '🟢' : '🔴';
+                const next = j.enabled && j.next_run_at
+                    ? new Date(j.next_run_at).toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
+                    : j.enabled ? 'N/A' : 'disabled';
+                const prompt = j.prompt.length > 35 ? j.prompt.slice(0, 35) + '…' : j.prompt;
+                return `${status} ${i + 1}. \`${j.id}\` \n${prompt}\n    _${next}_`;
+            });
+            await ctx.reply(`*Chronos Jobs*\n\n${lines.join('\n')}`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleChronosView(ctx, id) {
+        if (!id) {
+            await ctx.reply('Usage: /chronos_view <job_id>');
+            return;
+        }
+        try {
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const repo = ChronosRepository.getInstance();
+            const job = repo.getJob(id);
+            if (!job) {
+                await ctx.reply('Job not found.');
+                return;
+            }
+            const executions = repo.listExecutions(id, 3);
+            const next = job.next_run_at ? new Date(job.next_run_at).toLocaleString() : 'N/A';
+            const last = job.last_run_at ? new Date(job.last_run_at).toLocaleString() : 'Never';
+            const execLines = executions.map(e => `  • ${e.status.toUpperCase()} — ${new Date(e.triggered_at).toLocaleString()}`).join('\n') || '  None yet';
+            const msg = `*Chronos Job* \`${id.slice(0, 8)}\`\n\n` +
+                `*Prompt:* ${job.prompt}\n` +
+                `*Schedule:* ${job.schedule_type} — \`${job.schedule_expression}\`\n` +
+                `*Timezone:* ${job.timezone}\n` +
+                `*Status:* ${job.enabled ? 'Enabled' : 'Disabled'}\n` +
+                `*Next Run:* ${next}\n` +
+                `*Last Run:* ${last}\n\n` +
+                `*Last 3 Executions:*\n${execLines}`;
+            await ctx.reply(msg, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleChronosDisable(ctx, id) {
+        if (!id) {
+            await ctx.reply('Usage: /chronos_disable <job_id>');
+            return;
+        }
+        try {
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const repo = ChronosRepository.getInstance();
+            const job = repo.disableJob(id);
+            if (!job) {
+                await ctx.reply('Job not found.');
+                return;
+            }
+            await ctx.reply(`Job \`${id.slice(0, 8)}\` disabled.`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleChronosEnable(ctx, id) {
+        if (!id) {
+            await ctx.reply('Usage: /chronos_enable <job_id>');
+            return;
+        }
+        try {
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const { parseNextRun } = await import('../runtime/chronos/parser.js');
+            const repo = ChronosRepository.getInstance();
+            const existing = repo.getJob(id);
+            if (!existing) {
+                await ctx.reply('Job not found.');
+                return;
+            }
+            let nextRunAt;
+            if (existing.cron_normalized) {
+                // cron_normalized is always a 5-field cron string — use parseNextRun directly
+                nextRunAt = parseNextRun(existing.cron_normalized, existing.timezone);
+            }
+            repo.updateJob(id, { enabled: true, next_run_at: nextRunAt });
+            const job = repo.getJob(id);
+            const next = job.next_run_at ? new Date(job.next_run_at).toLocaleString() : 'N/A';
+            await ctx.reply(`Job \`${id.slice(0, 8)}\` enabled. Next run: ${next}`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleChronosDelete(ctx, id) {
+        if (!id) {
+            await ctx.reply('Usage: /chronos_delete <job_id>');
+            return;
+        }
+        try {
+            const { ChronosRepository } = await import('../runtime/chronos/repository.js');
+            const repo = ChronosRepository.getInstance();
+            const deleted = repo.deleteJob(id);
+            if (!deleted) {
+                await ctx.reply('Job not found.');
+                return;
+            }
+            await ctx.reply(`Job \`${id.slice(0, 8)}\` deleted.`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    // ─── End Chronos ──────────────────────────────────────────────────────────────
     async handleNewSessionCommand(ctx, user) {
         try {
             await ctx.reply("Are you ready to start a new session\\? Please confirm\\.", {
@@ -767,9 +1023,10 @@ export class TelegramAdapter {
     }
     async handleSessionStatusCommand(ctx, user) {
         try {
-            // Obter todas as sessões ativas e pausadas usando a nova função
             const history = new SQLiteChatMessageHistory({ sessionId: "" });
-            const sessions = await history.listSessions();
+            // Exclude automated Chronos sessions — their IDs exceed Telegram's 64-byte
+            // callback_data limit and they are not user-managed sessions.
+            const sessions = (await history.listSessions()).filter((s) => !s.id.startsWith('chronos-job-') && !s.id.startsWith('sati-evaluation'));
             if (sessions.length === 0) {
                 await ctx.reply('No active or paused sessions found\\.', { parse_mode: 'MarkdownV2' });
                 return;
@@ -779,10 +1036,10 @@ export class TelegramAdapter {
             for (const session of sessions) {
                 const title = session.title || 'Untitled Session';
                 const statusEmoji = session.status === 'active' ? '🟢' : '🟡';
-                response += `${statusEmoji} *${escMd(title)}*\n`;
-                response += `\\- ID: ${escMd(session.id)}\n`;
-                response += `\\- Status: ${escMd(session.status)}\n`;
-                response += `\\- Started: ${escMd(new Date(session.started_at).toLocaleString())}\n\n`;
+                response += `${statusEmoji} *${escMdRaw(title)}*\n`;
+                response += `\\- ID: \`${escMdRaw(session.id)}\`\n`;
+                response += `\\- Status: ${escMdRaw(session.status)}\n`;
+                response += `\\- Started: ${escMdRaw(new Date(session.started_at).toLocaleString())}\n\n`;
                 // Adicionar botão inline para alternar para esta sessão
                 const sessionButtons = [];
                 if (session.status !== 'active') {

package/dist/cli/commands/start.js

@@ -18,6 +18,8 @@ import { startSessionEmbeddingScheduler } from '../../runtime/session-embedding-
 import { TaskWorker } from '../../runtime/tasks/worker.js';
 import { TaskNotifier } from '../../runtime/tasks/notifier.js';
 import { TaskDispatcher } from '../../runtime/tasks/dispatcher.js';
+import { ChronosWorker } from '../../runtime/chronos/worker.js';
+import { ChronosRepository } from '../../runtime/chronos/repository.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -125,10 +127,13 @@ export const startCommand = new Command('start')
         const taskWorker = new TaskWorker();
         const taskNotifier = new TaskNotifier();
         const asyncTasksEnabled = config.runtime?.async_tasks?.enabled !== false;
+        const chronosRepo = ChronosRepository.getInstance();
+        const chronosWorker = new ChronosWorker(chronosRepo, oracle);
+        ChronosWorker.setInstance(chronosWorker);
         // Initialize Web UI
         if (options.ui && config.ui.enabled) {
             try {
-                httpServer = new HttpServer(oracle);
+                httpServer = new HttpServer(oracle, chronosWorker);
                 // Use CLI port if provided and valid, otherwise fallback to config or default
                 const port = parseInt(options.port) || config.ui.port || 3333;
                 httpServer.start(port);
@@ -146,6 +151,7 @@ export const startCommand = new Command('start')
                     // Wire Telegram adapter to webhook dispatcher for proactive notifications
                     WebhookDispatcher.setTelegramAdapter(telegram);
                     TaskDispatcher.setTelegramAdapter(telegram);
+                    ChronosWorker.setNotifyFn((text) => telegram.sendMessage(text));
                     adapters.push(telegram);
                 }
                 catch (e) {
@@ -158,6 +164,7 @@ export const startCommand = new Command('start')
         }
         // Start Background Services
         startSessionEmbeddingScheduler();
+        chronosWorker.start();
         if (asyncTasksEnabled) {
             taskWorker.start();
             taskNotifier.start();
@@ -176,6 +183,7 @@ export const startCommand = new Command('start')
             for (const adapter of adapters) {
                 await adapter.disconnect();
             }
+            chronosWorker.stop();
             if (asyncTasksEnabled) {
                 taskWorker.stop();
                 taskNotifier.stop();

package/dist/config/manager.js

@@ -186,6 +186,15 @@ export class ConfigManager {
         const memoryConfig = {
             limit: config.memory.limit // Not applying env var precedence to deprecated field
         };
+        // Apply precedence to Chronos config
+        let chronosConfig;
+        if (config.chronos) {
+            chronosConfig = {
+                timezone: resolveString('MORPHEUS_CHRONOS_TIMEZONE', config.chronos.timezone, 'UTC'),
+                check_interval_ms: resolveNumeric('MORPHEUS_CHRONOS_CHECK_INTERVAL_MS', config.chronos.check_interval_ms, 60000),
+                max_active_jobs: resolveNumeric('MORPHEUS_CHRONOS_MAX_ACTIVE_JOBS', config.chronos.max_active_jobs, 100),
+            };
+        }
         return {
             agent: agentConfig,
             llm: llmConfig,
@@ -197,7 +206,8 @@ export class ConfigManager {
             channels: channelsConfig,
             ui: uiConfig,
             logging: loggingConfig,
-            memory: memoryConfig
+            memory: memoryConfig,
+            chronos: chronosConfig,
         };
     }
     get() {
@@ -267,4 +277,11 @@ export class ConfigManager {
         // Fallback to main LLM config
         return { ...this.config.llm };
     }
+    getChronosConfig() {
+        const defaults = { timezone: 'UTC', check_interval_ms: 60000, max_active_jobs: 100 };
+        if (this.config.chronos) {
+            return { ...defaults, ...this.config.chronos };
+        }
+        return defaults;
+    }
 }

package/dist/config/schemas.js

@@ -31,6 +31,11 @@ export const TrinityConfigSchema = LLMConfigSchema;
 export const WebhookConfigSchema = z.object({
     telegram_notify_all: z.boolean().optional(),
 }).optional();
+export const ChronosConfigSchema = z.object({
+    timezone: z.string().default('UTC'),
+    check_interval_ms: z.number().min(60000).default(60000),
+    max_active_jobs: z.number().min(1).max(1000).default(100),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
@@ -52,6 +57,7 @@ export const ConfigSchema = z.object({
             enabled: z.boolean().default(DEFAULT_CONFIG.runtime?.async_tasks.enabled ?? true),
         }).default(DEFAULT_CONFIG.runtime?.async_tasks ?? { enabled: true }),
     }).optional(),
+    chronos: ChronosConfigSchema.optional(),
     channels: z.object({
         telegram: z.object({
             enabled: z.boolean().default(false),

package/dist/http/api.js

@@ -15,6 +15,9 @@ import { TaskRepository } from '../runtime/tasks/repository.js';
 import { DatabaseRegistry } from '../runtime/memory/trinity-db.js';
 import { testConnection, introspectSchema } from '../runtime/trinity-connector.js';
 import { Trinity } from '../runtime/trinity.js';
+import { ChronosRepository } from '../runtime/chronos/repository.js';
+import { ChronosWorker } from '../runtime/chronos/worker.js';
+import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -25,11 +28,18 @@ async function readLastLines(filePath, n) {
         return [];
     }
 }
-export function createApiRouter(oracle) {
+export function createApiRouter(oracle, chronosWorker) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
     const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
     const taskRepository = TaskRepository.getInstance();
+    const chronosRepo = ChronosRepository.getInstance();
+    const worker = chronosWorker ?? ChronosWorker.getInstance();
+    // Mount Chronos routers
+    if (worker) {
+        router.use('/chronos', createChronosJobRouter(chronosRepo, worker));
+        router.use('/config/chronos', createChronosConfigRouter(worker));
+    }
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {
@@ -248,6 +258,18 @@ export function createApiRouter(oracle) {
             res.status(500).json({ error: err.message });
         }
     });
+    router.post('/tasks/:id/cancel', (req, res) => {
+        try {
+            const ok = taskRepository.cancelTask(req.params.id);
+            if (!ok) {
+                return res.status(404).json({ error: 'Active task not found for cancellation' });
+            }
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // Legacy /session/reset (keep for backward compat or redirect to POST /sessions)
     router.post('/session/reset', async (req, res) => {
         try {
@@ -999,7 +1021,7 @@ export function createApiRouter(oracle) {
             return res.status(404).json({ error: 'Log file not found' });
         }
         const lines = await readLastLines(filePath, limit);
-        res.json({ lines: lines.reverse() });
+        res.json({ lines: lines });
     });
     return router;
 }