morpheus-cli 0.6.0 → 0.6.2

package/dist/devkit/tools/browser.js

@@ -295,81 +295,197 @@ const browserFillTool = tool(async ({ selector, value, press_enter, timeout_ms }
  */
 const browserSearchTool = tool(async ({ query, num_results, language }) => {
     try {
-        const max = num_results ?? 10;
-        // DDG region codes: "br-pt" for Brazil/Portuguese, "us-en" for US/English, etc.
-        // Map from simple lang code to DDG kl param
+        const max = Math.min(num_results ?? 10, 20);
+        const year = new Date().getFullYear().toString();
+        const lang = language ?? "pt";
+        // ─────────────────────────────────────────────
+        // 1️⃣ Intent Classification (heurístico leve)
+        // ─────────────────────────────────────────────
+        const qLower = query.toLowerCase();
+        let intent = "general";
+        if (/(hoje|último|resultado|placar|próximos|futebol|202\d)/.test(qLower))
+            intent = "news";
+        if (/(site oficial|gov|receita federal|ministério)/.test(qLower))
+            intent = "official";
+        if (/(api|sdk|npm|docs|documentação)/.test(qLower))
+            intent = "documentation";
+        if (/(preço|valor|quanto custa)/.test(qLower))
+            intent = "price";
+        // ─────────────────────────────────────────────
+        // 2️⃣ Query Refinement
+        // ─────────────────────────────────────────────
+        let refinedQuery = query;
+        if (intent === "news") {
+            refinedQuery = `${query} ${year}`;
+        }
+        if (intent === "official") {
+            refinedQuery = `${query} site:gov.br OR site:org`;
+        }
+        if (intent === "documentation") {
+            refinedQuery = `${query} documentation OR docs OR github`;
+        }
+        if (intent === "price") {
+            refinedQuery = `${query} preço ${year} Brasil`;
+        }
+        // ─────────────────────────────────────────────
+        // 3️⃣ DuckDuckGo Lite Fetch
+        // ─────────────────────────────────────────────
         const regionMap = {
-            pt: 'br-pt', br: 'br-pt',
-            en: 'us-en', us: 'us-en',
-            es: 'es-es', fr: 'fr-fr',
-            de: 'de-de', it: 'it-it',
-            jp: 'jp-jp', ar: 'ar-es',
+            pt: "br-pt",
+            br: "br-pt",
+            en: "us-en",
+            us: "us-en",
         };
-        const lang = language ?? 'pt';
         const kl = regionMap[lang] ?? lang;
-        const body = new URLSearchParams({ q: query, kl }).toString();
-        const res = await fetch('https://lite.duckduckgo.com/lite/', {
-            method: 'POST',
+        const body = new URLSearchParams({ q: refinedQuery, kl }).toString();
+        const res = await fetch("https://lite.duckduckgo.com/lite/", {
+            method: "POST",
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ' +
-                    '(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                "Content-Type": "application/x-www-form-urlencoded",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
             },
             body,
-            signal: AbortSignal.timeout(20_000),
+            signal: AbortSignal.timeout(20000),
         });
         if (!res.ok) {
-            return JSON.stringify({ success: false, query, error: `HTTP ${res.status}` });
+            return JSON.stringify({ success: false, error: `HTTP ${res.status}` });
         }
         const html = await res.text();
-        // Extract all result-link anchors (href uses double quotes, class uses single quotes)
         const linkPattern = /href="(https?:\/\/[^"]+)"[^>]*class='result-link'>([^<]+)<\/a>/g;
         const snippetPattern = /class='result-snippet'>([\s\S]*?)<\/td>/g;
-        const allLinks = [...html.matchAll(linkPattern)];
-        const allSnippets = [...html.matchAll(snippetPattern)];
-        // Pair links with snippets by index, filtering sponsored (DDG y.js redirect URLs)
+        const links = [...html.matchAll(linkPattern)];
+        const snippets = [...html.matchAll(snippetPattern)];
+        if (!links.length) {
+            return JSON.stringify({
+                success: false,
+                query: refinedQuery,
+                error: "No results found",
+            });
+        }
+        // ─────────────────────────────────────────────
+        // 4️⃣ Helpers
+        // ─────────────────────────────────────────────
+        function normalizeUrl(url) {
+            try {
+                const u = new URL(url);
+                u.search = ""; // remove tracking params
+                return u.toString();
+            }
+            catch {
+                return url;
+            }
+        }
+        function getDomain(url) {
+            try {
+                return new URL(url).hostname.replace("www.", "");
+            }
+            catch {
+                return "";
+            }
+        }
+        const trustedDomains = [
+            "gov.br",
+            "bbc.com",
+            "reuters.com",
+            "globo.com",
+            "uol.com",
+            "cnn.com",
+            "github.com",
+            "npmjs.com",
+            "com.br"
+        ];
+        function scoreResult(result) {
+            let score = 0;
+            const domain = getDomain(result.url);
+            if (trustedDomains.some((d) => domain.includes(d)))
+                score += 5;
+            if (intent === "official" && domain.includes("gov"))
+                score += 5;
+            if (intent === "documentation" && domain.includes("github"))
+                score += 4;
+            if (intent === "news" && /(globo|uol|cnn|bbc)/.test(domain))
+                score += 3;
+            if (result.title.toLowerCase().includes(query.toLowerCase()))
+                score += 2;
+            if (result.snippet.length > 120)
+                score += 1;
+            if (/login|assine|subscribe|paywall/i.test(result.snippet))
+                score -= 3;
+            return score;
+        }
+        // ─────────────────────────────────────────────
+        // 5️⃣ Build Results + Deduplicate Domain
+        // ─────────────────────────────────────────────
+        const domainSeen = new Set();
         const results = [];
-        for (let i = 0; i < allLinks.length && results.length < max; i++) {
-            const url = allLinks[i][1];
-            const title = allLinks[i][2].trim();
-            // Skip sponsored ads (redirected through duckduckgo.com/y.js)
-            if (url.startsWith('https://duckduckgo.com/'))
+        for (let i = 0; i < links.length; i++) {
+            const rawUrl = links[i][1];
+            if (rawUrl.startsWith("https://duckduckgo.com/"))
                 continue;
-            const snippet = allSnippets[i]
-                ? allSnippets[i][1].replace(/<[^>]+>/g, '').trim()
-                : '';
-            results.push({ title, url, snippet });
+            const url = normalizeUrl(rawUrl);
+            const domain = getDomain(url);
+            if (domainSeen.has(domain))
+                continue;
+            domainSeen.add(domain);
+            const title = links[i][2].trim();
+            const snippet = snippets[i]
+                ? snippets[i][1].replace(/<[^>]+>/g, "").trim()
+                : "";
+            const result = { title, url, snippet };
+            const score = scoreResult(result);
+            results.push({ ...result, domain, score });
         }
-        if (results.length === 0) {
+        if (!results.length) {
             return JSON.stringify({
                 success: false,
-                query,
-                error: 'No results found. The query may be too specific or DDG returned an unexpected response.',
+                query: refinedQuery,
+                error: "No valid results after filtering",
             });
         }
-        return JSON.stringify({ success: true, query, results });
+        // ─────────────────────────────────────────────
+        // 6️⃣ Ranking
+        // ─────────────────────────────────────────────
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, max);
+        const avgScore = topResults.reduce((acc, r) => acc + r.score, 0) /
+            topResults.length;
+        // ─────────────────────────────────────────────
+        // 7️⃣ Low-Confidence Auto Retry
+        // ─────────────────────────────────────────────
+        if (avgScore < 2 && intent !== "general") {
+            return JSON.stringify({
+                success: false,
+                query: refinedQuery,
+                warning: "Low confidence results. Consider refining query further.",
+                results: topResults,
+            });
+        }
+        return JSON.stringify({
+            success: true,
+            original_query: query,
+            refined_query: refinedQuery,
+            intent,
+            results: topResults.map((r) => ({
+                title: r.title,
+                url: r.url,
+                snippet: r.snippet,
+                score: r.score,
+            })),
+        });
     }
     catch (err) {
-        return JSON.stringify({ success: false, query, error: err.message });
+        return JSON.stringify({
+            success: false,
+            error: err.message,
+        });
     }
 }, {
-    name: 'browser_search',
-    description: 'Search the internet using DuckDuckGo and return structured results (title, URL, snippet). ' +
-        'Use this when you need to find current information, news, articles, documentation, or any web content. ' +
-        'Returns up to 10 results by default. Does NOT require browser_navigate first — it is self-contained and fast.',
+    name: "browser_search",
+    description: "Enhanced internet search with query refinement, ranking, deduplication, and confidence scoring. Uses DuckDuckGo Lite.",
     schema: z.object({
-        query: z.string().describe('Search query'),
-        num_results: z
-            .number()
-            .int()
-            .min(1)
-            .max(20)
-            .optional()
-            .describe('Number of results to return. Default: 10, max: 20'),
-        language: z
-            .string()
-            .optional()
-            .describe('Language/region code (e.g. "pt" for Portuguese/Brazil, "en" for English). Default: "pt"'),
+        query: z.string(),
+        num_results: z.number().int().min(1).max(20).optional(),
+        language: z.string().optional(),
     }),
 });
 // ─── Factory ────────────────────────────────────────────────────────────────

package/dist/runtime/apoc.js

@@ -73,151 +73,174 @@ export class Apoc {
             source: "Apoc",
         });
         const systemMessage = new SystemMessage(`
-You are Apoc, a specialized devtools subagent within the Morpheus system.
-
-You are called by Oracle when the user needs dev operations performed.
-Your job is to execute the requested task accurately using your available tools.
-
-Available capabilities:
-- Read, write, append, and delete files
-- Execute shell commands
-- Inspect and manage processes
-- Run git operations (status, log, diff, clone, commit, etc.)
-- Perform network operations (curl, DNS, ping)
-- Manage packages (npm, yarn)
-- Inspect system information
-- Navigate websites, inspect DOM, click elements, fill forms using a real browser (for JS-heavy pages and SPAs)
-- Search the internet with browser_search (DuckDuckGo, returns structured results)
-
-OPERATING RULES:
-1. Use tools to accomplish the task. Do not speculate.
-2. Always verify results after execution.
-3. Report clearly what was done and what the result was.
-4. If something fails, report the error and what you tried.
-5. Stay focused on the delegated task only.
-6. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
-7. For connectivity checks, prefer the dedicated network tool "ping" (TCP reachability) instead of shell "ping".
-8. Only use shell ping when explicitly required by the user. If shell ping is needed, detect OS first:
-   - Windows: use "-n" (never use "-c")
-   - Linux/macOS: use "-c"
-
-
-────────────────────────────────────────
-BROWSER AUTOMATION PROTOCOL
-────────────────────────────────────────
-
-When using browser tools (browser_navigate, browser_get_dom, browser_click, browser_fill), follow this protocol exactly.
-
-GENERAL PRINCIPLES
-- Never guess selectors.
-- Never assume page state.
-- Always verify page transitions.
-- Always extract evidence of success.
-- If required user data is missing, STOP and return to Oracle immediately.
-
-PHASE 1 — Navigation
-1. ALWAYS call browser_navigate first.
-2. Use:
-   - wait_until: "networkidle0" for SPAs or JS-heavy pages.
-   - wait_until: "domcontentloaded" for simple pages.
-3. After navigation, confirm current_url and title.
-4. If navigation fails, report the error and stop.
-
-PHASE 2 — DOM Inspection (MANDATORY BEFORE ACTION)
-1. ALWAYS call browser_get_dom before browser_click or browser_fill.
-2. Identify stable selectors (prefer id > name > role > unique class).
-3. Understand page structure and expected flow before interacting.
-4. Never click or fill blindly.
-
-PHASE 3 — Interaction
-When clicking:
-- Prefer stable selectors.
-- If ambiguous, refine selector.
-- Use visible text only if selector is unstable.
-
-When filling:
-- Confirm correct input field via DOM.
-- Fill field.
-- Submit using press_enter OR clicking submit button.
-
-If login or personal data is required:
-STOP and return required fields clearly.
-
-PHASE 4 — State Verification (MANDATORY)
-After ANY interaction:
-1. Call browser_get_dom again.
-2. Verify URL change or content change.
-3. Confirm success or detect error message.
-
-If expected change did not occur:
-- Reinspect DOM.
-- Attempt one justified alternative.
-- If still failing, report failure clearly.
-
-Maximum 2 attempts per step.
-Never assume success.
-
-PHASE 5 — Reporting
-Include:
-- Step-by-step actions
-- Final URL
-- Evidence of success
-- Errors encountered
-- Completion status (true/false)
-
-
-────────────────────────────────────────
-WEB RESEARCH PROTOCOL
-────────────────────────────────────────
-
-When using browser_search for factual verification, follow this protocol strictly.
-
-PHASE 1 — Query Design
-1. Identify core entity, information type, and time constraint.
-2. Build a precise search query.
-3. If time-sensitive, include the current year.
-
-PHASE 2 — Source Discovery
-1. Call browser_search.
-2. Collect results.
-3. Prioritize official sources and major publications.
-4. Reformulate query if necessary.
-5. IMMEDIATELY save the search result titles and snippets — you will need them as fallback.
-
-PHASE 3 — Source Validation
-1. Try to open up to 3 distinct URLs with browser_navigate.
-   - For news/sports/media sites (GE, Globo, UOL, Terra, ESPN, etc.): ALWAYS use wait_until: "networkidle0" — these are SPAs that require JavaScript to load content.
-   - For simple/static pages: use wait_until: "domcontentloaded".
-2. Read actual page content from accessible pages.
-3. Ignore inaccessible pages (timeouts, bot blocks, errors).
-4. If ALL navigations fail OR page content does not contain useful information:
-   - DO NOT attempt further workarounds (wget, curl, python scripts, http_request).
-   - Use the search snippets from Phase 2 as your source and proceed to Phase 5.
-
-PHASE 4 — Cross-Verification
-1. Extract relevant information from each accessible source.
-2. Compare findings across sources when possible.
-3. If content came from snippets only, state clearly:
-   "Source: DuckDuckGo search snippets (direct page access unavailable)."
-
-PHASE 5 — Structured Report
-Include:
-- Direct answer based ONLY on what was found online
-- Source URLs (from search results or navigated pages)
-- Confidence level (High / Medium / Low)
-
-ABSOLUTE RULES — NEVER VIOLATE
-1. NEVER use prior knowledge to fill gaps when online tools failed to find information.
-2. NEVER fabricate, invent, or speculate about news, facts, prices, results, or events.
-3. If browser_search returned results: ALWAYS report those results — never say "no results found".
-4. If content could not be extracted from pages: report the search snippets verbatim.
-5. If both search and navigation failed: say exactly "I was unable to retrieve this information online at this time." Stop there. Do not continue with "based on general knowledge...".
-6. Do NOT attempt more than 2 workaround approaches (wget, curl, python) — if the primary tools fail, move immediately to fallback (snippets) or honest failure report.
+You are Apoc, a high-reliability execution and verification subagent inside the Morpheus system.
 
+You are NOT a conversational assistant.
+You are a task executor, evidence collector, and autonomous verifier.
 
+Accuracy is more important than speed.
+If verification fails, you must state it clearly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CORE PRINCIPLES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+• Never fabricate.
+• Never rely on prior knowledge when online tools are available.
+• Prefer authoritative sources over secondary commentary.
+• Prefer verification over assumption.
+• Explicitly measure and report confidence.
+
+If reliable evidence cannot be obtained:
+State clearly:
+"I was unable to retrieve this information online at this time."
+
+Stop there.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TASK CLASSIFICATION
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Before using tools:
+
+1. Identify task type:
+   - Dev operation
+   - Web research
+   - Browser automation
+   - System inspection
+   - Network verification
+
+2. Determine whether external verification is required.
+   If yes → use tools.
+   If no → respond directly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WEB RESEARCH STRATEGY (QUALITY-FIRST)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+You operate in iterative cycles.
+
+Maximum cycles: 2
+
+━━━━━━━━━━━━━━
+CYCLE 1
+━━━━━━━━━━━━━━
+
+PHASE 1 — Intelligent Query Design
+• Identify intent: news, official, documentation, price, general.
+• Add year if time-sensitive.
+• Add region if relevant.
+• Make query precise and focused.
+
+PHASE 2 — Search
+• Use browser_search.
+• Immediately store titles and snippets.
+
+PHASE 3 — Source Selection
+Select up to 3 URLs.
+Prefer:
+  - One official source
+  - One major publication
+  - One independent alternative
+Avoid:
+  - Multiple links from same domain group
+  - Obvious paywalls or login walls
+
+PHASE 4 — Navigation & Extraction
+• Use browser_navigate.
+• For news/media → wait_until: "networkidle0"
+• Extract content from:
+    article > main > body
+• Remove navigation noise.
+
+PHASE 5 — Cross Verification
+• Compare findings across sources.
+• Detect inconsistencies.
+• Identify strongest source.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+AUTO-REFINEMENT LOOP
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+After completing Cycle 1, evaluate:
+
+Trigger refinement if ANY condition is true:
+
+• No authoritative source was successfully opened.
+• Only snippets were available.
+• Extracted content did not contain concrete answer.
+• Sources contradict each other.
+• Confidence would be LOW.
+• Search results appear irrelevant or weak.
+
+If refinement is triggered:
+
+1. Reformulate query:
+   - Add year
+   - Add country
+   - Add "official"
+   - Add domain filters (gov, org, major media)
+   - Remove ambiguous words
+
+2. Execute a second search cycle (Cycle 2).
+3. Repeat selection, navigation, extraction, verification.
+4. Choose the stronger cycle’s evidence.
+5. Do NOT perform more than 2 cycles.
+
+If Cycle 2 also fails:
+Report inability clearly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SELF-CRITIQUE (MANDATORY BEFORE OUTPUT)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Internally evaluate:
+
+1. Did I use at least one authoritative source when available?
+2. Did I rely only on snippets unnecessarily?
+3. Did I merge conflicting data incorrectly?
+4. Did I verify the page actually contained the requested information?
+5. Did I introduce any information not explicitly found online?
+6. Is my confidence level justified?
+
+If issues are found:
+Correct them.
+If correction is not possible:
+Lower confidence explicitly.
+
+Do NOT expose this checklist.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CONFIDENCE CRITERIA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+HIGH:
+• Multiple independent authoritative sources agree
+• Full page extraction used
+
+MEDIUM:
+• One strong source OR minor inconsistencies
+• Partial verification
+
+LOW:
+• Snippets only OR weak sources OR incomplete confirmation
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+OUTPUT FORMAT (STRICT)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. Direct Answer  
+2. Evidence Summary  
+3. Sources (URLs)  
+4. Confidence Level (HIGH / MEDIUM / LOW)  
+5. Completion Status (true / false)
+
+No conversational filler.
+No reasoning trace.
+Only structured output.
 
 ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
-    `);
+`);
         const userMessage = new HumanMessage(task);
         const messages = [systemMessage, userMessage];
         try {

package/dist/runtime/chronos/worker.js

@@ -88,12 +88,11 @@ export class ChronosWorker {
             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);
+            // Prefix the job prompt with the Chronos execution context marker so the
+            // Oracle system prompt can detect it in the current HumanMessage.
+            // This avoids persisting an AIMessage with the marker in conversation history,
+            // which would cause the LLM to reproduce the format in future scheduling responses.
+            const promptWithContext = `[CHRONOS EXECUTION — job_id: ${job.id}]\n${job.prompt}`;
             // If a Telegram notify function is registered, tag delegated tasks with
             // origin_channel: 'telegram' so the TaskDispatcher broadcasts their result.
             const taskContext = ChronosWorker.notifyFn
@@ -101,7 +100,7 @@ export class ChronosWorker {
                 : undefined;
             // Hard-block Chronos management tools during execution.
             ChronosWorker.isExecuting = true;
-            const response = await this.oracle.chat(job.prompt, undefined, false, taskContext);
+            const response = await this.oracle.chat(promptWithContext, undefined, false, taskContext);
             this.repo.completeExecution(execId, 'success');
             display.log(`Job ${job.id} completed — status: success`, { source: 'Chronos' });
             // Deliver Oracle response to notification channels.

package/dist/runtime/memory/sati/repository.js

@@ -208,7 +208,7 @@ export class SatiRepository {
     searchUnifiedVector(embedding, limit) {
         if (!this.db)
             return [];
-        const SIMILARITY_THRESHOLD = 0.8;
+        const SIMILARITY_THRESHOLD = 0.9;
         const stmt = this.db.prepare(`
     SELECT *
     FROM (

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.
@@ -919,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, chronosTools } from "./tools/index.js";
+import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { MCPManager } from "../config/mcp-manager.js";
 export class Oracle {
     provider;
@@ -114,6 +114,20 @@ export class Oracle {
         }
         return false;
     }
+    hasChronosToolCall(messages) {
+        const chronosToolNames = new Set(["chronos_schedule", "chronos_list", "chronos_cancel", "chronos_preview"]);
+        for (const msg of messages) {
+            if (!(msg instanceof AIMessage))
+                continue;
+            const toolCalls = msg.tool_calls ?? [];
+            if (!Array.isArray(toolCalls))
+                continue;
+            if (toolCalls.some((tc) => chronosToolNames.has(tc?.name))) {
+                return true;
+            }
+        }
+        return false;
+    }
     async initialize() {
         if (!this.config.llm) {
             throw new Error("LLM configuration missing in config object.");
@@ -129,7 +143,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, ...chronosTools]);
+            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,6 +189,14 @@ 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).
@@ -190,6 +212,17 @@ Rules:
 10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
 
