@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/services/orchestration/execution/OrchestrationExecutionRuntime.js

@@ -0,0 +1,1147 @@
+import { randomUUID } from 'node:crypto';
+import { getOrchestrationDatabase, nowIso, requireText, toNullableText, withOrchestrationTransaction, } from '../../../utils/orchestration/store/orchestrationDb.js';
+import { getOrchestrationRunById, createOrchestrationRun, listOrchestrationTasks, listOrchestrationMessages, createOrchestrationTaskResult, upsertOrchestrationDomainReport, upsertOrchestrationRunReport, } from '../../../utils/orchestration/store/runStore.js';
+import { getProviderWorkspaceById } from '../../../utils/orchestration/store/providerWorkspaceStore.js';
+import { getProviderAgentById, listProviderAgentCapabilities, } from '../../../utils/orchestration/store/providerAgentStore.js';
+import { getTeamDomainById, listTeamDomainMembers, } from '../../../utils/orchestration/store/teamStore.js';
+import { executeAgentDomainTask, } from './AgentTaskExecutor.js';
+const RUN_TRANSITIONS = {
+    planned: ['in_progress', 'cancelled'],
+    in_progress: ['completed', 'failed', 'cancelled'],
+    completed: [],
+    failed: ['in_progress', 'cancelled'],
+    cancelled: ['in_progress'],
+};
+const TASK_TRANSITIONS = {
+    pending: ['ready', 'in_progress', 'blocked', 'failed', 'completed'],
+    ready: ['in_progress', 'blocked', 'failed', 'completed'],
+    in_progress: ['completed', 'failed', 'blocked'],
+    completed: [],
+    failed: ['ready', 'blocked'],
+    blocked: ['ready', 'in_progress'],
+};
+function rowToRun(row) {
+    if (!row) {
+        return null;
+    }
+    const typed = row;
+    return {
+        id: typed.id,
+        teamId: typed.team_id,
+        goal: typed.goal,
+        globalOrchestratorAgentId: typed.global_orchestrator_agent_id ?? null,
+        status: typed.status,
+        createdAt: typed.created_at,
+        updatedAt: typed.created_at,
+        startedAt: typed.started_at ?? null,
+        finishedAt: typed.finished_at ?? null,
+    };
+}
+function rowToTask(row) {
+    if (!row) {
+        return null;
+    }
+    const typed = row;
+    return {
+        id: typed.id,
+        runId: typed.run_id,
+        parentTaskId: typed.parent_task_id ?? null,
+        scopeType: typed.scope_type,
+        teamDomainId: typed.team_domain_id ?? null,
+        assignedAgentId: typed.assigned_agent_id ?? null,
+        title: typed.title,
+        instructions: typed.instructions,
+        status: typed.status,
+        resultSummary: typed.result_summary ?? null,
+        createdAt: typed.created_at,
+        finishedAt: typed.finished_at ?? null,
+    };
+}
+function rowToMessage(row) {
+    if (!row) {
+        return null;
+    }
+    const typed = row;
+    return {
+        id: typed.id,
+        runId: typed.run_id,
+        taskId: typed.task_id ?? null,
+        fromAgentId: typed.from_agent_id ?? null,
+        toAgentId: typed.to_agent_id ?? null,
+        messageType: typed.message_type,
+        content: typed.content,
+        createdAt: typed.created_at,
+    };
+}
+function nowMessage(operation, detail) {
+    return detail?.trim()
+        ? `${operation}: ${detail.trim()}`
+        : operation;
+}
+function isTerminalRunStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+}
+function isTerminalTaskStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'blocked';
+}
+function isRunnableTaskStatus(status) {
+    return status === 'ready' || status === 'in_progress';
+}
+function validateRunTransition(current, next) {
+    if (current === next) {
+        return;
+    }
+    if (!RUN_TRANSITIONS[current].includes(next)) {
+        throw new Error(`No se puede transicionar una corrida de ${current} a ${next}.`);
+    }
+}
+function validateTaskTransition(current, next) {
+    if (current === next) {
+        return;
+    }
+    if (!TASK_TRANSITIONS[current].includes(next)) {
+        throw new Error(`No se puede transicionar una tarea de ${current} a ${next}.`);
+    }
+}
+function isOpenTaskStatus(status) {
+    return status === 'pending' || status === 'ready' || status === 'in_progress';
+}
+function sortCapabilities(capabilities) {
+    return [...capabilities]
+        .sort((a, b) => b.weight - a.weight || a.capability.localeCompare(b.capability))
+        .map(capability => capability.capability);
+}
+function normalizePolicy(policy) {
+    return {
+        mode: policy?.mode ?? 'manual',
+        requiredCapabilities: policy?.requiredCapabilities ?? [],
+        preferredCapabilities: policy?.preferredCapabilities ?? [],
+        allowFallback: policy?.allowFallback ?? true,
+    };
+}
+function selectExecutionAgent(task, domain, members, policy) {
+    const candidates = [
+        task.assignedAgentId,
+        domain?.localOrchestratorAgentId,
+        domain?.leadAgentId,
+        ...members.map(member => member.agentId),
+    ].filter((agentId) => Boolean(agentId));
+    if (candidates.length === 0) {
+        return null;
+    }
+    if (policy.mode === 'manual') {
+        return candidates[0] ?? null;
+    }
+    // Phase 4 contract hook: execution remains deterministic until richer scoring lands.
+    return candidates[0] ?? null;
+}
+function buildTaskSummary(input) {
+    const domainName = input.domain?.domainName ?? input.task.scopeType;
+    const agentName = input.agent?.name ?? input.task.assignedAgentId ?? 'sin-agente';
+    const capabilityText = input.capabilities.length > 0
+        ? ` Capacidades: ${input.capabilities.slice(0, 5).join(', ')}.`
+        : '';
+    return [
+        `Escuadron ${domainName} ejecuto la tarea "${input.task.title}" con ${agentName}.`,
+        `Objetivo global: ${input.run.goal}.`,
+        `Miembros disponibles: ${input.memberCount}.`,
+        capabilityText,
+    ]
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function buildExecutionMessage(executionResult, summary) {
+    const modelText = executionResult.model ? ` con ${executionResult.model}` : '';
+    const header = `${executionResult.provider}/${executionResult.profileId}${modelText}: ${summary}`;
+    return executionResult.output?.trim()
+        ? `${header}\n\n${executionResult.output.trim()}`
+        : header;
+}
+function summarizeRun(run, tasks, reports) {
+    const completedTasks = tasks.filter(task => task.status === 'completed').length;
+    const failedTasks = tasks.filter(task => task.status === 'failed').length;
+    const blockedTasks = tasks.filter(task => task.status === 'blocked').length;
+    const openTasks = tasks.filter(task => isOpenTaskStatus(task.status)).length;
+    const status = run.status === 'cancelled'
+        ? 'cancelled'
+        : openTasks > 0
+            ? 'in_progress'
+            : failedTasks > 0 || blockedTasks > 0
+                ? 'failed'
+                : 'completed';
+    const summary = [
+        `Run ${run.id}: ${completedTasks} completadas`,
+        failedTasks > 0 ? `${failedTasks} fallidas` : null,
+        blockedTasks > 0 ? `${blockedTasks} bloqueadas` : null,
+        openTasks > 0 ? `${openTasks} abiertas` : null,
+    ]
+        .filter(Boolean)
+        .join(', ');
+    return {
+        runId: run.id,
+        status,
+        completedTasks,
+        failedTasks,
+        blockedTasks,
+        openTasks,
+        summary,
+        domainReports: reports,
+        generatedAt: nowIso(),
+    };
+}
+async function loadTaskDomainContext(task) {
+    if (!task.teamDomainId) {
+        return { domain: null, members: [] };
+    }
+    const domain = await getTeamDomainById(task.teamDomainId);
+    const members = domain ? await listTeamDomainMembers(domain.id) : [];
+    return { domain, members };
+}
+async function loadRunState(runId) {
+    const run = await getOrchestrationRunById(runId);
+    if (!run) {
+        return null;
+    }
+    const db = await getOrchestrationDatabase();
+    const tasks = db
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
+       WHERE run_id = ?
+       ORDER BY created_at, id`)
+        .all(requireText(runId, 'runId'))
+        .map(rowToTask)
+        .filter((task) => task !== null);
+    const messages = db
+        .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+       FROM orchestration_messages
+       WHERE run_id = ?
+       ORDER BY created_at, id`)
+        .all(requireText(runId, 'runId'))
+        .map(rowToMessage)
+        .filter((message) => message !== null);
+    return { run, tasks, messages };
+}
+async function loadTaskAndRunState(taskId) {
+    const db = await getOrchestrationDatabase();
+    const row = db
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
+       WHERE id = ?`)
+        .get(requireText(taskId, 'taskId'));
+    const task = rowToTask(row);
+    if (!task) {
+        return null;
+    }
+    const run = await getOrchestrationRunById(task.runId);
+    if (!run) {
+        return null;
+    }
+    return { run, task };
+}
+async function updateTasksByRun(runId, transform) {
+    const db = await getOrchestrationDatabase();
+    const rows = db
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
+       WHERE run_id = ?`)
+        .all(requireText(runId, 'runId'))
+        .map(rowToTask)
+        .filter((task) => task !== null);
+    for (const task of rows) {
+        const patch = transform(task);
+        if (!patch) {
+            continue;
+        }
+        db.prepare(`UPDATE orchestration_tasks
+       SET status = ?, result_summary = ?, finished_at = ?
+       WHERE id = ?`).run(patch.status ?? task.status, patch.result_summary ?? task.resultSummary ?? null, patch.finished_at ?? task.finishedAt ?? null, task.id);
+    }
+}
+async function writeRunTransition(runId, nextStatus, options) {
+    const db = await getOrchestrationDatabase();
+    const current = await getOrchestrationRunById(runId);
+    if (!current) {
+        throw new Error(`Orchestration run not found: ${runId}`);
+    }
+    validateRunTransition(current.status, nextStatus);
+    const startedAt = options?.startedAt === undefined
+        ? current.startedAt
+        : toNullableText(options.startedAt);
+    const finishedAt = options?.finishedAt === undefined
+        ? current.finishedAt
+        : toNullableText(options.finishedAt);
+    db.prepare(`UPDATE orchestration_runs
+     SET status = ?, started_at = ?, finished_at = ?
+     WHERE id = ?`).run(nextStatus, startedAt, finishedAt, runId);
+}
+async function writeTaskTransition(taskId, nextStatus, options) {
+    const db = await getOrchestrationDatabase();
+    const current = await loadTaskAndRunState(taskId);
+    if (!current) {
+        throw new Error(`Orchestration task not found: ${taskId}`);
+    }
+    validateTaskTransition(current.task.status, nextStatus);
+    const finishedAt = options?.finishedAt === undefined
+        ? isTerminalTaskStatus(nextStatus)
+            ? nowIso()
+            : null
+        : toNullableText(options.finishedAt);
+    db.prepare(`UPDATE orchestration_tasks
+     SET status = ?, result_summary = ?, finished_at = ?
+     WHERE id = ?`).run(nextStatus, options?.resultSummary === undefined
+        ? current.task.resultSummary
+        : toNullableText(options.resultSummary), finishedAt, taskId);
+}
+async function resolveAgentExecutionLabel(assignedAgentId) {
+    if (!assignedAgentId) {
+        return {
+            ok: false,
+            label: 'sin asignar',
+            reason: 'La tarea no tiene agente asignado.',
+        };
+    }
+    const agent = await getProviderAgentById(assignedAgentId);
+    if (!agent) {
+        return {
+            ok: false,
+            label: `${assignedAgentId} (missing)`,
+            reason: 'El agente asignado ya no existe.',
+        };
+    }
+    const workspace = await getProviderWorkspaceById(agent.workspaceId);
+    if (!workspace) {
+        return {
+            ok: false,
+            label: agent.name,
+            reason: 'El workspace del agente asignado ya no existe.',
+        };
+    }
+    const label = `${workspace.provider}/${agent.name}`;
+    if (!workspace.isEnabled) {
+        return {
+            ok: false,
+            label,
+            reason: `El workspace ${workspace.displayName} esta deshabilitado.`,
+        };
+    }
+    if (!agent.isEnabled) {
+        return {
+            ok: false,
+            label,
+            reason: `El agente ${label} esta deshabilitado.`,
+        };
+    }
+    return { ok: true, label };
+}
+async function executeRunnableTasks(runId, operation) {
+    const runState = await loadRunState(runId);
+    if (!runState) {
+        throw new Error(`Orchestration run not found: ${runId}`);
+    }
+    for (const task of runState.tasks) {
+        if (!isRunnableTaskStatus(task.status)) {
+            continue;
+        }
+        const agent = await resolveAgentExecutionLabel(task.assignedAgentId);
+        if (!agent.ok) {
+            await writeTaskTransition(task.id, 'blocked', {
+                resultSummary: agent.reason,
+                finishedAt: null,
+            });
+            const refreshed = await loadTaskAndRunState(task.id);
+            await new OrchestrationExecutionRuntime().appendMessage(runId, 'task.blocked', `${task.title}: ${agent.reason}`, task.id, runState.run.globalOrchestratorAgentId, refreshed?.task.assignedAgentId ?? task.assignedAgentId);
+            continue;
+        }
+        if (task.status !== 'in_progress') {
+            await writeTaskTransition(task.id, 'in_progress', {
+                resultSummary: task.resultSummary,
+                finishedAt: null,
+            });
+        }
+        await new OrchestrationExecutionRuntime().appendMessage(runId, 'task.started', `${task.title}: ejecucion delegada a ${agent.label}.`, task.id, runState.run.globalOrchestratorAgentId, task.assignedAgentId);
+        const resultSummary = operation === 'resume'
+            ? `Reanudado y reportado por ${agent.label}.`
+            : `Ejecutado y reportado por ${agent.label}.`;
+        await writeTaskTransition(task.id, 'completed', {
+            resultSummary,
+            finishedAt: nowIso(),
+        });
+        await new OrchestrationExecutionRuntime().appendMessage(runId, 'task.completed', `${task.title}: ${resultSummary}`, task.id, task.assignedAgentId, runState.run.globalOrchestratorAgentId);
+    }
+}
+async function finalizeRunFromTasks(runId) {
+    const state = await loadRunState(runId);
+    if (!state) {
+        throw new Error(`Orchestration run not found: ${runId}`);
+    }
+    const hasOpenTasks = state.tasks.some(task => task.status === 'pending' ||
+        task.status === 'ready' ||
+        task.status === 'in_progress');
+    const hasBlockedOrFailedTasks = state.tasks.some(task => task.status === 'blocked' || task.status === 'failed');
+    const nextStatus = hasOpenTasks || hasBlockedOrFailedTasks ? 'failed' : 'completed';
+    await writeRunTransition(runId, nextStatus, {
+        startedAt: state.run.startedAt ?? nowIso(),
+        finishedAt: nowIso(),
+    });
+    await new OrchestrationExecutionRuntime().appendMessage(runId, nextStatus === 'completed' ? 'run.completed' : 'run.failed', nextStatus === 'completed'
+        ? 'Todos los dominios ejecutables reportaron resultado al orquestador global.'
+        : 'La corrida termino con dominios bloqueados o fallidos.', null, state.run.globalOrchestratorAgentId, null);
+}
+export class OrchestrationExecutionRuntime {
+    async getRunState(runId) {
+        return loadRunState(runId);
+    }
+    async getState(runId) {
+        return this.getRunState(runId);
+    }
+    async startRun(input) {
+        const runId = requireText(input.runId, 'runId');
+        const runState = await loadRunState(runId);
+        if (!runState) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        if (runState.run.status === 'completed') {
+            throw new Error('No se puede iniciar una corrida completada.');
+        }
+        const changed = runState.run.status !== 'in_progress';
+        await withOrchestrationTransaction(async (db) => {
+            const startedAt = runState.run.startedAt ?? nowIso();
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = NULL
+         WHERE id = ?`).run('in_progress', startedAt, runId);
+            if (input.promotePendingTasks !== false) {
+                for (const task of runState.tasks) {
+                    if (task.status === 'pending' || task.status === 'blocked') {
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = NULL
+               WHERE id = ?`).run('ready', task.id);
+                    }
+                }
+            }
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.start', nowMessage('start', input.note), nowIso());
+        });
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        if (input.executeReadyTasks !== false) {
+            return this.executeReadyDomainTasks({
+                runId,
+                note: 'Ejecucion automatica posterior al inicio.',
+                onProgress: input.onProgress,
+            });
+        }
+        return {
+            ...refreshed,
+            operation: 'start',
+            changed,
+        };
+    }
+    async resumeRun(input) {
+        const runId = requireText(input.runId, 'runId');
+        const runState = await loadRunState(runId);
+        if (!runState) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        if (runState.run.status === 'completed') {
+            throw new Error('No se puede reanudar una corrida completada.');
+        }
+        const changed = runState.run.status !== 'in_progress';
+        await withOrchestrationTransaction(async (db) => {
+            const startedAt = runState.run.startedAt ?? nowIso();
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = NULL
+         WHERE id = ?`).run('in_progress', startedAt, runId);
+            if (input.reactivateBlockedTasks !== false) {
+                for (const task of runState.tasks) {
+                    if (task.status === 'blocked' || task.status === 'failed' || task.status === 'pending') {
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = NULL
+               WHERE id = ?`).run('ready', task.id);
+                    }
+                }
+            }
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.resume', nowMessage('resume', input.note), nowIso());
+        });
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        if (input.executeReadyTasks !== false) {
+            return this.executeReadyDomainTasks({
+                runId,
+                note: 'Ejecucion automatica posterior a la reanudacion.',
+                onProgress: input.onProgress,
+            });
+        }
+        return {
+            ...refreshed,
+            operation: 'resume',
+            changed,
+        };
+    }
+    async cancelRun(input) {
+        const runId = requireText(input.runId, 'runId');
+        const runState = await loadRunState(runId);
+        if (!runState) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        const changed = runState.run.status !== 'cancelled';
+        await withOrchestrationTransaction(async (db) => {
+            const finishedAt = nowIso();
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
+         WHERE id = ?`).run('cancelled', finishedAt, runId);
+            if (input.blockOpenTasks !== false) {
+                for (const task of runState.tasks) {
+                    if (task.status !== 'completed') {
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = ?
+               WHERE id = ?`).run('blocked', finishedAt, task.id);
+                    }
+                }
+            }
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.cancel', nowMessage('cancel', input.reason), nowIso());
+        });
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        return {
+            ...refreshed,
+            operation: 'cancel',
+            changed,
+        };
+    }
+    async transitionRun(input) {
+        const runId = requireText(input.runId, 'runId');
+        const current = await getOrchestrationRunById(runId);
+        if (!current) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        const changed = current.status !== input.status;
+        await withOrchestrationTransaction(async (db) => {
+            validateRunTransition(current.status, input.status);
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = ?
+         WHERE id = ?`).run(input.status, input.startedAt === undefined
+                ? current.startedAt
+                : toNullableText(input.startedAt), input.finishedAt === undefined
+                ? current.finishedAt
+                : toNullableText(input.finishedAt), runId);
+            if (input.note) {
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.transition', nowMessage('transition-run', input.note), nowIso());
+            }
+        });
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        return {
+            ...refreshed,
+            operation: 'transition-run',
+            changed,
+        };
+    }
+    async transitionTask(input) {
+        const taskId = requireText(input.taskId, 'taskId');
+        const loaded = await loadTaskAndRunState(taskId);
+        if (!loaded) {
+            throw new Error(`Orchestration task not found: ${taskId}`);
+        }
+        const changed = loaded.task.status !== input.status;
+        await withOrchestrationTransaction(async (db) => {
+            validateTaskTransition(loaded.task.status, input.status);
+            db.prepare(`UPDATE orchestration_tasks
+         SET status = ?, result_summary = ?, finished_at = ?
+         WHERE id = ?`).run(input.status, input.resultSummary === undefined
+                ? loaded.task.resultSummary
+                : toNullableText(input.resultSummary), input.finishedAt === undefined
+                ? isTerminalTaskStatus(input.status)
+                    ? nowIso()
+                    : null
+                : toNullableText(input.finishedAt), taskId);
+            if (input.note) {
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), loaded.run.id, taskId, null, null, 'task.transition', nowMessage('transition-task', input.note), nowIso());
+            }
+        });
+        const refreshed = await loadRunState(loaded.run.id);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${loaded.run.id}`);
+        }
+        return {
+            ...refreshed,
+            operation: 'transition-task',
+            changed,
+        };
+    }
+    async executeReadyDomainTasks(input) {
+        const runId = requireText(input.runId, 'runId');
+        const policy = normalizePolicy(input.policy);
+        const initial = await loadRunState(runId);
+        if (!initial) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        if (initial.run.status === 'completed') {
+            throw new Error('No se puede ejecutar una corrida completada.');
+        }
+        if (initial.run.status === 'cancelled') {
+            throw new Error('No se puede ejecutar una corrida cancelada.');
+        }
+        const readyTasks = initial.tasks
+            .filter(task => task.status === 'ready')
+            .slice(0, input.limit && input.limit > 0 ? input.limit : undefined);
+        const totalReadyTasks = readyTasks.length;
+        let processedReadyTasks = 0;
+        const progressPercent = () => totalReadyTasks === 0
+            ? 100
+            : Math.min(100, Math.round((processedReadyTasks / totalReadyTasks) * 100));
+        if (readyTasks.length === 0) {
+            const consolidatedReport = await this.consolidateRunReport(runId);
+            const refreshed = await loadRunState(runId);
+            if (!refreshed) {
+                throw new Error(`Failed to reload orchestration run: ${runId}`);
+            }
+            return {
+                ...refreshed,
+                operation: 'execute-ready',
+                changed: false,
+                reports: [],
+                consolidatedReport,
+            };
+        }
+        if (initial.run.status !== 'in_progress') {
+            await writeRunTransition(runId, 'in_progress', {
+                startedAt: initial.run.startedAt ?? nowIso(),
+                finishedAt: null,
+            });
+        }
+        if (input.note) {
+            await this.appendMessage(runId, 'run.execute-ready', nowMessage('execute-ready', input.note));
+        }
+        const reports = [];
+        for (const task of readyTasks) {
+            const { domain, members } = await loadTaskDomainContext(task);
+            const domainName = domain?.domainName ?? task.scopeType;
+            const selectedAgentId = selectExecutionAgent(task, domain, members, policy);
+            const localOrchestratorAgentId = domain?.localOrchestratorAgentId ?? null;
+            const leadAgentId = domain?.leadAgentId ?? null;
+            input.onProgress?.({
+                runId,
+                taskId: task.id,
+                domainName,
+                phase: 'dispatching',
+                detail: 'seleccionando agente',
+                progressPercent: progressPercent(),
+            });
+            if (!selectedAgentId) {
+                const summary = `Dominio ${domainName} bloqueado: no hay agente asignado ni miembros disponibles.`;
+                const blockedAt = nowIso();
+                input.onProgress?.({
+                    runId,
+                    taskId: task.id,
+                    domainName,
+                    phase: 'blocked',
+                    detail: 'sin agente asignado',
+                    progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
+                });
+                await writeTaskTransition(task.id, 'blocked', {
+                    resultSummary: summary,
+                    finishedAt: blockedAt,
+                });
+                await createOrchestrationTaskResult({
+                    runId,
+                    taskId: task.id,
+                    agentId: null,
+                    resultType: 'domain-execution',
+                    status: 'submitted',
+                    summary,
+                    content: summary,
+                    metadataJson: JSON.stringify({
+                        domainName: domain?.domainName ?? null,
+                        status: 'blocked',
+                        reason: 'no-agent',
+                    }),
+                });
+                if (task.teamDomainId) {
+                    await upsertOrchestrationDomainReport({
+                        runId,
+                        teamDomainId: task.teamDomainId,
+                        localOrchestratorAgentId,
+                        status: 'needs_revision',
+                        summary,
+                        blockers: 'No hay agente disponible para ejecutar el dominio.',
+                        output: summary,
+                        metricsJson: JSON.stringify({
+                            completedTasks: 0,
+                            blockedTasks: 1,
+                            failedTasks: 0,
+                            memberCount: members.length,
+                        }),
+                        submittedAt: blockedAt,
+                    });
+                }
+                await this.appendMessage(runId, 'squad.blocked', summary, task.id, localOrchestratorAgentId, initial.run.globalOrchestratorAgentId);
+                reports.push({
+                    taskId: task.id,
+                    domainName: domain?.domainName ?? null,
+                    assignedAgentId: null,
+                    localOrchestratorAgentId,
+                    leadAgentId,
+                    memberAgentIds: members.map(member => member.agentId),
+                    status: 'blocked',
+                    summary,
+                    blockers: ['No hay agente disponible para ejecutar el dominio.'],
+                    completedAt: blockedAt,
+                });
+                processedReadyTasks += 1;
+                continue;
+            }
+            const agent = await getProviderAgentById(selectedAgentId);
+            const capabilities = sortCapabilities(agent ? await listProviderAgentCapabilities(agent.id) : []);
+            if (!agent || !agent.isEnabled) {
+                const summary = `Dominio ${domainName} bloqueado: el agente asignado no existe o esta deshabilitado.`;
+                const blockedAt = nowIso();
+                input.onProgress?.({
+                    runId,
+                    taskId: task.id,
+                    domainName,
+                    agentLabel: selectedAgentId,
+                    phase: 'blocked',
+                    detail: 'agente deshabilitado o inexistente',
+                    progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
+                });
+                await writeTaskTransition(task.id, 'blocked', {
+                    resultSummary: summary,
+                    finishedAt: blockedAt,
+                });
+                await createOrchestrationTaskResult({
+                    runId,
+                    taskId: task.id,
+                    agentId: selectedAgentId,
+                    resultType: 'domain-execution',
+                    status: 'submitted',
+                    summary,
+                    content: summary,
+                    metadataJson: JSON.stringify({
+                        domainName: domain?.domainName ?? null,
+                        status: 'blocked',
+                        reason: 'agent-disabled-or-missing',
+                    }),
+                });
+                if (task.teamDomainId) {
+                    await upsertOrchestrationDomainReport({
+                        runId,
+                        teamDomainId: task.teamDomainId,
+                        localOrchestratorAgentId,
+                        status: 'needs_revision',
+                        summary,
+                        blockers: 'El agente asignado no existe o esta deshabilitado.',
+                        output: summary,
+                        metricsJson: JSON.stringify({
+                            completedTasks: 0,
+                            blockedTasks: 1,
+                            failedTasks: 0,
+                            memberCount: members.length,
+                        }),
+                        submittedAt: blockedAt,
+                    });
+                }
+                await this.appendMessage(runId, 'squad.blocked', summary, task.id, selectedAgentId, initial.run.globalOrchestratorAgentId);
+                reports.push({
+                    taskId: task.id,
+                    domainName: domain?.domainName ?? null,
+                    assignedAgentId: selectedAgentId,
+                    localOrchestratorAgentId,
+                    leadAgentId,
+                    memberAgentIds: members.map(member => member.agentId),
+                    status: 'blocked',
+                    summary,
+                    blockers: ['El agente asignado no esta habilitado.'],
+                    completedAt: blockedAt,
+                });
+                processedReadyTasks += 1;
+                continue;
+            }
+            const workspace = await getProviderWorkspaceById(agent.workspaceId);
+            const agentLabel = workspace ? `${workspace.provider}/${agent.name}` : agent.name;
+            if (!workspace || !workspace.isEnabled) {
+                const summary = `Dominio ${domainName} bloqueado: el workspace del agente no existe o esta deshabilitado.`;
+                const blockedAt = nowIso();
+                input.onProgress?.({
+                    runId,
+                    taskId: task.id,
+                    domainName,
+                    agentLabel,
+                    phase: 'blocked',
+                    detail: 'workspace deshabilitado o inexistente',
+                    progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
+                });
+                await writeTaskTransition(task.id, 'blocked', {
+                    resultSummary: summary,
+                    finishedAt: blockedAt,
+                });
+                await createOrchestrationTaskResult({
+                    runId,
+                    taskId: task.id,
+                    agentId: selectedAgentId,
+                    resultType: 'domain-execution',
+                    status: 'rejected',
+                    summary,
+                    content: summary,
+                    metadataJson: JSON.stringify({
+                        domainName: domain?.domainName ?? null,
+                        status: 'blocked',
+                        reason: 'workspace-disabled-or-missing',
+                    }),
+                });
+                if (task.teamDomainId) {
+                    await upsertOrchestrationDomainReport({
+                        runId,
+                        teamDomainId: task.teamDomainId,
+                        localOrchestratorAgentId,
+                        status: 'needs_revision',
+                        summary,
+                        blockers: 'El workspace del agente no existe o esta deshabilitado.',
+                        output: summary,
+                        metricsJson: JSON.stringify({
+                            completedTasks: 0,
+                            blockedTasks: 1,
+                            failedTasks: 0,
+                            memberCount: members.length,
+                        }),
+                        submittedAt: blockedAt,
+                    });
+                }
+                await this.appendMessage(runId, 'squad.blocked', summary, task.id, selectedAgentId, initial.run.globalOrchestratorAgentId);
+                reports.push({
+                    taskId: task.id,
+                    domainName: domain?.domainName ?? null,
+                    assignedAgentId: selectedAgentId,
+                    localOrchestratorAgentId,
+                    leadAgentId,
+                    memberAgentIds: members.map(member => member.agentId),
+                    status: 'blocked',
+                    summary,
+                    blockers: ['El workspace del agente no esta habilitado.'],
+                    completedAt: blockedAt,
+                });
+                processedReadyTasks += 1;
+                continue;
+            }
+            await withOrchestrationTransaction(async (db) => {
+                db.prepare(`UPDATE orchestration_tasks
+           SET status = ?, assigned_agent_id = ?, finished_at = NULL
+           WHERE id = ?`).run('in_progress', selectedAgentId, task.id);
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, task.id, initial.run.globalOrchestratorAgentId, selectedAgentId, 'task.dispatch', `Dominio ${domainName}: tarea enviada a ${agent.name}.`, nowIso());
+            });
+            input.onProgress?.({
+                runId,
+                taskId: task.id,
+                domainName,
+                agentLabel,
+                phase: 'executing',
+                detail: `modelo/perfil del agente en uso`,
+                progressPercent: progressPercent(),
+            });
+            const fallbackSummary = buildTaskSummary({
+                run: initial.run,
+                task: { ...task, assignedAgentId: selectedAgentId },
+                domain,
+                agent,
+                capabilities,
+                memberCount: members.length,
+            });
+            const executionResult = await executeAgentDomainTask({
+                run: initial.run,
+                task: { ...task, assignedAgentId: selectedAgentId },
+                domain,
+                agent,
+                workspace,
+                capabilities,
+                members,
+            });
+            const summary = executionResult.summary || fallbackSummary;
+            const completedAt = nowIso();
+            const nextTaskStatus = executionResult.status === 'completed'
+                ? 'completed'
+                : executionResult.status === 'failed'
+                    ? 'failed'
+                    : 'blocked';
+            const resultStatus = executionResult.status === 'completed' ? 'accepted' : 'rejected';
+            input.onProgress?.({
+                runId,
+                taskId: task.id,
+                domainName,
+                agentLabel,
+                phase: executionResult.status,
+                detail: executionResult.model ? `modelo ${executionResult.model}` : null,
+                progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
+            });
+            await writeTaskTransition(task.id, nextTaskStatus, {
+                resultSummary: summary,
+                finishedAt: completedAt,
+            });
+            await createOrchestrationTaskResult({
+                runId,
+                taskId: task.id,
+                agentId: selectedAgentId,
+                resultType: 'domain-execution',
+                status: resultStatus,
+                summary,
+                content: executionResult.output ?? summary,
+                metadataJson: JSON.stringify({
+                    ...executionResult.metadata,
+                    domainName: domain?.domainName ?? null,
+                    status: executionResult.status,
+                    capabilities,
+                    memberCount: members.length,
+                }),
+            });
+            if (task.teamDomainId) {
+                await upsertOrchestrationDomainReport({
+                    runId,
+                    teamDomainId: task.teamDomainId,
+                    localOrchestratorAgentId,
+                    status: executionResult.status === 'completed' ? 'accepted' : 'needs_revision',
+                    summary,
+                    blockers: executionResult.blockers.length > 0
+                        ? executionResult.blockers.join('\n')
+                        : null,
+                    output: executionResult.output ?? summary,
+                    metricsJson: JSON.stringify({
+                        completedTasks: executionResult.status === 'completed' ? 1 : 0,
+                        blockedTasks: executionResult.status === 'blocked' ? 1 : 0,
+                        failedTasks: executionResult.status === 'failed' ? 1 : 0,
+                        memberCount: members.length,
+                        capabilityCount: capabilities.length,
+                        provider: executionResult.provider,
+                        profileId: executionResult.profileId,
+                        model: executionResult.model,
+                    }),
+                    submittedAt: completedAt,
+                });
+            }
+            await this.appendMessage(runId, executionResult.messageType, buildExecutionMessage(executionResult, summary), task.id, localOrchestratorAgentId ?? selectedAgentId, initial.run.globalOrchestratorAgentId);
+            reports.push({
+                taskId: task.id,
+                domainName: domain?.domainName ?? null,
+                assignedAgentId: selectedAgentId,
+                localOrchestratorAgentId,
+                leadAgentId,
+                memberAgentIds: members.map(member => member.agentId),
+                status: executionResult.status,
+                summary,
+                blockers: executionResult.blockers,
+                completedAt,
+            });
+            processedReadyTasks += 1;
+        }
+        input.onProgress?.({
+            runId,
+            phase: 'consolidating',
+            detail: 'consolidando reporte global',
+            progressPercent: 100,
+        });
+        const consolidatedReport = await this.consolidateRunReport(runId);
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        return {
+            ...refreshed,
+            operation: 'execute-ready',
+            changed: reports.length > 0,
+            reports,
+            consolidatedReport,
+        };
+    }
+    async consolidateRunReport(runId) {
+        const state = await loadRunState(requireText(runId, 'runId'));
+        if (!state) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        const reports = [];
+        for (const task of state.tasks.filter(task => task.resultSummary)) {
+            const { domain, members } = await loadTaskDomainContext(task);
+            reports.push({
+                taskId: task.id,
+                domainName: domain?.domainName ?? null,
+                assignedAgentId: task.assignedAgentId,
+                localOrchestratorAgentId: domain?.localOrchestratorAgentId ?? null,
+                leadAgentId: domain?.leadAgentId ?? null,
+                memberAgentIds: members.map(member => member.agentId),
+                status: task.status === 'completed'
+                    ? 'completed'
+                    : task.status === 'failed'
+                        ? 'failed'
+                        : task.status === 'blocked'
+                            ? 'blocked'
+                            : 'skipped',
+                summary: task.resultSummary ?? '',
+                blockers: task.status === 'blocked' ? [task.resultSummary ?? 'Tarea bloqueada.'] : [],
+                completedAt: task.finishedAt ?? nowIso(),
+            });
+        }
+        const report = summarizeRun(state.run, state.tasks, reports);
+        const finishedAt = report.status === 'completed' ||
+            report.status === 'failed' ||
+            report.status === 'cancelled'
+            ? report.generatedAt
+            : null;
+        await withOrchestrationTransaction(async (db) => {
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
+         WHERE id = ?`).run(report.status, finishedAt, runId);
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, state.run.globalOrchestratorAgentId, 'global.consolidated-report', report.summary, report.generatedAt);
+        });
+        await upsertOrchestrationRunReport({
+            runId,
+            status: report.status === 'completed'
+                ? 'accepted'
+                : report.status === 'failed'
+                    ? 'needs_revision'
+                    : 'submitted',
+            summary: report.summary,
+            output: JSON.stringify({
+                completedTasks: report.completedTasks,
+                failedTasks: report.failedTasks,
+                blockedTasks: report.blockedTasks,
+                openTasks: report.openTasks,
+                domainReports: report.domainReports,
+            }),
+            risks: report.failedTasks > 0 || report.blockedTasks > 0
+                ? 'Hay tareas fallidas o bloqueadas que requieren revision antes de cerrar la corrida.'
+                : null,
+            nextSteps: report.openTasks > 0
+                ? 'Ejecutar /run resume <run-id> para continuar las tareas abiertas.'
+                : null,
+            metricsJson: JSON.stringify({
+                completedTasks: report.completedTasks,
+                failedTasks: report.failedTasks,
+                blockedTasks: report.blockedTasks,
+                openTasks: report.openTasks,
+            }),
+            submittedAt: report.generatedAt,
+        });
+        return report;
+    }
+    async appendMessage(runId, messageType, content, taskId, fromAgentId, toAgentId) {
+        const db = await getOrchestrationDatabase();
+        const id = randomUUID();
+        const createdAt = nowIso();
+        db.prepare(`INSERT INTO orchestration_messages (
+        id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, requireText(runId, 'runId'), toNullableText(taskId), toNullableText(fromAgentId), toNullableText(toAgentId), requireText(messageType, 'messageType'), requireText(content, 'content'), createdAt);
+        const row = db
+            .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+         FROM orchestration_messages
+         WHERE id = ?`)
+            .get(id);
+        const created = rowToMessage(row);
+        if (!created) {
+            throw new Error('Failed to create orchestration message.');
+        }
+        return created;
+    }
+    async blockRunTasks(runId, reason) {
+        const current = await loadRunState(runId);
+        if (!current) {
+            throw new Error(`Orchestration run not found: ${runId}`);
+        }
+        await withOrchestrationTransaction(async (db) => {
+            const finishedAt = nowIso();
+            await updateTasksByRun(runId, task => task.status === 'completed'
+                ? null
+                : {
+                    status: 'blocked',
+                    finished_at: finishedAt,
+                    result_summary: task.resultSummary ?? null,
+                });
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.block', nowMessage('cancel', reason), nowIso());
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
+         WHERE id = ?`).run('cancelled', finishedAt, runId);
+        });
+        const refreshed = await loadRunState(runId);
+        if (!refreshed) {
+            throw new Error(`Failed to reload orchestration run: ${runId}`);
+        }
+        return {
+            ...refreshed,
+            operation: 'cancel',
+            changed: true,
+        };
+    }
+}
+export function createOrchestrationExecutionRuntime() {
+    return new OrchestrationExecutionRuntime();
+}
+export async function startOrchestrationRun(input) {
+    const created = await createOrchestrationRun({
+        teamId: input.teamId,
+        goal: input.goal,
+        globalOrchestratorAgentId: input.globalOrchestratorAgentId,
+        status: 'planned',
+    });
+    return createOrchestrationExecutionRuntime().startRun({
+        runId: created.id,
+        promotePendingTasks: true,
+        executeReadyTasks: false,
+        note: 'Inicio solicitado desde /run start.',
+    });
+}
+export async function startExistingOrchestrationRun(runId) {
+    return createOrchestrationExecutionRuntime().startRun({
+        runId,
+        promotePendingTasks: true,
+        note: 'Inicio solicitado desde /run start.',
+    });
+}
+export async function resumeOrchestrationRun(runId, options) {
+    return createOrchestrationExecutionRuntime().resumeRun({
+        runId,
+        reactivateBlockedTasks: true,
+        note: 'Reanudacion solicitada desde /run resume.',
+        onProgress: options?.onProgress,
+    });
+}
+export async function getOrchestrationRunState(runId) {
+    return createOrchestrationExecutionRuntime().getState(runId);
+}
+export async function executeReadyOrchestrationDomainTasks(input) {
+    return createOrchestrationExecutionRuntime().executeReadyDomainTasks(input);
+}
+export async function consolidateOrchestrationRunReport(runId) {
+    return createOrchestrationExecutionRuntime().consolidateRunReport(runId);
+}
+export async function cancelOrchestrationRun(runId) {
+    return createOrchestrationExecutionRuntime().cancelRun({
+        runId,
+        blockOpenTasks: true,
+        reason: 'Cancelacion solicitada desde /run cancel.',
+    });
+}
+export async function listOrchestrationRunTasks(runId) {
+    return listOrchestrationTasks(runId);
+}
+export async function listOrchestrationRunMessages(runId) {
+    return listOrchestrationMessages(runId);
+}