morpheus-cli 0.5.5 → 0.6.0

package/dist/runtime/chronos/repository.js

@@ -0,0 +1,244 @@
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { ConfigManager } from '../../config/manager.js';
+export class ChronosError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ChronosError';
+    }
+}
+export class ChronosRepository {
+    static instance = null;
+    db;
+    constructor() {
+        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        fs.ensureDirSync(path.dirname(dbPath));
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.ensureTable();
+    }
+    static getInstance() {
+        if (!ChronosRepository.instance) {
+            ChronosRepository.instance = new ChronosRepository();
+        }
+        return ChronosRepository.instance;
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chronos_jobs (
+        id TEXT PRIMARY KEY
+      );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chronos_executions (
+        id TEXT PRIMARY KEY
+      );
+    `);
+        this.migrateTable();
+        this.ensureIndexes();
+    }
+    migrateTable() {
+        const jobInfo = this.db.pragma('table_info(chronos_jobs)');
+        const jobCols = new Set(jobInfo.map((c) => c.name));
+        const addJobCol = (sql, col) => {
+            if (jobCols.has(col))
+                return;
+            this.db.exec(sql);
+            jobCols.add(col);
+        };
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN prompt TEXT NOT NULL DEFAULT ''`, 'prompt');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN schedule_type TEXT NOT NULL DEFAULT 'once'`, 'schedule_type');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN schedule_expression TEXT NOT NULL DEFAULT ''`, 'schedule_expression');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN cron_normalized TEXT`, 'cron_normalized');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN timezone TEXT NOT NULL DEFAULT 'UTC'`, 'timezone');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN next_run_at INTEGER`, 'next_run_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN last_run_at INTEGER`, 'last_run_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1`, 'enabled');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0`, 'created_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_by TEXT NOT NULL DEFAULT 'api'`, 'created_by');
+        const execInfo = this.db.pragma('table_info(chronos_executions)');
+        const execCols = new Set(execInfo.map((c) => c.name));
+        const addExecCol = (sql, col) => {
+            if (execCols.has(col))
+                return;
+            this.db.exec(sql);
+            execCols.add(col);
+        };
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN job_id TEXT NOT NULL DEFAULT ''`, 'job_id');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN triggered_at INTEGER NOT NULL DEFAULT 0`, 'triggered_at');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN completed_at INTEGER`, 'completed_at');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN status TEXT NOT NULL DEFAULT 'running'`, 'status');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN error TEXT`, 'error');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN session_id TEXT NOT NULL DEFAULT ''`, 'session_id');
+    }
+    ensureIndexes() {
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_chronos_jobs_next_run
+        ON chronos_jobs (enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_chronos_jobs_created_by
+        ON chronos_jobs (created_by);
+      CREATE INDEX IF NOT EXISTS idx_chronos_executions_job
+        ON chronos_executions (job_id, triggered_at DESC);
+    `);
+    }
+    deserializeJob(row) {
+        return {
+            id: row.id,
+            prompt: row.prompt,
+            schedule_type: row.schedule_type,
+            schedule_expression: row.schedule_expression,
+            cron_normalized: row.cron_normalized ?? null,
+            timezone: row.timezone,
+            next_run_at: row.next_run_at ?? null,
+            last_run_at: row.last_run_at ?? null,
+            enabled: row.enabled === 1,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            created_by: row.created_by,
+        };
+    }
+    deserializeExecution(row) {
+        return {
+            id: row.id,
+            job_id: row.job_id,
+            triggered_at: row.triggered_at,
+            completed_at: row.completed_at ?? null,
+            status: row.status,
+            error: row.error ?? null,
+            session_id: row.session_id,
+        };
+    }
+    // ─── T036: max_active_jobs enforcement ────────────────────────────────────
+    createJob(input) {
+        const cfg = ConfigManager.getInstance().getChronosConfig();
+        const activeCount = this.db.prepare(`SELECT COUNT(*) as cnt FROM chronos_jobs WHERE enabled = 1`).get().cnt;
+        if (activeCount >= cfg.max_active_jobs) {
+            throw new ChronosError(`Maximum active jobs limit (${cfg.max_active_jobs}) reached. Disable or delete an existing job first.`);
+        }
+        const now = Date.now();
+        const id = randomUUID();
+        this.db.prepare(`
+      INSERT INTO chronos_jobs (
+        id, prompt, schedule_type, schedule_expression, cron_normalized,
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?)
+    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by);
+        return this.getJob(id);
+    }
+    getJob(id) {
+        const row = this.db.prepare('SELECT * FROM chronos_jobs WHERE id = ?').get(id);
+        return row ? this.deserializeJob(row) : null;
+    }
+    listJobs(filters) {
+        const params = [];
+        let query = 'SELECT * FROM chronos_jobs WHERE 1=1';
+        if (filters?.enabled !== undefined) {
+            query += ' AND enabled = ?';
+            params.push(filters.enabled ? 1 : 0);
+        }
+        if (filters?.created_by) {
+            query += ' AND created_by = ?';
+            params.push(filters.created_by);
+        }
+        query += ' ORDER BY created_at DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((r) => this.deserializeJob(r));
+    }
+    updateJob(id, patch) {
+        const now = Date.now();
+        const sets = ['updated_at = ?'];
+        const params = [now];
+        if (patch.prompt !== undefined) {
+            sets.push('prompt = ?');
+            params.push(patch.prompt);
+        }
+        if (patch.schedule_expression !== undefined) {
+            sets.push('schedule_expression = ?');
+            params.push(patch.schedule_expression);
+        }
+        if ('cron_normalized' in patch) {
+            sets.push('cron_normalized = ?');
+            params.push(patch.cron_normalized ?? null);
+        }
+        if (patch.timezone !== undefined) {
+            sets.push('timezone = ?');
+            params.push(patch.timezone);
+        }
+        if ('next_run_at' in patch) {
+            sets.push('next_run_at = ?');
+            params.push(patch.next_run_at ?? null);
+        }
+        if ('last_run_at' in patch) {
+            sets.push('last_run_at = ?');
+            params.push(patch.last_run_at ?? null);
+        }
+        if (patch.enabled !== undefined) {
+            sets.push('enabled = ?');
+            params.push(patch.enabled ? 1 : 0);
+        }
+        params.push(id);
+        this.db.prepare(`UPDATE chronos_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+        return this.getJob(id);
+    }
+    deleteJob(id) {
+        const result = this.db.prepare('DELETE FROM chronos_jobs WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    getDueJobs(nowMs) {
+        const rows = this.db.prepare(`
+      SELECT * FROM chronos_jobs
+      WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?
+      ORDER BY next_run_at ASC
+    `).all(nowMs);
+        return rows.map((r) => this.deserializeJob(r));
+    }
+    enableJob(id) {
+        const now = Date.now();
+        this.db.prepare(`UPDATE chronos_jobs SET enabled = 1, updated_at = ? WHERE id = ?`).run(now, id);
+        return this.getJob(id);
+    }
+    disableJob(id) {
+        const now = Date.now();
+        this.db.prepare(`UPDATE chronos_jobs SET enabled = 0, next_run_at = NULL, updated_at = ? WHERE id = ?`).run(now, id);
+        return this.getJob(id);
+    }
+    // ─── Executions ───────────────────────────────────────────────────────────
+    insertExecution(record) {
+        this.db.prepare(`
+      INSERT INTO chronos_executions (id, job_id, triggered_at, completed_at, status, error, session_id)
+      VALUES (?, ?, ?, NULL, ?, NULL, ?)
+    `).run(record.id, record.job_id, record.triggered_at, record.status, record.session_id);
+    }
+    completeExecution(id, status, error) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE chronos_executions SET status = ?, completed_at = ?, error = ? WHERE id = ?
+    `).run(status, now, error ?? null, id);
+    }
+    listExecutions(jobId, limit = 50) {
+        const rows = this.db.prepare(`
+      SELECT * FROM chronos_executions WHERE job_id = ?
+      ORDER BY triggered_at DESC LIMIT ?
+    `).all(jobId, Math.min(limit, 100));
+        return rows.map((r) => this.deserializeExecution(r));
+    }
+    pruneExecutions(jobId, keepCount) {
+        this.db.prepare(`
+      DELETE FROM chronos_executions
+      WHERE job_id = ? AND id NOT IN (
+        SELECT id FROM chronos_executions
+        WHERE job_id = ?
+        ORDER BY triggered_at DESC
+        LIMIT ?
+      )
+    `).run(jobId, jobId, keepCount);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/runtime/chronos/worker.js

@@ -0,0 +1,141 @@
+import { randomUUID } from 'crypto';
+import { ConfigManager } from '../../config/manager.js';
+import { DisplayManager } from '../display.js';
+import { parseNextRun } from './parser.js';
+export class ChronosWorker {
+    repo;
+    oracle;
+    static instance = null;
+    static notifyFn = null;
+    /**
+     * True while a Chronos job is being executed. Chronos management tools
+     * (chronos_cancel, chronos_schedule) check this flag and refuse to operate
+     * during execution to prevent the Oracle from self-deleting or re-scheduling
+     * the active job.
+     */
+    static isExecuting = false;
+    timer = null;
+    isRunning = false;
+    pollIntervalMs;
+    constructor(repo, oracle) {
+        this.repo = repo;
+        this.oracle = oracle;
+        this.pollIntervalMs = ConfigManager.getInstance().getChronosConfig().check_interval_ms;
+    }
+    static getInstance() {
+        return ChronosWorker.instance;
+    }
+    static setInstance(worker) {
+        ChronosWorker.instance = worker;
+    }
+    /** Register a function that will deliver Oracle responses to users (e.g. Telegram). */
+    static setNotifyFn(fn) {
+        ChronosWorker.notifyFn = fn;
+    }
+    start() {
+        if (this.timer)
+            return;
+        const display = DisplayManager.getInstance();
+        display.log(`Worker started (interval: ${this.pollIntervalMs}ms)`, { source: 'Chronos' });
+        this.timer = setInterval(() => void this.tick(), this.pollIntervalMs);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const display = DisplayManager.getInstance();
+        display.log('Worker stopped', { source: 'Chronos' });
+    }
+    /** Hot-reload poll interval without restarting the process */
+    updateInterval(newMs) {
+        if (newMs < 60000)
+            return;
+        this.pollIntervalMs = newMs;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = setInterval(() => void this.tick(), this.pollIntervalMs);
+        }
+        const display = DisplayManager.getInstance();
+        display.log(`Worker interval updated to ${newMs}ms`, { source: 'Chronos' });
+    }
+    async tick() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        try {
+            const dueJobs = this.repo.getDueJobs(Date.now());
+            for (const job of dueJobs) {
+                void this.executeJob(job);
+            }
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    async executeJob(job) {
+        const display = DisplayManager.getInstance();
+        const execId = randomUUID();
+        display.log(`Job ${job.id} triggered — "${job.prompt.slice(0, 60)}"`, { source: 'Chronos' });
+        // Use the currently active Oracle session so Chronos executes in the
+        // user's conversation context — no session switching or isolation needed.
+        const activeSessionId = this.oracle.getCurrentSessionId() ?? 'default';
+        this.repo.insertExecution({
+            id: execId,
+            job_id: job.id,
+            triggered_at: Date.now(),
+            status: 'running',
+            session_id: activeSessionId,
+        });
+        try {
+            // Inject execution context as an AI message so it appears naturally in the
+            // conversation history without triggering an extra LLM response.
+            const contextMessage = `[CHRONOS EXECUTION — job_id: ${job.id}]\n` +
+                `Executing scheduled job. Do NOT call chronos_cancel, chronos_schedule, ` +
+                `or any Chronos management tools during this execution.`;
+            await this.oracle.injectAIMessage(contextMessage);
+            // If a Telegram notify function is registered, tag delegated tasks with
+            // origin_channel: 'telegram' so the TaskDispatcher broadcasts their result.
+            const taskContext = ChronosWorker.notifyFn
+                ? { origin_channel: 'telegram', session_id: activeSessionId }
+                : undefined;
+            // Hard-block Chronos management tools during execution.
+            ChronosWorker.isExecuting = true;
+            const response = await this.oracle.chat(job.prompt, undefined, false, taskContext);
+            this.repo.completeExecution(execId, 'success');
+            display.log(`Job ${job.id} completed — status: success`, { source: 'Chronos' });
+            // Deliver Oracle response to notification channels.
+            await this.notify(job, response);
+        }
+        catch (err) {
+            const errMsg = err?.message ?? String(err);
+            this.repo.completeExecution(execId, 'failed', errMsg);
+            display.log(`Job ${job.id} failed — ${errMsg}`, { source: 'Chronos', level: 'error' });
+        }
+        finally {
+            ChronosWorker.isExecuting = false;
+            if (job.schedule_type === 'once') {
+                this.repo.disableJob(job.id);
+                display.log(`Job ${job.id} auto-disabled (once-type)`, { source: 'Chronos' });
+            }
+            else if (job.cron_normalized) {
+                const nextRunAt = parseNextRun(job.cron_normalized, job.timezone);
+                this.repo.updateJob(job.id, { next_run_at: nextRunAt, last_run_at: Date.now() });
+                display.log(`Job ${job.id} rescheduled — next_run_at: ${new Date(nextRunAt).toISOString()}`, { source: 'Chronos' });
+            }
+            this.repo.pruneExecutions(job.id, 100);
+        }
+    }
+    async notify(job, response) {
+        if (!ChronosWorker.notifyFn)
+            return;
+        const display = DisplayManager.getInstance();
+        const header = `⏰ *Chronos* — _${job.prompt.slice(0, 80)}${job.prompt.length > 80 ? '…' : ''}_\n\n`;
+        try {
+            await ChronosWorker.notifyFn(header + response);
+        }
+        catch (err) {
+            display.log(`Job ${job.id} notification failed — ${err.message}`, { source: 'Chronos', level: 'error' });
+        }
+    }
+}

package/dist/runtime/chronos/worker.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ChronosWorker } from './worker.js';
+// Mock ConfigManager and DisplayManager
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: () => ({
+            getChronosConfig: () => ({ timezone: 'UTC', check_interval_ms: 60000, max_active_jobs: 100 }),
+        }),
+    },
+}));
+vi.mock('../display.js', () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        }),
+    },
+}));
+function makeJob(overrides = {}) {
+    return {
+        id: 'job-1',
+        prompt: 'Say hello',
+        schedule_type: 'once',
+        schedule_expression: 'in 1 hour',
+        cron_normalized: null,
+        timezone: 'UTC',
+        next_run_at: Date.now() - 1000,
+        last_run_at: null,
+        enabled: true,
+        created_at: Date.now() - 5000,
+        updated_at: Date.now() - 5000,
+        created_by: 'ui',
+        ...overrides,
+    };
+}
+function makeRepo(jobs = []) {
+    return {
+        getDueJobs: vi.fn().mockReturnValue(jobs),
+        insertExecution: vi.fn(),
+        completeExecution: vi.fn(),
+        disableJob: vi.fn(),
+        enableJob: vi.fn(),
+        updateJob: vi.fn(),
+        pruneExecutions: vi.fn(),
+        createJob: vi.fn(),
+        getJob: vi.fn(),
+        listJobs: vi.fn(),
+        deleteJob: vi.fn(),
+        listExecutions: vi.fn(),
+        close: vi.fn(),
+    };
+}
+function makeOracle() {
+    return {
+        chat: vi.fn().mockResolvedValue('Oracle response'),
+        setSessionId: vi.fn().mockResolvedValue(undefined),
+        getCurrentSessionId: vi.fn().mockReturnValue('user-session-1'),
+        initialize: vi.fn(),
+        getHistory: vi.fn(),
+        createNewSession: vi.fn(),
+        clearMemory: vi.fn(),
+        reloadTools: vi.fn(),
+    };
+}
+describe('ChronosWorker.tick()', () => {
+    it('isRunning guard prevents concurrent execution', async () => {
+        const repo = makeRepo([]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        // Set isRunning to true via tick (accessing private via casting)
+        worker.isRunning = true;
+        await worker.tick();
+        expect(repo.getDueJobs).not.toHaveBeenCalled();
+    });
+    it('calls getDueJobs with current timestamp', async () => {
+        const repo = makeRepo([]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        const before = Date.now();
+        await worker.tick();
+        const after = Date.now();
+        const [[ts]] = repo.getDueJobs.mock.calls;
+        expect(ts).toBeGreaterThanOrEqual(before);
+        expect(ts).toBeLessThanOrEqual(after);
+    });
+    it('triggers oracle.chat for a once-type due job then disables it', async () => {
+        const job = makeJob({ schedule_type: 'once' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        // Wait for fire-and-forget
+        await new Promise((r) => setTimeout(r, 50));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(repo.disableJob).toHaveBeenCalledWith(job.id);
+        expect(repo.updateJob).not.toHaveBeenCalled();
+    });
+    it('triggers oracle.chat for a recurring job then updates next_run_at', async () => {
+        const job = makeJob({ schedule_type: 'cron', cron_normalized: '0 9 * * *' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(repo.disableJob).not.toHaveBeenCalled();
+        expect(repo.updateJob).toHaveBeenCalledWith(job.id, expect.objectContaining({ next_run_at: expect.any(Number) }));
+    });
+    it('sets execution status to failed when oracle.chat rejects', async () => {
+        const job = makeJob({ schedule_type: 'once' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        oracle.chat.mockRejectedValue(new Error('LLM error'));
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(repo.completeExecution).toHaveBeenCalledWith(expect.any(String), 'failed', 'LLM error');
+        // For once-type, still auto-disable even on failure
+        expect(repo.disableJob).toHaveBeenCalledWith(job.id);
+    });
+});

package/dist/runtime/display.js

@@ -98,6 +98,9 @@ export class DisplayManager {
             else if (options.source === 'Zaion') {
                 color = chalk.hex('#00c3ff');
             }
+            else if (options.source === 'Chronos') {
+                color = chalk.hex('#a855f7');
+            }
             prefix = color(`[${options.source}] `);
         }
         let formattedMessage = message;

package/dist/runtime/memory/sqlite.js

@@ -828,6 +828,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(`

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 } 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, ...chronosTools]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -180,7 +180,7 @@ 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.
@@ -422,6 +422,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 +438,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 +461,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/tasks/dispatcher.js

