morpheus-cli 0.4.14 → 0.5.0

package/dist/runtime/tasks/notifier.js

@@ -0,0 +1,68 @@
+import { DisplayManager } from '../display.js';
+import { TaskDispatcher } from './dispatcher.js';
+import { TaskRepository } from './repository.js';
+export class TaskNotifier {
+    pollIntervalMs;
+    maxAttempts;
+    staleSendingMs;
+    notificationGraceMs;
+    repository = TaskRepository.getInstance();
+    display = DisplayManager.getInstance();
+    timer = null;
+    running = false;
+    constructor(opts) {
+        this.pollIntervalMs = opts?.pollIntervalMs ?? 1200;
+        this.maxAttempts = opts?.maxAttempts ?? 5;
+        this.staleSendingMs = opts?.staleSendingMs ?? 30_000;
+        this.notificationGraceMs = opts?.notificationGraceMs ?? 2000;
+    }
+    start() {
+        if (this.timer)
+            return;
+        const recovered = this.repository.recoverNotificationQueue(this.maxAttempts, this.staleSendingMs);
+        if (recovered > 0) {
+            this.display.log(`Recovered ${recovered} task notification(s) back to pending.`, {
+                source: 'TaskNotifier',
+                level: 'warning',
+            });
+        }
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.pollIntervalMs);
+        this.display.log('Task notifier started.', { source: 'TaskNotifier' });
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+            this.display.log('Task notifier stopped.', { source: 'TaskNotifier' });
+        }
+    }
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            const task = this.repository.claimNextNotificationCandidate(this.notificationGraceMs);
+            if (!task)
+                return;
+            try {
+                await TaskDispatcher.onTaskFinished(task);
+                this.repository.markNotificationSent(task.id);
+            }
+            catch (err) {
+                const latest = this.repository.getTaskById(task.id);
+                const attempts = (latest?.notify_attempts ?? 0) + 1;
+                const retry = attempts < this.maxAttempts;
+                this.repository.markNotificationFailed(task.id, err?.message ?? String(err), retry);
+                this.display.log(`Task notification failed (${task.id}): ${err?.message ?? err}`, {
+                    source: 'TaskNotifier',
+                    level: retry ? 'warning' : 'error',
+                });
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+}

package/dist/runtime/tasks/repository.js

