@anastops/mcp-server 0.1.0 → 1.1.0

package/dist/handlers/handlers.task.js

@@ -0,0 +1,762 @@
+/**
+ * MCP Tool Handlers - Task Management
+ * Handles: task_create, task_queue, task_status, task_complete, task_list, task_execute, task_cancel, task_retry, task_batch_create, task_batch_execute
+ */
+import { AdapterRegistry } from '@anastops/adapters';
+import { SessionManager, IntelligentRouter, addBreadcrumb, captureError, ProviderFailoverService, AllProvidersFailedError, } from '@anastops/core';
+import { nanoid } from 'nanoid';
+import { getPersistence } from '../persistence.js';
+import { safePersist, tasks, getTask } from './handlers.base.js';
+// Shared instances
+const router = new IntelligentRouter();
+const registry = AdapterRegistry.getInstance();
+const sessionManager = new SessionManager();
+const failoverService = new ProviderFailoverService(router);
+/**
+ * Process the task queue for a session.
+ * Starts queued tasks up to the concurrency limit if auto_execute is enabled.
+ * Returns the number of tasks started.
+ */
+function processTaskQueue(sessionId) {
+    // Check if session exists and has auto_execute enabled
+    if (!sessionManager.exists(sessionId)) {
+        return Promise.resolve(0);
+    }
+    const session = sessionManager.getSession(sessionId);
+    if (session.queue_config.auto_execute !== true) {
+        return Promise.resolve(0);
+    }
+    // Get all tasks for the session
+    const sessionTasks = [];
+    for (const [, task] of tasks.entries()) {
+        if (task.session_id === sessionId) {
+            sessionTasks.push(task);
+        }
+    }
+    // Count running tasks
+    const runningCount = sessionTasks.filter((t) => t.status === 'running').length;
+    const availableSlots = Math.max(0, session.queue_config.concurrency - runningCount);
+    if (availableSlots === 0) {
+        return Promise.resolve(0);
+    }
+    // Get queued tasks that have met dependencies
+    const taskMap = new Map(sessionTasks.map((t) => [t.id, t]));
+    const queuedTasks = sessionTasks
+        .filter((t) => t.status === 'queued')
+        .filter((task) => {
+        // Check if all dependencies are completed
+        if (task.dependencies.length === 0)
+            return true;
+        return task.dependencies.every((depId) => {
+            const depTask = taskMap.get(depId);
+            return depTask !== undefined && depTask.status === 'completed';
+        });
+    })
+        .sort((a, b) => {
+        // Sort by priority (higher first), then by created_at (earlier first)
+        if (a.priority !== b.priority)
+            return b.priority - a.priority;
+        return a.created_at.getTime() - b.created_at.getTime();
+    })
+        .slice(0, availableSlots);
+    // Start tasks (fire and forget)
+    let startedCount = 0;
+    for (const task of queuedTasks) {
+        // Execute task in background - don't await
+        void executeTaskInBackground(task.id);
+        startedCount++;
+    }
+    return Promise.resolve(startedCount);
+}
+/**
+ * Execute a task in the background.
+ * Used by queue processing to start tasks without blocking.
+ */
+async function executeTaskInBackground(taskId) {
+    try {
+        await handleTaskExecuteInternal(taskId);
+    }
+    catch {
+        // Error is already handled and persisted in handleTaskExecuteInternal
+    }
+}
+/**
+ * Internal task execution logic.
+ * Shared between handleTaskExecute and background execution.
+ */
+async function handleTaskExecuteInternal(taskId) {
+    const task = await getTask(taskId);
+    if (task === null) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    if (task.status !== 'pending' && task.status !== 'queued') {
+        return {
+            task_id: taskId,
+            status: task.status,
+            error: `Task cannot be executed - current status is '${task.status}'`,
+        };
+    }
+    addBreadcrumb('Executing task', { task_id: taskId, provider: task.provider }, 'info', 'task');
+    // Update task status to running
+    task.status = 'running';
+    task.started_at = new Date();
+    tasks.set(taskId, task);
+    safePersist(getPersistence().saveTask(task));
+    try {
+        const adapter = registry.get(task.provider);
+        if (adapter === undefined) {
+            throw new Error(`Provider adapter not found: ${task.provider}`);
+        }
+        const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
+        const taskInput = task.input;
+        const executeRequest = {
+            model: task.model,
+            prompt: taskInput?.prompt ?? task.description,
+            working_dir: workingDir,
+        };
+        if (taskInput?.agent !== undefined && taskInput.agent !== '') {
+            executeRequest.agent = taskInput.agent;
+        }
+        if (taskInput?.skills !== undefined && taskInput.skills.length > 0) {
+            executeRequest.skills = taskInput.skills;
+        }
+        // Execute with streaming logs support
+        const executeOptions = { workingDir };
+        // Add streaming logs callback
+        executeOptions.onProgress = (output) => {
+            // Update task logs in memory and persist
+            task.logs = output;
+            tasks.set(taskId, task);
+            safePersist(getPersistence().saveTask(task));
+        };
+        executeOptions.progressInterval = 1000; // Update logs every 1 second
+        const response = await adapter.execute(executeRequest, executeOptions);
+        task.status = 'completed';
+        task.completed_at = new Date();
+        task.token_usage = response.usage ?? task.token_usage;
+        task.output = {
+            content: response.content,
+            artifacts: [],
+            files_modified: [],
+            metadata: { usage: response.usage },
+        };
+        tasks.set(taskId, task);
+        safePersist(getPersistence().saveTask(task));
+        addBreadcrumb('Task completed', {
+            task_id: taskId,
+            tokens_used: response.usage?.total_tokens ?? 0,
+        }, 'info', 'task');
+        if (sessionManager.exists(task.session_id)) {
+            const session = sessionManager.getSession(task.session_id);
+            session.metadata = session.metadata ?? {
+                total_tokens: 0,
+                total_cost: 0,
+                agents_used: [],
+                files_affected: [],
+                tasks_completed: 0,
+                tasks_failed: 0,
+            };
+            session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
+            session.metadata.total_tokens =
+                (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
+            session.metadata.total_cost =
+                (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
+            session.updated_at = new Date();
+            safePersist(getPersistence().saveSession(session));
+        }
+        // Process queue to start next tasks
+        void processTaskQueue(task.session_id);
+        return {
+            task_id: taskId,
+            status: 'completed',
+            result: response,
+        };
+    }
+    catch (error) {
+        task.status = 'failed';
+        task.completed_at = new Date();
+        task.error = error instanceof Error ? error.message : String(error);
+        tasks.set(taskId, task);
+        safePersist(getPersistence().saveTask(task));
+        addBreadcrumb('Task failed', {
+            task_id: taskId,
+            error: task.error,
+        }, 'error', 'task');
+        captureError(error, {
+            task_id: taskId,
+            provider: task.provider,
+            type: task.type,
+        });
+        if (sessionManager.exists(task.session_id)) {
+            const session = sessionManager.getSession(task.session_id);
+            session.metadata = session.metadata ?? {
+                total_tokens: 0,
+                total_cost: 0,
+                agents_used: [],
+                files_affected: [],
+                tasks_completed: 0,
+                tasks_failed: 0,
+            };
+            session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
+            session.updated_at = new Date();
+            safePersist(getPersistence().saveSession(session));
+        }
+        // Process queue to start next tasks even after failure
+        void processTaskQueue(task.session_id);
+        throw error;
+    }
+}
+export function handleTaskCreate(args) {
+    const taskId = nanoid(21);
+    const now = new Date();
+    const taskType = args['type'] ?? 'other';
+    const sessionId = args['session_id'];
+    const description = args['description'];
+    addBreadcrumb('Creating task', { session_id: sessionId, type: taskType, description }, 'info', 'task');
+    // Store agent and skills in task input for execution
+    const taskInput = {
+        prompt: args['prompt'],
+        context_files: args['context_files'] ?? [],
+    };
+    if (args['agent'] !== undefined) {
+        taskInput.agent = args['agent'];
+    }
+    if (args['skills'] !== undefined) {
+        taskInput.skills = args['skills'];
+    }
+    const task = {
+        id: taskId,
+        session_id: sessionId,
+        agent_id: null,
+        type: taskType,
+        status: 'pending',
+        description,
+        input: taskInput,
+        output: null,
+        error: null,
+        complexity_score: 0,
+        routing_tier: 3,
+        provider: 'claude',
+        model: 'claude-sonnet',
+        token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
+        created_at: now,
+        started_at: null,
+        completed_at: null,
+        dependencies: [],
+        priority: 5,
+        retry_count: 0,
+        max_retries: 3,
+        failover_history: [],
+        failover_enabled: args['disable_failover'] !== true,
+    };
+    // Route the task with optional overrides
+    const routingOverride = {};
+    if (args['force_provider'] !== undefined) {
+        routingOverride.force_provider = args['force_provider'];
+    }
+    if (args['force_tier'] !== undefined) {
+        routingOverride.force_tier = args['force_tier'];
+    }
+    const routing = router.route(task, routingOverride);
+    task.routing_tier = routing.tier;
+    task.provider = routing.provider;
+    task.model = routing.model;
+    task.complexity_score = routing.complexity_score;
+    addBreadcrumb('Task routed', { task_id: taskId, provider: routing.provider, tier: routing.tier }, 'info', 'task');
+    tasks.set(taskId, task);
+    // Persist to MongoDB
+    safePersist(getPersistence().saveTask(task));
+    const response = {
+        task_id: task.id,
+        type: task.type,
+        routing: { tier: routing.tier, provider: routing.provider, model: routing.model },
+    };
+    if (taskInput.agent !== undefined && taskInput.agent !== '') {
+        response.agent = taskInput.agent;
+    }
+    return Promise.resolve(response);
+}
+export async function handleTaskQueue(args) {
+    const task = await getTask(args['task_id']);
+    if (task === null)
+        throw new Error('Task not found');
+    task.status = 'queued';
+    tasks.set(task.id, task);
+    safePersist(getPersistence().saveTask(task));
+    // Trigger queue processing to potentially start this task
+    const tasksStarted = await processTaskQueue(task.session_id);
+    return {
+        task_id: task.id,
+        status: task.status,
+        queue_processed: tasksStarted > 0,
+        tasks_started: tasksStarted,
+    };
+}
+export async function handleTaskStatus(args) {
+    const task = await getTask(args['task_id']);
+    if (task === null)
+        throw new Error('Task not found');
+    return task;
+}
+export async function handleTaskComplete(args) {
+    const task = await getTask(args['task_id']);
+    if (task === null)
+        throw new Error('Task not found');
+    task.status = 'completed';
+    task.completed_at = new Date();
+    task.output = {
+        content: args['content'],
+        artifacts: args['artifacts'] ?? [],
+        files_modified: [],
+        metadata: {},
+    };
+    tasks.set(task.id, task);
+    // Persist to MongoDB
+    safePersist(getPersistence().saveTask(task));
+    return { task_id: task.id, status: task.status };
+}
+export async function handleTaskList(args) {
+    // Get from in-memory cache first
+    const inMemoryTasks = [];
+    for (const [, task] of tasks.entries()) {
+        if (args['session_id'] === undefined || task.session_id === args['session_id']) {
+            inMemoryTasks.push(task);
+        }
+    }
+    // Also get from MongoDB for persistence
+    const persistedTasks = await getPersistence().listTasks({
+        ...(args['session_id'] !== undefined && { session_id: args['session_id'] }),
+    });
+    // Merge: in-memory takes precedence
+    const inMemoryIds = new Set(inMemoryTasks.map((t) => t.id));
+    const sessionTasks = [...inMemoryTasks, ...persistedTasks.filter((t) => !inMemoryIds.has(t.id))];
+    return {
+        count: sessionTasks.length,
+        tasks: sessionTasks.map((t) => ({
+            id: t.id,
+            type: t.type,
+            status: t.status,
+            description: t.description.slice(0, 50),
+        })),
+    };
+}
+export async function handleTaskExecute(args) {
+    const taskId = args['task_id'];
+    const wait = args['wait'] ?? true;
+    const task = await getTask(taskId);
+    if (task === null) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    if (task.status !== 'pending' && task.status !== 'queued') {
+        return {
+            task_id: taskId,
+            status: task.status,
+            error: `Task cannot be executed - current status is '${task.status}'`,
+        };
+    }
+    addBreadcrumb('Executing task', { task_id: taskId, provider: task.provider, failover_enabled: task.failover_enabled }, 'info', 'task');
+    // Update task status to running
+    task.status = 'running';
+    task.started_at = new Date();
+    tasks.set(taskId, task);
+    // Persist running status
+    safePersist(getPersistence().saveTask(task));
+    try {
+        // Use workspace root from environment or cwd
+        const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
+        // Build request with optional agent and skills
+        const taskInput = task.input;
+        const executeRequest = {
+            model: task.model,
+            prompt: taskInput?.prompt ?? task.description,
+            working_dir: workingDir,
+        };
+        // Get adapter for the task's provider
+        const adapter = registry.get(task.provider);
+        if (adapter === undefined) {
+            throw new Error(`Provider adapter not found: ${task.provider}`);
+        }
+        // Execute with streaming logs support (direct execution, no failover)
+        const executeOptions = {
+            workingDir,
+            onProgress: (output) => {
+                // Update task logs in memory and persist
+                task.logs = output;
+                tasks.set(taskId, task);
+                safePersist(getPersistence().saveTask(task));
+            },
+            progressInterval: 1000, // Update logs every 1 second
+        };
+        // Type assertion needed due to pnpm workspace linking not picking up updated types
+        const response = await adapter.execute(executeRequest, executeOptions);
+        // Update task with result
+        task.status = 'completed';
+        task.completed_at = new Date();
+        task.token_usage = response.usage ?? task.token_usage;
+        task.output = {
+            content: response.content,
+            artifacts: [],
+            files_modified: [],
+            metadata: {
+                usage: response.usage,
+            },
+        };
+        tasks.set(taskId, task);
+        // Persist completed task
+        safePersist(getPersistence().saveTask(task));
+        addBreadcrumb('Task completed', {
+            task_id: taskId,
+            tokens_used: response.usage?.total_tokens ?? 0,
+        }, 'info', 'task');
+        // Update session metadata via sessionManager
+        if (sessionManager.exists(task.session_id)) {
+            const session = sessionManager.getSession(task.session_id);
+            session.metadata = session.metadata ?? {
+                total_tokens: 0,
+                total_cost: 0,
+                agents_used: [],
+                files_affected: [],
+                tasks_completed: 0,
+                tasks_failed: 0,
+            };
+            session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
+            session.metadata.total_tokens =
+                (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
+            session.metadata.total_cost =
+                (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
+            session.updated_at = new Date();
+            safePersist(getPersistence().saveSession(session));
+        }
+        // Process queue to start next tasks after completion
+        void processTaskQueue(task.session_id);
+        return {
+            task_id: taskId,
+            status: 'completed',
+            result: response,
+            waited: wait,
+        };
+    }
+    catch (error) {
+        const failoverHistory = [];
+        task.status = 'failed';
+        task.completed_at = new Date();
+        task.error = error instanceof Error ? error.message : String(error);
+        task.failover_history = failoverHistory;
+        tasks.set(taskId, task);
+        // Persist failed task
+        safePersist(getPersistence().saveTask(task));
+        addBreadcrumb('Task failed', {
+            task_id: taskId,
+            error: task.error,
+            failover_attempts: failoverHistory.length,
+        }, 'error', 'task');
+        // Capture task execution error
+        captureError(error, {
+            task_id: taskId,
+            provider: task.provider,
+            type: task.type,
+            failover_attempts: failoverHistory.length,
+        });
+        // Update session metadata for failure via sessionManager
+        if (sessionManager.exists(task.session_id)) {
+            const session = sessionManager.getSession(task.session_id);
+            session.metadata = session.metadata ?? {
+                total_tokens: 0,
+                total_cost: 0,
+                agents_used: [],
+                files_affected: [],
+                tasks_completed: 0,
+                tasks_failed: 0,
+            };
+            session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
+            session.updated_at = new Date();
+            safePersist(getPersistence().saveSession(session));
+        }
+        // Process queue to start next tasks even after failure
+        void processTaskQueue(task.session_id);
+        throw error;
+    }
+}
+export async function handleTaskCancel(args) {
+    const taskId = args['task_id'];
+    const task = await getTask(taskId);
+    if (task === null) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    // Check if task is cancelable (pending, queued, or running)
+    const cancelableStatuses = ['pending', 'queued', 'running'];
+    if (!cancelableStatuses.includes(task.status)) {
+        return {
+            task_id: taskId,
+            status: task.status,
+            cancelled: false,
+            error: `Task cannot be cancelled - current status is '${task.status}'`,
+        };
+    }
+    // Cancel the task
+    task.status = 'cancelled';
+    task.completed_at = new Date();
+    tasks.set(taskId, task);
+    // Persist to MongoDB
+    safePersist(getPersistence().saveTask(task));
+    return {
+        task_id: taskId,
+        status: task.status,
+        cancelled: true,
+    };
+}
+export async function handleTaskRetry(args) {
+    const taskId = args['task_id'];
+    const task = await getTask(taskId);
+    if (task === null) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    // Check if task is in failed status
+    if (task.status !== 'failed') {
+        return {
+            task_id: taskId,
+            status: task.status,
+            retried: false,
+            error: `Task cannot be retried - current status is '${task.status}' (must be 'failed')`,
+        };
+    }
+    // Check if max retries exceeded
+    if (task.retry_count >= task.max_retries) {
+        return {
+            task_id: taskId,
+            status: task.status,
+            retried: false,
+            error: `Task has exceeded max retries (${task.max_retries})`,
+            retry_count: task.retry_count,
+        };
+    }
+    // Retry the task
+    task.status = 'pending';
+    task.retry_count += 1;
+    task.error = null;
+    task.started_at = null;
+    task.completed_at = null;
+    tasks.set(taskId, task);
+    // Persist to MongoDB
+    safePersist(getPersistence().saveTask(task));
+    return {
+        task_id: taskId,
+        status: task.status,
+        retried: true,
+        retry_count: task.retry_count,
+        max_retries: task.max_retries,
+    };
+}
+export function handleTaskBatchCreate(args) {
+    const sessionId = args['session_id'];
+    const taskDefs = args['tasks'];
+    const createdTasks = [];
+    const now = new Date();
+    for (const def of taskDefs) {
+        const taskId = nanoid(21);
+        const taskType = def.type ?? 'other';
+        const taskInput = {
+            prompt: def.prompt,
+            context_files: def.context_files ?? [],
+        };
+        if (def.agent !== undefined) {
+            taskInput.agent = def.agent;
+        }
+        if (def.skills !== undefined) {
+            taskInput.skills = def.skills;
+        }
+        const provider = def.force_provider ?? 'claude';
+        const model = 'claude-sonnet';
+        const tier = def.force_tier ?? 3;
+        const task = {
+            id: taskId,
+            session_id: sessionId,
+            agent_id: null,
+            type: taskType,
+            status: 'pending',
+            description: def.description,
+            input: taskInput,
+            output: null,
+            error: null,
+            complexity_score: 50,
+            routing_tier: tier,
+            provider: provider,
+            model: model,
+            token_usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost: 0 },
+            created_at: now,
+            started_at: null,
+            completed_at: null,
+            dependencies: [],
+            priority: 5,
+            retry_count: 0,
+            max_retries: 3,
+            failover_history: [],
+            failover_enabled: true, // Failover enabled by default for batch tasks
+        };
+        tasks.set(taskId, task);
+        safePersist(getPersistence().saveTask(task));
+        const createdTask = {
+            task_id: taskId,
+            type: task.type,
+            routing: { tier, provider, model },
+        };
+        if (taskInput.agent !== undefined) {
+            createdTask.agent = taskInput.agent;
+        }
+        createdTasks.push(createdTask);
+    }
+    return Promise.resolve({
+        created: createdTasks.length,
+        task_ids: createdTasks.map((t) => t.task_id),
+        tasks: createdTasks,
+    });
+}
+export async function handleTaskBatchExecute(args) {
+    const taskIds = args['task_ids'];
+    const parallel = args['parallel'] ?? true;
+    const wait = args['wait'] ?? true;
+    const executeOne = async (taskId) => {
+        const task = await getTask(taskId);
+        if (task === null) {
+            return { task_id: taskId, status: 'not_found', error: `Task not found: ${taskId}` };
+        }
+        if (task.status !== 'pending' && task.status !== 'queued') {
+            return {
+                task_id: taskId,
+                status: task.status,
+                error: `Task cannot be executed - current status is '${task.status}'`,
+            };
+        }
+        task.status = 'running';
+        task.started_at = new Date();
+        tasks.set(taskId, task);
+        safePersist(getPersistence().saveTask(task));
+        try {
+            const workingDir = process.env['ANASTOPS_WORKSPACE'] ?? process.cwd();
+            const taskInput = task.input;
+            const executeRequest = {
+                model: task.model,
+                prompt: taskInput?.prompt ?? task.description,
+                working_dir: workingDir,
+            };
+            // Execute with failover support
+            const failoverResult = await failoverService.executeWithFailover(task, executeRequest, registry, { workingDir });
+            const response = failoverResult.response;
+            task.status = 'completed';
+            task.completed_at = new Date();
+            task.provider = failoverResult.successful_provider;
+            task.routing_tier = failoverResult.successful_tier;
+            task.failover_history = failoverResult.attempt_history;
+            task.token_usage = response.usage ?? task.token_usage;
+            task.output = {
+                content: response.content,
+                artifacts: [],
+                files_modified: [],
+                metadata: {
+                    usage: response.usage,
+                    failover_used: failoverResult.failover_used,
+                    failover_attempts: failoverResult.failover_attempts,
+                },
+            };
+            tasks.set(taskId, task);
+            safePersist(getPersistence().saveTask(task));
+            if (sessionManager.exists(task.session_id)) {
+                const session = sessionManager.getSession(task.session_id);
+                session.metadata = session.metadata ?? {
+                    total_tokens: 0,
+                    total_cost: 0,
+                    agents_used: [],
+                    files_affected: [],
+                    tasks_completed: 0,
+                    tasks_failed: 0,
+                };
+                session.metadata.tasks_completed = (session.metadata.tasks_completed ?? 0) + 1;
+                session.metadata.total_tokens =
+                    (session.metadata.total_tokens ?? 0) + (response.usage?.total_tokens ?? 0);
+                session.metadata.total_cost =
+                    (session.metadata.total_cost ?? 0) + (response.usage?.cost ?? 0);
+                session.updated_at = new Date();
+                safePersist(getPersistence().saveSession(session));
+            }
+            const batchResult = {
+                task_id: taskId,
+                status: 'completed',
+                result: { content: response.content, usage: response.usage },
+            };
+            if (failoverResult.failover_used) {
+                batchResult.failover = {
+                    used: true,
+                    attempts: failoverResult.failover_attempts,
+                    final_provider: failoverResult.successful_provider,
+                    final_tier: failoverResult.successful_tier,
+                };
+            }
+            return batchResult;
+        }
+        catch (error) {
+            // Get failover history from error if available
+            const failoverHistory = error instanceof AllProvidersFailedError ? error.failoverHistory : [];
+            task.status = 'failed';
+            task.completed_at = new Date();
+            task.error = error instanceof Error ? error.message : String(error);
+            task.failover_history = failoverHistory;
+            tasks.set(taskId, task);
+            safePersist(getPersistence().saveTask(task));
+            if (sessionManager.exists(task.session_id)) {
+                const session = sessionManager.getSession(task.session_id);
+                session.metadata = session.metadata ?? {
+                    total_tokens: 0,
+                    total_cost: 0,
+                    agents_used: [],
+                    files_affected: [],
+                    tasks_completed: 0,
+                    tasks_failed: 0,
+                };
+                session.metadata.tasks_failed = (session.metadata.tasks_failed ?? 0) + 1;
+                session.updated_at = new Date();
+                safePersist(getPersistence().saveSession(session));
+            }
+            return {
+                task_id: taskId,
+                status: 'failed',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    };
+    let results;
+    if (parallel) {
+        results = await Promise.all(taskIds.map(executeOne));
+    }
+    else {
+        results = [];
+        for (const taskId of taskIds) {
+            results.push(await executeOne(taskId));
+        }
+    }
+    const failoverUsedCount = results.filter((r) => r.failover?.used).length;
+    const summary = {
+        completed: results.filter((r) => r.status === 'completed').length,
+        failed: results.filter((r) => r.status === 'failed').length,
+        skipped: results.filter((r) => r.status !== 'completed' && r.status !== 'failed').length,
+        failover_used: failoverUsedCount,
+    };
+    // Process queues for all sessions involved
+    const sessionIds = new Set();
+    for (const taskId of taskIds) {
+        const task = await getTask(taskId);
+        if (task !== null) {
+            sessionIds.add(task.session_id);
+        }
+    }
+    for (const sessionId of sessionIds) {
+        void processTaskQueue(sessionId);
+    }
+    return {
+        executed: results.length,
+        parallel,
+        waited: wait,
+        results,
+        summary,
+    };
+}
+//# sourceMappingURL=handlers.task.js.map