@@ -43,10 +43,12 @@ export class TaskDispatcher {
             return;
         }
         if (task.origin_channel === 'ui') {
-            const statusIcon = task.status === 'completed' ? '✅' : '❌';
+            const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
             const body = task.status === 'completed'
                 ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
-                : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
+                : task.status === 'cancelled'
+                    ? 'Task was cancelled.'
+                    : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
             const content = `${statusIcon}\ Task \`${task.id.toUpperCase()}\`\n` +
                 `Agent: \`${task.agent.toUpperCase()}\`\n` +
                 `Status: \`${task.status.toUpperCase()}\`\n\n${body}`;
@@ -70,10 +72,12 @@ export class TaskDispatcher {
         if (!adapter) {
             throw new Error('Telegram adapter not connected');
         }
-        const statusIcon = task.status === 'completed' ? '✅' : '❌';
+        const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
         const body = task.status === 'completed'
             ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
-            : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
+            : task.status === 'cancelled'
+                ? 'Task was cancelled.'
+                : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
         const header = `${statusIcon}\ Task \`${task.id.toUpperCase()}\`\n` +
             `Agent: \`${task.agent.toUpperCase()}\`\n` +
             `Status: \`${task.status.toUpperCase()}\``;

package/dist/runtime/tasks/repository.js

@@ -240,7 +240,7 @@ export class TaskRepository {
           notify_status = 'pending',
           notify_last_error = NULL,
           notified_at = NULL
-      WHERE id = ?
+      WHERE id = ? AND status != 'cancelled'
     `).run(normalizedOutput.length > 0 ? normalizedOutput : 'Task completed without output.', now, now, id);
     }
     markFailed(id, error) {
@@ -253,9 +253,22 @@ export class TaskRepository {
           updated_at = ?,
           notify_status = 'pending',
           notified_at = NULL
-      WHERE id = ?
+      WHERE id = ? AND status != 'cancelled'
     `).run(error, now, now, id);
     }
+    cancelTask(id) {
+        const now = Date.now();
+        const result = this.db.prepare(`
+      UPDATE tasks
+      SET status = 'cancelled',
+          finished_at = ?,
+          updated_at = ?,
+          notify_status = 'pending',
+          notified_at = NULL
+      WHERE id = ? AND status IN ('pending', 'running')
+    `).run(now, now, id);
+        return result.changes > 0;
+    }
     retryTask(id) {
         const now = Date.now();
         const result = this.db.prepare(`
@@ -306,7 +319,7 @@ export class TaskRepository {
             const row = this.db.prepare(`
         SELECT id
         FROM tasks
-        WHERE status IN ('completed', 'failed')
+        WHERE status IN ('completed', 'failed', 'cancelled')
           AND notify_status = 'pending'
           AND finished_at IS NOT NULL
           AND finished_at <= ?
@@ -338,7 +351,7 @@ export class TaskRepository {
       SET notify_status = 'pending',
           notify_last_error = COALESCE(notify_last_error, 'Recovered notification queue state'),
           updated_at = ?
-      WHERE status IN ('completed', 'failed')
+      WHERE status IN ('completed', 'failed', 'cancelled')
         AND (
           (notify_status = 'sending' AND updated_at <= ?)
           OR