morpheus-cli 0.4.15 → 0.5.0

package/dist/runtime/tasks/dispatcher.js

@@ -0,0 +1,70 @@
+import { DisplayManager } from '../display.js';
+import { WebhookRepository } from '../webhooks/repository.js';
+import { AIMessage } from '@langchain/core/messages';
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+export class TaskDispatcher {
+    static telegramAdapter = null;
+    static display = DisplayManager.getInstance();
+    static setTelegramAdapter(adapter) {
+        TaskDispatcher.telegramAdapter = adapter;
+    }
+    static async notifyTaskResult(task) {
+        if (task.origin_channel === 'webhook') {
+            if (!task.origin_message_id) {
+                throw new Error('Webhook-origin task has no origin_message_id');
+            }
+            const repo = WebhookRepository.getInstance();
+            const status = task.status === 'completed' ? 'completed' : 'failed';
+            const result = 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.');
+            repo.updateNotificationResult(task.origin_message_id, status, result);
+            return;
+        }
+        if (task.origin_channel === 'ui') {
+            const statusIcon = task.status === 'completed' ? '✅' : '❌';
+            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.');
+            const content = `${statusIcon}\ Task \`${task.id.toUpperCase()}\`\n` +
+                `Agent: \`${task.agent.toUpperCase()}\`\n` +
+                `Status: \`${task.status.toUpperCase()}\`\n\n${body}`;
+            TaskDispatcher.display.log(`Writing UI task result to session "${task.session_id}" (task ${task.id})`, { source: 'TaskDispatcher', level: 'info' });
+            const history = new SQLiteChatMessageHistory({ sessionId: task.session_id });
+            try {
+                const msg = new AIMessage(content);
+                msg.provider_metadata = { provider: task.agent, model: 'task-result' };
+                await history.addMessage(msg);
+                TaskDispatcher.display.log(`UI task result written successfully to session "${task.session_id}"`, { source: 'TaskDispatcher' });
+            }
+            finally {
+                history.close();
+            }
+            return;
+        }
+        if (task.origin_channel !== 'telegram') {
+            return;
+        }
+        const adapter = TaskDispatcher.telegramAdapter;
+        if (!adapter) {
+            throw new Error('Telegram adapter not connected');
+        }
+        const statusIcon = task.status === 'completed' ? '✅' : '❌';
+        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.');
+        const header = `${statusIcon}\ Task \`${task.id.toUpperCase()}\`\n` +
+            `Agent: \`${task.agent.toUpperCase()}\`\n` +
+            `Status: \`${task.status.toUpperCase()}\``;
+        const message = `${header}\n\n${body}`;
+        if (task.origin_user_id) {
+            await adapter.sendMessageToUser(task.origin_user_id, message);
+            return;
+        }
+        TaskDispatcher.display.log(`Task ${task.id} has telegram origin but no origin_user_id; broadcasting to allowed users.`, { source: 'TaskDispatcher', level: 'warning' });
+        await adapter.sendMessage(message);
+    }
+    static async onTaskFinished(task) {
+        await TaskDispatcher.notifyTaskResult(task);
+    }
+}

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' });
+        }
+    }
+}