morpheus-cli 0.5.6 → 0.6.1

package/dist/runtime/memory/sqlite.js

@@ -9,8 +9,8 @@ import { DisplayManager } from "../display.js";
 export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     lc_namespace = ["langchain", "stores", "message", "sqlite"];
     display = DisplayManager.getInstance();
+    static migrationDone = false; // run migrations only once per process
     db;
-    dbSati; // Optional separate DB for Sati memory, if needed in the future
     sessionId;
     limit;
     titleSet = false; // cache: skip setSessionTitleIfNeeded after title is set
@@ -23,20 +23,16 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
         const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
-        const dbSatiPath = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
         // Ensure the directory exists
         this.ensureDirectory(dbPath);
-        this.ensureDirectory(dbSatiPath);
         // Initialize database with retry logic for locked databases
         try {
             this.db = new Database(dbPath, {
                 ...fields.config,
                 timeout: 5000, // 5 second timeout for locks
             });
-            this.dbSati = new Database(dbSatiPath, {
-                ...fields.config,
-                timeout: 5000,
-            });
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('synchronous = NORMAL');
             try {
                 this.ensureTable();
             }
@@ -172,6 +168,9 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      * Checks for missing columns and adds them if necessary.
      */
     migrateTable() {
+        if (SQLiteChatMessageHistory.migrationDone)
+            return;
+        SQLiteChatMessageHistory.migrationDone = true;
         try {
             // Migrate messages table
             const tableInfo = this.db.pragma('table_info(messages)');
@@ -669,6 +668,27 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         tx(); // Executar a transação
         this.display.log('✅ Nova sessão iniciada e sessão anterior pausada', { source: 'Sati' });
     }
+    chunkText(text, chunkSize = 500, overlap = 50) {
+        if (!text || text.length === 0)
+            return [];
+        const chunks = [];
+        let start = 0;
+        while (start < text.length) {
+            let end = start + chunkSize;
+            if (end < text.length) {
+                const lastSpace = text.lastIndexOf(' ', end);
+                if (lastSpace > start)
+                    end = lastSpace;
+            }
+            const chunk = text.slice(start, end).trim();
+            if (chunk.length > 0)
+                chunks.push(chunk);
+            start = end - overlap;
+            if (start < 0)
+                start = 0;
+        }
+        return chunks;
+    }
     /**
      * Encerrar uma sessão e transformá-la em memória do Sati.
      * Validar sessão existe e está em active ou paused.
@@ -711,30 +731,49 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
                 const sessionText = messages
                     .map(m => `[${m.type}] ${m.content}`)
                     .join('\n\n');
-                // Criar chunks (session_chunks) usando dbSati
-                if (this.dbSati) {
-                    const chunks = this.chunkText(sessionText);
-                    for (let i = 0; i < chunks.length; i++) {
-                        this.dbSati.prepare(`
-              INSERT INTO session_chunks (
-                id,
-                session_id,
-                chunk_index,
-                content,
-                created_at
-              ) VALUES (?, ?, ?, ?, ?)
-            `).run(randomUUID(), sessionId, i, chunks[i], now);
-                    }
-                    this.display.log(`🧩 ${chunks.length} chunks criados para sessão ${sessionId}`, { source: 'Sati' });
-                }
                 // Remover mensagens da sessão após criar os chunks
                 this.db.prepare(`
           DELETE FROM messages
           WHERE session_id = ?
         `).run(sessionId);
+                return sessionText;
             }
+            return null;
         });
-        tx(); // Executar a transação
+        const sessionText = tx(); // Executar a transação
+        // Criar chunks no banco Sati — conexão aberta localmente e fechada ao fim
+        if (sessionText) {
+            const dbSatiPath = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+            this.ensureDirectory(dbSatiPath);
+            const dbSati = new Database(dbSatiPath, { timeout: 5000 });
+            dbSati.pragma('journal_mode = WAL');
+            try {
+                dbSati.exec(`
+          CREATE TABLE IF NOT EXISTS session_chunks (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            chunk_index INTEGER NOT NULL,
+            content TEXT NOT NULL,
+            created_at INTEGER NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_session_chunks_session_id ON session_chunks(session_id);
+        `);
+                const chunks = this.chunkText(sessionText);
+                const now = Date.now();
+                const insert = dbSati.prepare(`
+          INSERT INTO session_chunks (id, session_id, chunk_index, content, created_at)
+          VALUES (?, ?, ?, ?, ?)
+        `);
+                const insertMany = dbSati.transaction((items) => {
+                    items.forEach((chunk, i) => insert.run(randomUUID(), sessionId, i, chunk, now));
+                });
+                insertMany(chunks);
+                this.display.log(`${chunks.length} chunks criados para sessão ${sessionId}`, { source: 'Sati' });
+            }
+            finally {
+                dbSati.close();
+            }
+        }
     }
     /**
      * Descartar completamente uma sessão sem gerar memória.
@@ -828,6 +867,16 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      * Se já for active, não faz nada.
      * Transação: sessão atual active → paused, sessão alvo → active.
      */
+    /**
+     * Creates a session row with status 'paused' if it doesn't already exist.
+     * Safe to call multiple times — idempotent.
+     */
+    ensureSession(sessionId) {
+        const existing = this.db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
+        if (!existing) {
+            this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'paused')").run(sessionId, Date.now());
+        }
+    }
     async switchSession(targetSessionId) {
         // Validar sessão alvo: existe e status ∈ (paused, active)
         const targetSession = this.db.prepare(`
@@ -909,31 +958,6 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
   `).run(newId, now);
         return newId;
     }
-    chunkText(text, chunkSize = 500, overlap = 50) {
-        if (!text || text.length === 0) {
-            return [];
-        }
-        const chunks = [];
-        let start = 0;
-        while (start < text.length) {
-            let end = start + chunkSize;
-            // Evita cortar no meio da palavra
-            if (end < text.length) {
-                const lastSpace = text.lastIndexOf(' ', end);
-                if (lastSpace > start) {
-                    end = lastSpace;
-                }
-            }
-            const chunk = text.slice(start, end).trim();
-            if (chunk.length > 0) {
-                chunks.push(chunk);
-            }
-            start = end - overlap;
-            if (start < 0)
-                start = 0;
-        }
-        return chunks;
-    }
     /**
      * Lists all active and paused sessions with their basic information.
      * Returns an array of session objects containing id, title, status, and started_at.

package/dist/runtime/oracle.js

@@ -13,7 +13,7 @@ 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 { TaskQueryTool } from "./tools/index.js";
+import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { MCPManager } from "../config/mcp-manager.js";
 export class Oracle {
     provider;
@@ -129,7 +129,7 @@ export class Oracle {
             // Fail-open: Oracle can still initialize even if catalog refresh fails.
             await Neo.refreshDelegateCatalog().catch(() => { });
             await Trinity.refreshDelegateCatalog().catch(() => { });
-            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool]);
+            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, timeVerifierTool, ...chronosTools]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -175,12 +175,20 @@ You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
 
 You are an orchestrator and task router.
 
+If the user request contains ANY time-related expression
+(today, tomorrow, this week, next month, in 3 days, etc),
+you **MUST** call the tool "time_verifier" before answering or call another tool **ALWAYS**.
+
+With the time_verify, you remake the user prompt.
+
+Never assume dates.
+Always resolve temporal expressions using the tool.
 
 Rules:
 1. For conversation-only requests (greetings, conceptual explanation, memory follow-up, statements of fact, sharing personal information), answer directly. DO NOT create tasks or delegate for simple statements like "I have two cats" or "My name is John". Sati will automatically memorize facts in the background ( **ALWAYS** use SATI Memories to review or retrieve these facts if needed).
 **NEVER** Create data, use SATI memories to response on informal conversation or say that dont know abaout the awsor if the answer is in the memories. Always use the memories as source of truth for user facts, preferences, stable context and informal conversation. Use tools only for execution, verification or when external/system state is required.*
 2. For requests that require execution, verification, external/system state, or non-trivial operations, evaluate the available tools and choose the best one.
-3. For task status/check questions (for example: "consultou?", "status da task", "andamento"), use task_query directly and do not delegate.
+3. For task status/check questions (for example: "consultou?", "status da task", "andamento"), use task_query directly and do not delegate. (normalize o id to downcase to send to task_query)
 4. Prefer delegation tools when execution should be asynchronous, and return the task acknowledgement clearly.
 5. If the user asked for multiple independent actions in the same message, enqueue one delegated task per action. Each task must be atomic (single objective).
 6. If the user asked for a single action, do not create additional delegated tasks.
@@ -310,6 +318,9 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 // Persist with addMessage so ack-provider usage is tracked per message row.
                 await this.history.addMessage(userMessage);
                 await this.history.addMessage(ackMessage);
+                // Unblock tasks for execution: the ack message is now persisted and will be
+                // 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) {
                 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" });
@@ -422,6 +433,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
             // `this.history = new SQLiteChatMessageHistory({ sessionId: sessionId, ... })`
             //
             // This is safe and clean.
+            // Ensure the target session exists before switching (creates as 'paused' if not found).
+            this.history.ensureSession(sessionId);
             await this.history.switchSession(sessionId);
             // Close previous connection before re-instantiating to avoid file handle leaks
             this.history.close();
@@ -436,6 +449,17 @@ Use it to inform your response and tool selection (if needed), but do not assume
             throw new Error("Current history provider does not support session switching.");
         }
     }
+    getCurrentSessionId() {
+        if (this.history instanceof SQLiteChatMessageHistory) {
+            return this.history.currentSessionId || null;
+        }
+        return null;
+    }
+    async injectAIMessage(content) {
+        if (!this.history)
+            throw new Error('Oracle not initialized.');
+        await this.history.addMessages([new AIMessage(content)]);
+    }
     async clearMemory() {
         if (!this.history) {
             throw new Error("Message history not initialized. Call initialize() first.");
@@ -448,7 +472,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
         }
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool]);
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, ...chronosTools]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }

package/dist/runtime/providers/factory.js

@@ -15,7 +15,7 @@ export class ProviderFactory {
                 display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ConstructLoad' });
                 try {
                     const result = handler(request);
-                    display.log("Tool completed successfully", { level: "info", source: 'ConstructLoad' });
+                    display.log(`Tool completed successfully. Result: ${JSON.stringify(result)}`, { level: "info", source: 'ConstructLoad' });
                     return result;
                 }
                 catch (e) {

package/dist/runtime/tasks/repository.js

@@ -61,6 +61,7 @@ export class TaskRepository {
         addColumn(`ALTER TABLE tasks ADD COLUMN notify_last_error TEXT`, 'notify_last_error');
         addColumn(`ALTER TABLE tasks ADD COLUMN notified_at INTEGER`, 'notified_at');
         addColumn(`ALTER TABLE tasks ADD COLUMN notify_after_at INTEGER`, 'notify_after_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN ack_sent INTEGER NOT NULL DEFAULT 0`, 'ack_sent');
         this.db.exec(`
       UPDATE tasks
       SET
@@ -108,6 +109,7 @@ export class TaskRepository {
             notify_last_error: row.notify_last_error ?? null,
             notified_at: row.notified_at ?? null,
             notify_after_at: row.notify_after_at ?? null,
+            ack_sent: row.ack_sent === 1,
         };
     }
     /**
@@ -115,16 +117,20 @@ export class TaskRepository {
      * acknowledgement and the task result share the same delivery path (e.g. Telegram).
      * Channels with a synchronous ack (ui, api, cli, webhook) don't need this delay.
      */
-    static DEFAULT_NOTIFY_AFTER_MS = 10_000;
+    static DEFAULT_NOTIFY_AFTER_MS = 1_000;
     static CHANNELS_NEEDING_ACK_GRACE = new Set(['telegram', 'discord']);
     createTask(input) {
         const now = Date.now();
         const id = randomUUID();
+        const needsAck = TaskRepository.CHANNELS_NEEDING_ACK_GRACE.has(input.origin_channel);
         const notify_after_at = input.notify_after_at !== undefined
             ? input.notify_after_at
-            : TaskRepository.CHANNELS_NEEDING_ACK_GRACE.has(input.origin_channel)
+            : needsAck
                 ? now + TaskRepository.DEFAULT_NOTIFY_AFTER_MS
                 : null;
+        // ack_sent starts as 0 (blocked) for channels that send an ack message (telegram, discord).
+        // For other channels (ui, api, webhook, cli) there is no ack to wait for, so start as 1 (free).
+        const ack_sent = needsAck ? 0 : 1;
         this.db.prepare(`
       INSERT INTO tasks (
         id, agent, status, input, context, output, error,
@@ -132,16 +138,16 @@ export class TaskRepository {
         attempt_count, max_attempts, available_at,
         created_at, started_at, finished_at, updated_at, worker_id,
         notify_status, notify_attempts, notify_last_error, notified_at,
-        notify_after_at
+        notify_after_at, ack_sent
       ) VALUES (
         ?, ?, 'pending', ?, ?, NULL, NULL,
         ?, ?, ?, ?,
         0, ?, ?,
         ?, NULL, NULL, ?, NULL,
         'pending', 0, NULL, NULL,
-        ?
+        ?, ?
       )
-    `).run(id, input.agent, input.input, input.context ?? null, input.origin_channel, input.session_id, input.origin_message_id ?? null, input.origin_user_id ?? null, input.max_attempts ?? 3, now, now, now, notify_after_at);
+    `).run(id, input.agent, input.input, input.context ?? null, input.origin_channel, input.session_id, input.origin_message_id ?? null, input.origin_user_id ?? null, input.max_attempts ?? 3, now, now, now, notify_after_at, ack_sent);
         return this.getTaskById(id);
     }
     getTaskById(id) {
@@ -199,16 +205,27 @@ export class TaskRepository {
         }
         return stats;
     }
+    /** Mark ack as sent for a list of task IDs, unblocking them for execution. */
+    markAckSent(ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        this.db.prepare(`UPDATE tasks SET ack_sent = 1, updated_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
+    }
+    /** Fallback grace period (ms): tasks older than this run even without ack_sent. */
+    static ACK_FALLBACK_MS = 60_000;
     claimNextPending(workerId) {
         const now = Date.now();
         const tx = this.db.transaction(() => {
             const row = this.db.prepare(`
         SELECT id
         FROM tasks
-        WHERE status = 'pending' AND available_at <= ?
+        WHERE status = 'pending'
+          AND available_at <= ?
+          AND (ack_sent = 1 OR created_at <= ?)
         ORDER BY created_at ASC
         LIMIT 1
-      `).get(now);
+      `).get(now, now - TaskRepository.ACK_FALLBACK_MS);
             if (!row)
                 return null;
             const result = this.db.prepare(`

package/dist/runtime/tasks/worker.js

@@ -8,14 +8,16 @@ export class TaskWorker {
     workerId;
     pollIntervalMs;
     staleRunningMs;
+    maxConcurrent;
     repository = TaskRepository.getInstance();
     display = DisplayManager.getInstance();
     timer = null;
-    running = false;
+    activeTasks = new Set(); // task IDs currently executing
     constructor(opts) {
         this.workerId = `task-worker-${randomUUID().slice(0, 8)}`;
-        this.pollIntervalMs = opts?.pollIntervalMs ?? 1000;
+        this.pollIntervalMs = opts?.pollIntervalMs ?? 300;
         this.staleRunningMs = opts?.staleRunningMs ?? 5 * 60 * 1000;
+        this.maxConcurrent = opts?.maxConcurrent ?? parseInt(process.env.MORPHEUS_TASK_CONCURRENCY ?? '3', 10);
     }
     start() {
         if (this.timer)
@@ -25,7 +27,7 @@ export class TaskWorker {
             this.display.log(`Recovered ${recovered} stale running task(s).`, { source: 'TaskWorker', level: 'warning' });
         }
         this.timer = setInterval(() => {
-            void this.tick();
+            this.tick();
         }, this.pollIntervalMs);
         this.display.log(`Task worker started (${this.workerId}).`, { source: 'TaskWorker' });
     }
@@ -36,19 +38,14 @@ export class TaskWorker {
             this.display.log(`Task worker stopped (${this.workerId}).`, { source: 'TaskWorker' });
         }
     }
-    async tick() {
-        if (this.running)
+    tick() {
+        if (this.activeTasks.size >= this.maxConcurrent)
             return;
-        this.running = true;
-        try {
-            const task = this.repository.claimNextPending(this.workerId);
-            if (!task)
-                return;
-            await this.executeTask(task);
-        }
-        finally {
-            this.running = false;
-        }
+        const task = this.repository.claimNextPending(this.workerId);
+        if (!task)
+            return;
+        this.activeTasks.add(task.id);
+        this.executeTask(task).finally(() => this.activeTasks.delete(task.id));
     }
     async executeTask(task) {
         try {

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

@@ -0,0 +1,181 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { ChronosRepository } from '../chronos/repository.js';
+import { parseScheduleExpression, getNextOccurrences } from '../chronos/parser.js';
+import { ConfigManager } from '../../config/manager.js';
+import { ChronosWorker } from '../chronos/worker.js';
+// ─── chronos_schedule ────────────────────────────────────────────────────────
+export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule_expression, timezone }) => {
+    if (ChronosWorker.isExecuting) {
+        return JSON.stringify({ success: false, error: 'Cannot create a new Chronos job from within an active Chronos execution.' });
+    }
+    try {
+        const cfg = ConfigManager.getInstance().getChronosConfig();
+        const tz = timezone ?? cfg.timezone;
+        const parsed = parseScheduleExpression(schedule_expression, schedule_type, { timezone: tz });
+        const repo = ChronosRepository.getInstance();
+        const job = repo.createJob({
+            prompt,
+            schedule_type,
+            schedule_expression,
+            timezone: tz,
+            next_run_at: parsed.next_run_at,
+            cron_normalized: parsed.cron_normalized,
+            created_by: 'oracle',
+        });
+        return JSON.stringify({
+            success: true,
+            job_id: job.id,
+            prompt: job.prompt,
+            schedule_type: job.schedule_type,
+            human_readable: parsed.human_readable,
+            next_run_at: job.next_run_at != null ? new Date(job.next_run_at).toISOString() : null,
+            timezone: job.timezone,
+        });
+    }
+    catch (err) {
+        return JSON.stringify({ success: false, error: err.message });
+    }
+}, {
+    name: 'chronos_schedule',
+    description: 'Schedule a prompt to be sent to the Oracle at a future time. ' +
+        'Use schedule_type "once" for a single execution (e.g. "tomorrow at 9am", "in 2 hours", "2026-03-01T09:00:00"), ' +
+        '"cron" for a recurring cron expression (e.g. "0 9 * * 1-5" = every weekday at 9am), ' +
+        '"interval" for natural interval phrases (e.g. "every 30 minutes", "every 2 hours", "every day"). ' +
+        'Returns the created job ID and the human-readable schedule confirmation.',
+    schema: z.object({
+        prompt: z.string().describe('The prompt text to send to Oracle at the scheduled time.'),
+        schedule_type: z
+            .enum(['once', 'cron', 'interval'])
+            .describe('"once" for one-time, "cron" for cron expression, "interval" for natural phrase.'),
+        schedule_expression: z
+            .string()
+            .describe('The schedule expression. For "once": ISO datetime or natural language like "tomorrow at 9am". ' +
+            'For "cron": 5-field cron expression like "0 9 * * *". ' +
+            'For "interval": phrase like "every 30 minutes" or "every 2 hours".'),
+        timezone: z
+            .string()
+            .optional()
+            .describe('IANA timezone (e.g. "America/Sao_Paulo"). Defaults to the global Chronos timezone config.'),
+    }),
+});
+// ─── chronos_list ────────────────────────────────────────────────────────────
+export const ChronosListTool = tool(async ({ enabled_only }) => {
+    try {
+        const repo = ChronosRepository.getInstance();
+        const jobs = repo.listJobs(enabled_only !== false ? { enabled: true } : {});
+        if (jobs.length === 0) {
+            return JSON.stringify({ success: true, jobs: [], message: 'No Chronos jobs found.' });
+        }
+        const summary = jobs.map((j) => ({
+            id: j.id,
+            prompt: j.prompt.length > 80 ? j.prompt.slice(0, 80) + '…' : j.prompt,
+            schedule_type: j.schedule_type,
+            schedule_expression: j.schedule_expression,
+            next_run_at: j.next_run_at != null ? new Date(j.next_run_at).toISOString() : null,
+            last_run_at: j.last_run_at != null ? new Date(j.last_run_at).toISOString() : null,
+            enabled: j.enabled,
+            timezone: j.timezone,
+            created_by: j.created_by,
+        }));
+        return JSON.stringify({ success: true, jobs: summary, total: jobs.length });
+    }
+    catch (err) {
+        return JSON.stringify({ success: false, error: err.message });
+    }
+}, {
+    name: 'chronos_list',
+    description: 'List Chronos scheduled jobs. By default only returns enabled (active) jobs. ' +
+        'Set enabled_only to false to include disabled jobs too.',
+    schema: z.object({
+        enabled_only: z
+            .boolean()
+            .optional()
+            .describe('If true (default), only return enabled jobs. Set to false to include disabled ones.'),
+    }),
+});
+// ─── chronos_cancel ──────────────────────────────────────────────────────────
+export const ChronosCancelTool = tool(async ({ job_id, action }) => {
+    if (ChronosWorker.isExecuting) {
+        return JSON.stringify({ success: false, error: 'Cannot manage Chronos jobs from within an active Chronos execution. Respond to the user normally without modifying the job.' });
+    }
+    try {
+        const repo = ChronosRepository.getInstance();
+        const job = repo.getJob(job_id);
+        if (!job) {
+            return JSON.stringify({ success: false, error: `No job found with id "${job_id}".` });
+        }
+        if (action === 'delete') {
+            repo.deleteJob(job_id);
+            return JSON.stringify({ success: true, message: `Job "${job_id}" deleted.` });
+        }
+        else if (action === 'disable') {
+            repo.disableJob(job_id);
+            return JSON.stringify({ success: true, message: `Job "${job_id}" disabled. It can be re-enabled later.` });
+        }
+        else {
+            repo.enableJob(job_id);
+            return JSON.stringify({ success: true, message: `Job "${job_id}" enabled.` });
+        }
+    }
+    catch (err) {
+        return JSON.stringify({ success: false, error: err.message });
+    }
+}, {
+    name: 'chronos_cancel',
+    description: 'Manage an existing Chronos job: disable it (pause without losing it), enable it again, or permanently delete it. ' +
+        'Use "disable" to pause a recurring job, "delete" to remove it permanently, "enable" to resume a disabled job.',
+    schema: z.object({
+        job_id: z.string().describe('The UUID of the Chronos job to manage.'),
+        action: z
+            .enum(['disable', 'enable', 'delete'])
+            .describe('"disable" pauses the job, "enable" resumes it, "delete" removes it permanently.'),
+    }),
+});
+// ─── chronos_preview ─────────────────────────────────────────────────────────
+export const ChronosPreviewTool = tool(async ({ schedule_type, schedule_expression, timezone, occurrences }) => {
+    try {
+        const cfg = ConfigManager.getInstance().getChronosConfig();
+        const tz = timezone ?? cfg.timezone;
+        const count = occurrences ?? 3;
+        const parsed = parseScheduleExpression(schedule_expression, schedule_type, { timezone: tz });
+        let next_occurrences = [];
+        if (schedule_type !== 'once' && parsed.cron_normalized) {
+            const timestamps = getNextOccurrences(parsed.cron_normalized, tz, count);
+            next_occurrences = timestamps.map((ts) => new Date(ts).toISOString());
+        }
+        return JSON.stringify({
+            success: true,
+            valid: true,
+            human_readable: parsed.human_readable,
+            next_run_at: new Date(parsed.next_run_at).toISOString(),
+            next_occurrences,
+            timezone: tz,
+        });
+    }
+    catch (err) {
+        return JSON.stringify({ success: false, valid: false, error: err.message });
+    }
+}, {
+    name: 'chronos_preview',
+    description: 'Preview a schedule expression without creating a job. ' +
+        'Shows when the job would next run and the human-readable description. ' +
+        'Useful for confirming a schedule before committing to it.',
+    schema: z.object({
+        schedule_type: z.enum(['once', 'cron', 'interval']).describe('Type of schedule expression.'),
+        schedule_expression: z.string().describe('The schedule expression to validate and preview.'),
+        timezone: z.string().optional().describe('IANA timezone. Defaults to global Chronos timezone.'),
+        occurrences: z
+            .number()
+            .min(1)
+            .max(10)
+            .optional()
+            .describe('How many future occurrences to show for recurring schedules (default 3).'),
+    }),
+});
+export const chronosTools = [
+    ChronosScheduleTool,
+    ChronosListTool,
+    ChronosCancelTool,
+    ChronosPreviewTool,
+];

package/dist/runtime/tools/index.js

@@ -2,3 +2,5 @@
 export * from './morpheus-tools.js';
 export * from './apoc-tool.js';
 export * from './neo-tool.js';
+export * from './chronos-tools.js';
+export * from './time-verify-tools.js';