@@ -0,0 +1,370 @@
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+export class TaskRepository {
+    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.ensureTables();
+    }
+    static getInstance() {
+        if (!TaskRepository.instance) {
+            TaskRepository.instance = new TaskRepository();
+        }
+        return TaskRepository.instance;
+    }
+    ensureTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY
+      );
+    `);
+        this.migrateTasksTable();
+        this.ensureIndexes();
+    }
+    migrateTasksTable() {
+        const tableInfo = this.db.pragma('table_info(tasks)');
+        const columns = new Set(tableInfo.map((c) => c.name));
+        const addColumn = (sql, column) => {
+            if (columns.has(column))
+                return;
+            this.db.exec(sql);
+            columns.add(column);
+        };
+        addColumn(`ALTER TABLE tasks ADD COLUMN agent TEXT NOT NULL DEFAULT 'apoc'`, 'agent');
+        addColumn(`ALTER TABLE tasks ADD COLUMN status TEXT NOT NULL DEFAULT 'pending'`, 'status');
+        addColumn(`ALTER TABLE tasks ADD COLUMN input TEXT NOT NULL DEFAULT ''`, 'input');
+        addColumn(`ALTER TABLE tasks ADD COLUMN context TEXT`, 'context');
+        addColumn(`ALTER TABLE tasks ADD COLUMN output TEXT`, 'output');
+        addColumn(`ALTER TABLE tasks ADD COLUMN error TEXT`, 'error');
+        addColumn(`ALTER TABLE tasks ADD COLUMN origin_channel TEXT NOT NULL DEFAULT 'api'`, 'origin_channel');
+        addColumn(`ALTER TABLE tasks ADD COLUMN session_id TEXT NOT NULL DEFAULT 'default'`, 'session_id');
+        addColumn(`ALTER TABLE tasks ADD COLUMN origin_message_id TEXT`, 'origin_message_id');
+        addColumn(`ALTER TABLE tasks ADD COLUMN origin_user_id TEXT`, 'origin_user_id');
+        addColumn(`ALTER TABLE tasks ADD COLUMN attempt_count INTEGER NOT NULL DEFAULT 0`, 'attempt_count');
+        addColumn(`ALTER TABLE tasks ADD COLUMN max_attempts INTEGER NOT NULL DEFAULT 3`, 'max_attempts');
+        addColumn(`ALTER TABLE tasks ADD COLUMN available_at INTEGER NOT NULL DEFAULT 0`, 'available_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0`, 'created_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN started_at INTEGER`, 'started_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN finished_at INTEGER`, 'finished_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
+        addColumn(`ALTER TABLE tasks ADD COLUMN worker_id TEXT`, 'worker_id');
+        addColumn(`ALTER TABLE tasks ADD COLUMN notify_status TEXT NOT NULL DEFAULT 'pending'`, 'notify_status');
+        addColumn(`ALTER TABLE tasks ADD COLUMN notify_attempts INTEGER NOT NULL DEFAULT 0`, 'notify_attempts');
+        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');
+        this.db.exec(`
+      UPDATE tasks
+      SET
+        created_at = CASE WHEN created_at = 0 THEN strftime('%s','now') * 1000 ELSE created_at END,
+        updated_at = CASE WHEN updated_at = 0 THEN strftime('%s','now') * 1000 ELSE updated_at END,
+        available_at = CASE WHEN available_at = 0 THEN created_at ELSE available_at END
+      WHERE created_at = 0 OR updated_at = 0 OR available_at = 0
+    `);
+    }
+    ensureIndexes() {
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tasks_status_available_at
+        ON tasks(status, available_at, created_at);
+      CREATE INDEX IF NOT EXISTS idx_tasks_origin
+        ON tasks(origin_channel, session_id);
+      CREATE INDEX IF NOT EXISTS idx_tasks_created_at
+        ON tasks(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_tasks_notify
+        ON tasks(status, notify_status, finished_at);
+    `);
+    }
+    deserializeTask(row) {
+        return {
+            id: row.id,
+            agent: row.agent,
+            status: row.status,
+            input: row.input,
+            context: row.context ?? null,
+            output: row.output ?? null,
+            error: row.error ?? null,
+            origin_channel: row.origin_channel,
+            session_id: row.session_id,
+            origin_message_id: row.origin_message_id ?? null,
+            origin_user_id: row.origin_user_id ?? null,
+            attempt_count: row.attempt_count ?? 0,
+            max_attempts: row.max_attempts ?? 3,
+            available_at: row.available_at,
+            created_at: row.created_at,
+            started_at: row.started_at ?? null,
+            finished_at: row.finished_at ?? null,
+            updated_at: row.updated_at,
+            worker_id: row.worker_id ?? null,
+            notify_status: row.notify_status,
+            notify_attempts: row.notify_attempts ?? 0,
+            notify_last_error: row.notify_last_error ?? null,
+            notified_at: row.notified_at ?? null,
+            notify_after_at: row.notify_after_at ?? null,
+        };
+    }
+    /**
+     * Grace period (ms) added to created_at for channels where the Oracle's
+     * 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 CHANNELS_NEEDING_ACK_GRACE = new Set(['telegram', 'discord']);
+    createTask(input) {
+        const now = Date.now();
+        const id = randomUUID();
+        const notify_after_at = input.notify_after_at !== undefined
+            ? input.notify_after_at
+            : TaskRepository.CHANNELS_NEEDING_ACK_GRACE.has(input.origin_channel)
+                ? now + TaskRepository.DEFAULT_NOTIFY_AFTER_MS
+                : null;
+        this.db.prepare(`
+      INSERT INTO tasks (
+        id, agent, status, input, context, output, error,
+        origin_channel, session_id, origin_message_id, origin_user_id,
+        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
+      ) 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);
+        return this.getTaskById(id);
+    }
+    getTaskById(id) {
+        const row = this.db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+        return row ? this.deserializeTask(row) : null;
+    }
+    listTasks(filters) {
+        const params = [];
+        let query = 'SELECT * FROM tasks WHERE 1=1';
+        if (filters?.status) {
+            query += ' AND status = ?';
+            params.push(filters.status);
+        }
+        if (filters?.agent) {
+            query += ' AND agent = ?';
+            params.push(filters.agent);
+        }
+        if (filters?.origin_channel) {
+            query += ' AND origin_channel = ?';
+            params.push(filters.origin_channel);
+        }
+        if (filters?.session_id) {
+            query += ' AND session_id = ?';
+            params.push(filters.session_id);
+        }
+        query += ' ORDER BY created_at DESC LIMIT ?';
+        params.push(filters?.limit ?? 200);
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => this.deserializeTask(row));
+    }
+    getStats() {
+        const rows = this.db.prepare(`
+      SELECT status, COUNT(*) as cnt
+      FROM tasks
+      GROUP BY status
+    `).all();
+        const stats = {
+            pending: 0,
+            running: 0,
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+            total: 0,
+        };
+        for (const row of rows) {
+            const status = row.status;
+            if (status in stats) {
+                stats[status] = row.cnt;
+            }
+            stats.total += row.cnt;
+        }
+        return stats;
+    }
+    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 <= ?
+        ORDER BY created_at ASC
+        LIMIT 1
+      `).get(now);
+            if (!row)
+                return null;
+            const result = this.db.prepare(`
+        UPDATE tasks
+        SET status = 'running',
+            started_at = COALESCE(started_at, ?),
+            updated_at = ?,
+            worker_id = ?,
+            attempt_count = attempt_count + 1
+        WHERE id = ? AND status = 'pending'
+      `).run(now, now, workerId, row.id);
+            if (result.changes === 0) {
+                return null;
+            }
+            return this.getTaskById(row.id);
+        });
+        return tx();
+    }
+    markCompleted(id, output) {
+        const now = Date.now();
+        const normalizedOutput = (output ?? '').trim();
+        this.db.prepare(`
+      UPDATE tasks
+      SET status = 'completed',
+          output = ?,
+          error = NULL,
+          finished_at = ?,
+          updated_at = ?,
+          notify_status = 'pending',
+          notify_last_error = NULL,
+          notified_at = NULL
+      WHERE id = ?
+    `).run(normalizedOutput.length > 0 ? normalizedOutput : 'Task completed without output.', now, now, id);
+    }
+    markFailed(id, error) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE tasks
+      SET status = 'failed',
+          error = ?,
+          finished_at = ?,
+          updated_at = ?,
+          notify_status = 'pending',
+          notified_at = NULL
+      WHERE id = ?
+    `).run(error, now, now, id);
+    }
+    retryTask(id) {
+        const now = Date.now();
+        const result = this.db.prepare(`
+      UPDATE tasks
+      SET status = 'pending',
+          output = NULL,
+          error = NULL,
+          finished_at = NULL,
+          started_at = NULL,
+          updated_at = ?,
+          available_at = ?,
+          worker_id = NULL
+      WHERE id = ? AND status = 'failed'
+    `).run(now, now, id);
+        return result.changes > 0;
+    }
+    requeueForRetry(id, error, delayMs) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE tasks
+      SET status = 'pending',
+          error = ?,
+          output = NULL,
+          updated_at = ?,
+          available_at = ?,
+          worker_id = NULL
+      WHERE id = ?
+    `).run(error, now, now + Math.max(0, delayMs), id);
+    }
+    recoverStaleRunning(staleMs) {
+        const now = Date.now();
+        const result = this.db.prepare(`
+      UPDATE tasks
+      SET status = 'pending',
+          updated_at = ?,
+          available_at = ?,
+          worker_id = NULL,
+          error = COALESCE(error, 'Recovered from stale running state')
+      WHERE status = 'running'
+        AND started_at IS NOT NULL
+        AND started_at <= ?
+    `).run(now, now, now - staleMs);
+        return result.changes;
+    }
+    claimNextNotificationCandidate(minFinishedAgeMs = 0) {
+        const now = Date.now();
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare(`
+        SELECT id
+        FROM tasks
+        WHERE status IN ('completed', 'failed')
+          AND notify_status = 'pending'
+          AND finished_at IS NOT NULL
+          AND finished_at <= ?
+          AND (notify_after_at IS NULL OR notify_after_at <= ?)
+        ORDER BY finished_at ASC
+        LIMIT 1
+      `).get(now - Math.max(0, minFinishedAgeMs), now);
+            if (!row)
+                return null;
+            const changed = this.db.prepare(`
+        UPDATE tasks
+        SET notify_status = 'sending',
+            notify_last_error = NULL,
+            updated_at = ?
+        WHERE id = ? AND notify_status = 'pending'
+      `).run(Date.now(), row.id);
+            if (changed.changes === 0) {
+                return null;
+            }
+            return this.getTaskById(row.id);
+        });
+        return tx();
+    }
+    recoverNotificationQueue(maxAttempts, staleSendingMs) {
+        const now = Date.now();
+        const staleThreshold = now - Math.max(0, staleSendingMs);
+        const result = this.db.prepare(`
+      UPDATE tasks
+      SET notify_status = 'pending',
+          notify_last_error = COALESCE(notify_last_error, 'Recovered notification queue state'),
+          updated_at = ?
+      WHERE status IN ('completed', 'failed')
+        AND (
+          (notify_status = 'sending' AND updated_at <= ?)
+          OR
+          (notify_status = 'failed' AND notify_attempts < ?)
+        )
+    `).run(now, staleThreshold, Math.max(1, maxAttempts));
+        return result.changes;
+    }
+    markNotificationSent(taskId) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE tasks
+      SET notify_status = 'sent',
+          notified_at = ?,
+          updated_at = ?
+      WHERE id = ?
+    `).run(now, now, taskId);
+    }
+    markNotificationFailed(taskId, error, retry) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE tasks
+      SET notify_status = ?,
+          notify_attempts = notify_attempts + 1,
+          notify_last_error = ?,
+          updated_at = ?
+      WHERE id = ?
+    `).run(retry ? 'pending' : 'failed', error, now, taskId);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/runtime/tasks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tasks/worker.js

@@ -0,0 +1,96 @@
+import { randomUUID } from 'crypto';
+import { DisplayManager } from '../display.js';
+import { Apoc } from '../apoc.js';
+import { Neo } from '../neo.js';
+import { TaskRepository } from './repository.js';
+export class TaskWorker {
+    workerId;
+    pollIntervalMs;
+    staleRunningMs;
+    repository = TaskRepository.getInstance();
+    display = DisplayManager.getInstance();
+    timer = null;
+    running = false;
+    constructor(opts) {
+        this.workerId = `task-worker-${randomUUID().slice(0, 8)}`;
+        this.pollIntervalMs = opts?.pollIntervalMs ?? 1000;
+        this.staleRunningMs = opts?.staleRunningMs ?? 5 * 60 * 1000;
+    }
+    start() {
+        if (this.timer)
+            return;
+        const recovered = this.repository.recoverStaleRunning(this.staleRunningMs);
+        if (recovered > 0) {
+            this.display.log(`Recovered ${recovered} stale running task(s).`, { source: 'TaskWorker', level: 'warning' });
+        }
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.pollIntervalMs);
+        this.display.log(`Task worker started (${this.workerId}).`, { source: 'TaskWorker' });
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+            this.display.log(`Task worker stopped (${this.workerId}).`, { source: 'TaskWorker' });
+        }
+    }
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            const task = this.repository.claimNextPending(this.workerId);
+            if (!task)
+                return;
+            await this.executeTask(task);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async executeTask(task) {
+        try {
+            let output;
+            switch (task.agent) {
+                case 'apoc': {
+                    const apoc = Apoc.getInstance();
+                    output = await apoc.execute(task.input, task.context ?? undefined, task.session_id);
+                    break;
+                }
+                case 'neo': {
+                    const neo = Neo.getInstance();
+                    output = await neo.execute(task.input, task.context ?? undefined, task.session_id, {
+                        origin_channel: task.origin_channel,
+                        session_id: task.session_id,
+                        origin_message_id: task.origin_message_id ?? undefined,
+                        origin_user_id: task.origin_user_id ?? undefined,
+                    });
+                    break;
+                }
+                case 'trinit': {
+                    throw new Error('Trinit executor is not implemented yet.');
+                }
+                default: {
+                    throw new Error(`Unknown task agent: ${task.agent}`);
+                }
+            }
+            this.repository.markCompleted(task.id, output);
+            this.display.log(`Task completed: ${task.id}`, { source: 'TaskWorker', level: 'success' });
+        }
+        catch (err) {
+            const latest = this.repository.getTaskById(task.id);
+            const attempt = latest?.attempt_count ?? task.attempt_count;
+            const maxAttempts = latest?.max_attempts ?? task.max_attempts;
+            const errorMessage = err?.message ? String(err.message) : String(err);
+            if (attempt < maxAttempts) {
+                const backoffMs = Math.min(30_000, 1000 * Math.pow(2, Math.max(0, attempt - 1)));
+                this.repository.requeueForRetry(task.id, `Attempt ${attempt}/${maxAttempts} failed: ${errorMessage}`, backoffMs);
+                this.display.log(`Task retry scheduled: ${task.id} in ${backoffMs}ms`, { source: 'TaskWorker', level: 'warning' });
+                return;
+            }
+            this.repository.markFailed(task.id, errorMessage);
+            this.display.log(`Task failed: ${task.id} (${errorMessage})`, { source: 'TaskWorker', level: 'error' });
+        }
+    }
+}

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

@@ -1,6 +1,9 @@
 import { tool } from "@langchain/core/tools";
 import { z } from "zod";
-import { Apoc } from "../apoc.js";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
+import { DisplayManager } from "../display.js";
 /**
  * Tool that Oracle uses to delegate devtools tasks to Apoc.
  * Oracle should call this whenever the user requests operations like:
@@ -14,16 +17,66 @@ import { Apoc } from "../apoc.js";
  */
 export const ApocDelegateTool = tool(async ({ task, context }) => {
     try {
-        const apoc = Apoc.getInstance();
-        const result = await apoc.execute(task, context);
-        return result;
+        const display = DisplayManager.getInstance();
+        if (isLikelyCompositeDelegationTask(task)) {
+            display.log(`Apoc delegation rejected (non-atomic task): ${task.slice(0, 140)}`, {
+                source: "ApocDelegateTool",
+                level: "warning",
+            });
+            return compositeDelegationError();
+        }
+        const existingAck = TaskRequestContext.findDuplicateDelegation("apoc", task);
+        if (existingAck) {
+            display.log(`Apoc delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: "ApocDelegateTool",
+                level: "info",
+            });
+            return `Task ${existingAck.task_id} already queued for ${existingAck.agent} execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Apoc delegation blocked by per-turn limit.`, {
+                source: "ApocDelegateTool",
+                level: "warning",
+            });
+            return "Delegation limit reached for this user turn. Split the request or wait for current tasks.";
+        }
+        const ctx = TaskRequestContext.get();
+        const repository = TaskRepository.getInstance();
+        const created = repository.createTask({
+            agent: "apoc",
+            input: task,
+            context: context ?? null,
+            origin_channel: ctx?.origin_channel ?? "api",
+            session_id: ctx?.session_id ?? "default",
+            origin_message_id: ctx?.origin_message_id ?? null,
+            origin_user_id: ctx?.origin_user_id ?? null,
+            max_attempts: 3,
+        });
+        TaskRequestContext.setDelegationAck({ task_id: created.id, agent: "apoc", task });
+        display.log(`Apoc task created: ${created.id}`, {
+            source: "ApocDelegateTool",
+            level: "info",
+            meta: {
+                agent: created.agent,
+                origin_channel: created.origin_channel,
+                session_id: created.session_id,
+                input: created.input,
+            }
+        });
+        return `Task ${created.id} queued for Apoc execution.`;
     }
     catch (err) {
-        return `Apoc execution failed: ${err.message}`;
+        const display = DisplayManager.getInstance();
+        display.log(`ApocDelegateTool error: ${err.message}`, { source: "ApocDelegateTool", level: "error" });
+        return `Apoc task enqueue failed: ${err.message}`;
     }
 }, {
     name: "apoc_delegate",
-    description: `Delegate a devtools task to Apoc, the specialized development subagent.
+    description: `Delegate a devtools task to Apoc, the specialized development subagent, asynchronously.
+
+This tool enqueues a background task and returns an acknowledgement with task id.
+Do not expect final execution output in the same response.
+Each task must contain a single atomic action with a clear expected result.
 
 Use this tool when the user asks for ANY of the following:
 - File operations: read, write, create, delete files or directories
@@ -39,7 +92,7 @@ Use this tool when the user asks for ANY of the following:
 Provide a clear natural language task description. Optionally provide context
 from the current conversation to help Apoc understand the broader goal.`,
     schema: z.object({
-        task: z.string().describe("Clear description of the devtools task to execute"),
-        context: z.string().optional().describe("Optional context from the conversation to help Apoc understand the goal"),
+        task: z.string().describe("Clear description of the devtools task to execute **in the user's language**"),
+        context: z.string().optional().describe("Optional context from the conversation to help Apoc understand the goal **in the user's language**"),
     }),
 });

package/dist/runtime/tools/delegation-guard.js

@@ -0,0 +1,29 @@
+function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Heuristic guard to reject clearly multi-action delegations.
+ * Allows phrases like "do X and return/report Y".
+ */
+export function isLikelyCompositeDelegationTask(task) {
+    const t = normalize(task);
+    if (!t)
+        return false;
+    if (/[;\n]/.test(t))
+        return true;
+    const conjunction = /\b(and|then|also|e|depois|tambem|também|alem disso|além disso)\b/;
+    if (!conjunction.test(t))
+        return false;
+    // "and return/report" is usually part of a single atomic objective.
+    const allowedSecondStep = /\b(and|then|e|depois)\s+(return|report|summarize|retorne|informe|resuma|mostre|show)\b/;
+    if (allowedSecondStep.test(t))
+        return false;
+    const actionVerbAfterConjunction = /\b(and|then|also|e|depois|tambem|também)\s+(check|ping|run|execute|search|fetch|get|list|create|update|delete|open|verify|consult|verificar|fazer|executar|buscar|obter|listar|criar|atualizar|deletar|abrir)\b/;
+    return actionVerbAfterConjunction.test(t);
+}
+export function compositeDelegationError() {
+    return "Delegation rejected: task must be atomic (single action). Split this request into multiple delegations, one task per action/tool.";
+}

package/dist/runtime/tools/index.js

@@ -3,3 +3,4 @@ export * from './config-tools.js';
 export * from './diagnostic-tools.js';
 export * from './analytics-tools.js';
 export * from './apoc-tool.js';
+export * from './neo-tool.js';