+## 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.
+
+Behavior rules for Chronos execution context:
+- **Reminder / notification prompts** (e.g., "me lembre de beber água", "lembre de tomar remédio", "avise que é hora de X", "lembrete: reunião às 15h"): respond with ONLY a short, direct notification message. Keep it to 1–2 sentences max. Do NOT use any tools. Do NOT delegate. Do NOT create tasks. Do NOT add motivational commentary or ask follow-up questions.
+  - Good: "Hora de beber água! 💧"
+  - Good: "Lembrete: reunião em 5 minutos."
+  - Bad: "Combinado! Vou beber agora. Você também deveria se hidratar!" (adds unnecessary commentary)
+- **Action / task prompts** (e.g., "executar npm build", "verificar se o servidor está online", "enviar relatório"): execute normally using the appropriate tools.
+- NEVER re-schedule or create new Chronos jobs from within a Chronos execution.
+
 Delegation quality:
 - Write delegation input in the same language requested by the user.
 - Include clear objective and constraints.
@@ -286,6 +319,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let responseContent;
             const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);
             const hadDelegationToolCall = this.hasDelegationToolCall(newGeneratedMessages);
+            const hadChronosToolCall = this.hasChronosToolCall(newGeneratedMessages);
             const mergedDelegationAcks = [
                 ...contextDelegationAcks.map((ack) => ({ task_id: ack.task_id, agent: ack.agent })),
                 ...toolDelegationAcks,
@@ -310,6 +344,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" });
@@ -325,7 +362,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             else {
                 const lastMessage = response.messages[response.messages.length - 1];
                 responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
-                if (this.looksLikeSyntheticDelegationAck(responseContent)) {
+                if (!hadChronosToolCall && this.looksLikeSyntheticDelegationAck(responseContent)) {
                     blockedSyntheticDelegationAck = true;
                     this.display.log("Blocked synthetic delegation acknowledgement without validated task creation.", { source: "Oracle", level: "error", meta: { preview: responseContent.slice(0, 200) } });
                     const usage = lastMessage.usage_metadata

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/index.js

@@ -3,3 +3,4 @@ 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';

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

@@ -11,8 +11,7 @@ Neo built-in capabilities (always available — no MCP required):
 • Analytics: message_count, token_usage, provider_model_usage — message counts and token/cost usage stats
 • Tasks: task_query — look up task status by id or session
 • MCP Management: mcp_list, mcp_manage — list/add/update/delete/enable/disable MCP servers; use action "reload" to reload tools across all agents after config changes
-• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key
-• Trinity DB: trinity_db_list, trinity_db_manage — register/update/delete/test connection/refresh schema for databases`.trim();
+• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key`.trim();
 const NEO_BASE_DESCRIPTION = `Delegate execution to Neo asynchronously.
 
 This tool creates a background task and returns an acknowledgement with task id.
@@ -29,7 +28,7 @@ function buildCatalogSection(mcpTools) {
     if (mcpTools.length === 0) {
         return "\n\nRuntime MCP tools: none currently loaded.";
     }
-    const maxItems = 32;
+    const maxItems = 500;
     const lines = mcpTools.slice(0, maxItems).map((t) => {
         const desc = normalizeDescription(t.description).slice(0, 120);
         return `- ${t.name}: ${desc}`;

package/dist/runtime/tools/time-verify-tools.js

@@ -0,0 +1,70 @@
+// tools/timeVerifier.tool.ts
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import * as chrono from "chrono-node";
+import { ConfigManager } from "../../config/manager.js";
+// Create a custom instance that supports English, Portuguese, and Spanish
+const casualChrono = new chrono.Chrono({
+    parsers: [
+        ...chrono.en.casual.parsers,
+        ...chrono.pt.casual.parsers,
+        ...chrono.es.casual.parsers,
+    ],
+    refiners: [
+        ...chrono.en.casual.refiners,
+        ...chrono.pt.casual.refiners,
+        ...chrono.es.casual.refiners,
+    ],
+});
+export const timeVerifierTool = tool(async ({ text, timezone }) => {
+    // If a timezone is provided, use it for parsing context. 
+    // Otherwise, use the configured system timezone from Chronos.
+    const configTimezone = ConfigManager.getInstance().getChronosConfig()?.timezone || 'UTC';
+    const effectiveTimezone = timezone || configTimezone;
+    const referenceDate = { instant: new Date(), timezone: effectiveTimezone };
+    // Parse using our multi-lingual casual parser
+    // We pass forwardDate: true to prefer future dates for ambiguous expressions (e.g. "Friday" -> next Friday)
+    // If timezone is provided, we could use it, but chrono-node's timezone support is complex.
+    // For now, we rely on relative parsing from the system's current time.
+    const results = casualChrono.parse(text, referenceDate, { forwardDate: true });
+    if (!results.length) {
+        return {
+            detected: false,
+            message: "No temporal expression detected.",
+        };
+    }
+    const parsed = results.map((result) => {
+        const startDate = result.start.date();
+        const endDate = result.end?.date();
+        return {
+            expression: result.text,
+            isoStart: startDate.toISOString(),
+            isoEnd: endDate ? endDate.toISOString() : null,
+            // Format the date in the user's timezone for clarity
+            formatted: startDate.toLocaleString('pt-BR', { timeZone: effectiveTimezone, timeZoneName: 'short' }),
+            isRange: !!endDate,
+        };
+    });
+    return {
+        detected: true,
+        timezone: effectiveTimezone,
+        referenceDate: referenceDate instanceof Date ? referenceDate.toISOString() : referenceDate.instant.toISOString(),
+        parsed,
+    };
+}, {
+    name: "time_verifier",
+    description: `
+Detects and resolves relative time expressions in user input.
+Supports multiple languages (English, Portuguese, Spanish).
+Use this tool whenever the user mentions words like:
+today, tomorrow, yesterday, this week, next week,
+hoje, amanhã, ontem, próxima semana,
+hoy, mañana, ayer, la próxima semana, etc.
+
+Returns resolved ISO dates based on the current time and timezone configuration.
+    `,
+    schema: z.object({
+        text: z.string().describe("User input text containing time expressions"),
+        timezone: z.string().optional().describe("Optional timezone override. Defaults to system configuration."),
+    }),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"
@@ -46,6 +46,7 @@
     "cors": "^2.8.6",
     "cron-parser": "^4.9.0",
     "cronstrue": "^2.59.0",
+    "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
     "express": "^5.2.1",
     "figlet": "^1.10.0",