@iaforged/context-code 1.2.9 → 1.2.10

package/dist/src/commands/orchestrate/orchestrate.js

@@ -1,13 +1,709 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Text } from '../../ink.js';
-export async function call(onDone, _context) {
-    onDone([
-        '/orchestrate esta en transicion a modo agent-first.',
-        'Usa /agent para crear roles y luego pide el objetivo directamente en el hilo principal.',
-        'Ejemplos:',
-        '- /agent',
-        '- "crea agentes backend, frontend y qa"',
-        '- "implementa esta funcionalidad y delega en los agentes disponibles"',
-    ].join('\n'));
-    return _jsx(Text, { dimColor: true, children: "/orchestrate migrado a agent-first." });
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { Box, Text, useInput } from '../../ink.js';
+import { createGlobalOrchestratorRuntime, createSquadOrchestratorRuntime, resumeOrchestrationRun, } from '../../services/orchestration/index.js';
+import { createOrchestrationMessage, createOrchestrationRun, createOrchestrationTask, getOrchestrationRunById, getProviderAgentById, getProviderWorkspaceById, getTeamByName, listOrchestrationMessages, listOrchestrationTasks, listTeamDomainMembers, listTeamDomains, } from '../../utils/orchestration/store/index.js';
+import { activityManager } from '../../utils/activityManager.js';
+import { manuallyExtractSessionMemory } from '../../services/sessionMemory/sessionMemory.js';
+import { createUserMessage, createAssistantMessage } from '../../utils/messages.js';
+function parseArgs(args) {
+    const trimmed = args.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const [teamName, ...rest] = trimmed.split(/\s+/);
+    const objective = rest.join(' ').trim();
+    if (!teamName || !objective) {
+        return null;
+    }
+    return { teamName, objective };
 }
+function roleFromDuty(duty) {
+    const normalized = duty?.trim().toLowerCase();
+    switch (normalized) {
+        case 'planner':
+        case 'plan':
+        case 'planning':
+            return 'planner';
+        case 'validator':
+        case 'reviewer':
+        case 'review':
+        case 'qa':
+            return 'validator';
+        case 'researcher':
+        case 'research':
+        case 'investigator':
+            return 'researcher';
+        case 'observer':
+        case 'watcher':
+            return 'observer';
+        default:
+            return 'executor';
+    }
+}
+function buildAgentLabel(provider, name) {
+    return `${provider}/${name}`;
+}
+function appendUniqueMember(members, candidate) {
+    if (members.some(member => member.id === candidate.id)) {
+        return;
+    }
+    members.push(candidate);
+}
+async function buildDomainContexts(teamId) {
+    const domains = await listTeamDomains(teamId);
+    const contexts = [];
+    for (const domain of domains) {
+        const warnings = [];
+        const members = [];
+        const workspace = domain.workspaceId
+            ? await getProviderWorkspaceById(domain.workspaceId)
+            : null;
+        const workspaceLabel = workspace
+            ? `${workspace.displayName} (${workspace.provider})`
+            : 'sin workspace';
+        const workspaceEnabled = workspace?.isEnabled ?? false;
+        if (!workspace) {
+            warnings.push('No tiene workspace asignado.');
+        }
+        else if (!workspace.isEnabled) {
+            warnings.push(`El workspace ${workspace.displayName} esta deshabilitado.`);
+        }
+        const localOrchestrator = domain.localOrchestratorAgentId
+            ? await getProviderAgentById(domain.localOrchestratorAgentId)
+            : null;
+        if (domain.localOrchestratorAgentId && !localOrchestrator) {
+            warnings.push('El orquestador local configurado ya no existe.');
+        }
+        const leadAgent = domain.leadAgentId
+            ? await getProviderAgentById(domain.leadAgentId)
+            : null;
+        if (domain.leadAgentId && !leadAgent) {
+            warnings.push('El lead agent configurado ya no existe.');
+        }
+        if (localOrchestrator) {
+            const orchestratorWorkspace = await getProviderWorkspaceById(localOrchestrator.workspaceId);
+            appendUniqueMember(members, {
+                id: localOrchestrator.id,
+                name: buildAgentLabel(orchestratorWorkspace?.provider ?? 'unknown', localOrchestrator.name),
+                role: 'planner',
+                providerHint: orchestratorWorkspace?.provider,
+                enabled: localOrchestrator.isEnabled,
+            });
+            if (!localOrchestrator.isEnabled) {
+                warnings.push(`El orquestador local ${localOrchestrator.name} esta deshabilitado.`);
+            }
+        }
+        if (leadAgent) {
+            const leadWorkspace = await getProviderWorkspaceById(leadAgent.workspaceId);
+            appendUniqueMember(members, {
+                id: leadAgent.id,
+                name: buildAgentLabel(leadWorkspace?.provider ?? 'unknown', leadAgent.name),
+                role: leadAgent.isOrchestrator ? 'planner' : 'executor',
+                providerHint: leadWorkspace?.provider,
+                enabled: leadAgent.isEnabled,
+            });
+            if (!leadAgent.isEnabled) {
+                warnings.push(`El lead agent ${leadAgent.name} esta deshabilitado.`);
+            }
+        }
+        const domainMembers = await listTeamDomainMembers(domain.id);
+        for (const member of domainMembers) {
+            const agent = await getProviderAgentById(member.agentId);
+            if (!agent) {
+                warnings.push(`Un miembro del equipo ya no existe: ${member.agentId}`);
+                continue;
+            }
+            const memberWorkspace = await getProviderWorkspaceById(agent.workspaceId);
+            appendUniqueMember(members, {
+                id: agent.id,
+                name: buildAgentLabel(memberWorkspace?.provider ?? 'unknown', agent.name),
+                role: roleFromDuty(member.duty),
+                providerHint: memberWorkspace?.provider,
+                enabled: agent.isEnabled,
+            });
+            if (!agent.isEnabled) {
+                warnings.push(`El miembro ${agent.name} esta deshabilitado.`);
+            }
+        }
+        const assignedAgent = localOrchestrator ?? leadAgent ?? null;
+        if (!assignedAgent) {
+            warnings.push('No hay agente asignable para este equipo.');
+        }
+        const assignedWorkspace = assignedAgent
+            ? await getProviderWorkspaceById(assignedAgent.workspaceId)
+            : null;
+        const localOrchestratorWorkspace = localOrchestrator
+            ? await getProviderWorkspaceById(localOrchestrator.workspaceId)
+            : null;
+        const leadAgentWorkspace = leadAgent
+            ? await getProviderWorkspaceById(leadAgent.workspaceId)
+            : null;
+        contexts.push({
+            domainId: domain.id,
+            domainName: domain.domainName,
+            selectionMode: domain.selectionMode,
+            required: domain.required,
+            workspaceLabel,
+            workspaceEnabled,
+            localOrchestratorId: localOrchestrator?.id ?? null,
+            localOrchestratorLabel: localOrchestrator && localOrchestratorWorkspace
+                ? buildAgentLabel(localOrchestratorWorkspace.provider, localOrchestrator.name)
+                : localOrchestrator?.name ?? null,
+            leadAgentId: leadAgent?.id ?? null,
+            leadAgentLabel: leadAgent && leadAgentWorkspace
+                ? buildAgentLabel(leadAgentWorkspace.provider, leadAgent.name)
+                : leadAgent?.name ?? null,
+            assignedAgentId: assignedAgent?.id ?? null,
+            assignedAgentLabel: assignedAgent && assignedWorkspace
+                ? buildAgentLabel(assignedWorkspace.provider, assignedAgent.name)
+                : assignedAgent?.name ?? null,
+            members,
+            validationWarnings: warnings,
+        });
+    }
+    return contexts;
+}
+function buildGlobalSummary(goal, planSummary, contexts) {
+    const lines = [
+        `Objetivo: ${goal}`,
+        `Resumen global: ${planSummary}`,
+        `Equipos detectados: ${contexts.length}`,
+        '',
+        'Equipos planificados:',
+    ];
+    for (const context of contexts) {
+        lines.push(`- ${context.domainName} -> workspace=${context.workspaceLabel} | assigned=${context.assignedAgentLabel ?? 'sin asignar'} | members=${context.members.length} | mode=${context.selectionMode}`);
+    }
+    return lines.join('\n');
+}
+function buildDomainInstructions(teamName, objective, context, squadPlanSummary) {
+    const lines = [
+        `Team: ${teamName}`,
+        `Equipo: ${context.domainName}`,
+        `Objetivo global: ${objective}`,
+        `Workspace: ${context.workspaceLabel}`,
+        `Modo de seleccion: ${context.selectionMode}`,
+        `Resumen del squad: ${squadPlanSummary}`,
+        '',
+        'Miembros del escuadron:',
+    ];
+    if (context.members.length === 0) {
+        lines.push('- sin miembros');
+        lines.push('');
+        lines.push('Autonomia del escuadron:');
+        lines.push(`- El orquestador/lead del equipo ${context.domainName} debe asumir roles internos temporales segun la funcion principal del equipo.`);
+        lines.push('- Debe explicar que roles asumio, que hizo cada rol y que falta para completar el equipo.');
+    }
+    else {
+        for (const member of context.members) {
+            lines.push(`- ${member.name} [${member.role}]${member.enabled ? '' : ' (disabled)'}`);
+        }
+    }
+    if (context.validationWarnings.length > 0) {
+        lines.push('');
+        lines.push('Advertencias:');
+        for (const warning of context.validationWarnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    lines.push('');
+    lines.push('Fase 2 temprana: esta tarea representa la delegacion inicial persistida en SQLite; la ejecucion distribuida real llegara en una fase posterior.');
+    return lines.join('\n');
+}
+function formatIssues(prefix, issues) {
+    if (issues.length === 0) {
+        return [];
+    }
+    return issues.map(issue => `- ${prefix}: ${issue.severity} -> ${issue.message}`);
+}
+function buildConfigurationChecklist(teamName, contexts) {
+    const lines = [];
+    for (const context of contexts) {
+        if (!context.workspaceEnabled) {
+            lines.push(`- ${context.domainName}: habilita el workspace/proveedor antes de ejecutar.`);
+        }
+        if (!context.localOrchestratorId) {
+            lines.push(`- ${context.domainName}: falta orquestador local. Usa /team equipo ${teamName} ${context.domainName} <provider>/<agent>`);
+        }
+        if (!context.leadAgentId) {
+            lines.push(`- ${context.domainName}: falta lead. Usa /team equipo ${teamName} ${context.domainName} <provider>/<agent>`);
+        }
+        if (context.members.length === 0 && context.assignedAgentId) {
+            lines.push(`- ${context.domainName}: modo autonomo. ${context.assignedAgentLabel ?? 'el orquestador local'} asignara roles internos; miembros extra son opcionales.`);
+        }
+    }
+    return lines;
+}
+async function planRun(args) {
+    const parsed = parseArgs(args);
+    if (!parsed) {
+        return { error: 'Uso: /orchestrate <team> <objetivo>' };
+    }
+    const team = await getTeamByName(parsed.teamName);
+    if (!team) {
+        return { error: `No existe el team ${parsed.teamName}.` };
+    }
+    if (!team.isEnabled) {
+        return { error: `El team ${team.name} esta deshabilitado.` };
+    }
+    if (!team.globalOrchestratorAgentId) {
+        return {
+            error: `El team ${team.name} no tiene orquestador global. Usa /team orchestrator primero.`,
+        };
+    }
+    const globalAgent = await getProviderAgentById(team.globalOrchestratorAgentId);
+    if (!globalAgent) {
+        return { error: `El orquestador global configurado ya no existe para ${team.name}.` };
+    }
+    const globalWorkspace = await getProviderWorkspaceById(globalAgent.workspaceId);
+    const globalLabel = globalWorkspace
+        ? `${globalWorkspace.provider}/${globalAgent.name}`
+        : globalAgent.name;
+    const domains = await listTeamDomains(team.id);
+    if (domains.length === 0) {
+        return {
+            error: `El team ${team.name} no tiene equipos configurados. Usa /team equipo primero.`,
+        };
+    }
+    const globalRuntime = createGlobalOrchestratorRuntime('phase-2-early');
+    const globalValidation = await globalRuntime.validate({
+        objective: parsed.objective,
+        scope: 'global',
+        context: `team:${team.name}`,
+        notes: `domains:${domains.length}`,
+    });
+    if (!globalValidation.valid) {
+        return {
+            error: [
+                `La orquestacion fue rechazada para ${team.name}.`,
+                ...formatIssues('global', globalValidation.issues),
+            ].join('\n'),
+        };
+    }
+    const domainContexts = await buildDomainContexts(team.id);
+    const configurationChecklist = buildConfigurationChecklist(team.name, domainContexts);
+    const globalPlan = await globalRuntime.plan({
+        objective: parsed.objective,
+        scope: 'global',
+        context: `team:${team.name}`,
+        notes: `domains:${domainContexts.length}`,
+        allowExecution: false,
+    });
+    const run = await createOrchestrationRun({
+        teamId: team.id,
+        goal: parsed.objective,
+        globalOrchestratorAgentId: globalAgent.id,
+        status: 'planned',
+    });
+    await createOrchestrationMessage({
+        runId: run.id,
+        fromAgentId: globalAgent.id,
+        messageType: 'global-plan',
+        content: buildGlobalSummary(parsed.objective, globalPlan.summary, domainContexts),
+    });
+    const taskSummaries = [];
+    let readyCount = 0;
+    let blockedCount = 0;
+    const validationWarnings = [...formatIssues('global', globalValidation.issues)];
+    for (const context of domainContexts) {
+        const squadRuntime = createSquadOrchestratorRuntime(context.members);
+        const squadValidation = await squadRuntime.validate({
+            objective: parsed.objective,
+            squadName: context.domainName,
+            members: context.members,
+            scope: 'squad',
+            context: `team:${team.name};domain:${context.domainName}`,
+        });
+        const squadPlan = await squadRuntime.plan({
+            objective: parsed.objective,
+            squadName: context.domainName,
+            members: context.members,
+            scope: 'squad',
+            context: `team:${team.name};domain:${context.domainName}`,
+            allowExecution: false,
+        });
+        const taskStatus = context.assignedAgentId && context.workspaceEnabled && squadValidation.valid
+            ? 'ready'
+            : 'blocked';
+        if (taskStatus === 'ready') {
+            readyCount += 1;
+        }
+        else {
+            blockedCount += 1;
+        }
+        const task = await createOrchestrationTask({
+            runId: run.id,
+            scopeType: 'domain',
+            teamDomainId: context.domainId,
+            assignedAgentId: context.assignedAgentId,
+            title: `Equipo ${context.domainName}`,
+            instructions: buildDomainInstructions(team.name, parsed.objective, context, squadPlan.summary),
+            status: taskStatus,
+            resultSummary: taskStatus === 'blocked'
+                ? 'Pendiente por validacion/configuracion del equipo.'
+                : 'Delegacion inicial preparada.',
+        });
+        await createOrchestrationMessage({
+            runId: run.id,
+            taskId: task.id,
+            fromAgentId: globalAgent.id,
+            toAgentId: context.assignedAgentId,
+            messageType: 'squad-plan',
+            content: [
+                `Equipo: ${context.domainName}`,
+                `Asignado: ${context.assignedAgentLabel ?? 'sin asignar'}`,
+                `Resumen: ${squadPlan.summary}`,
+                '',
+                ...context.validationWarnings.map(warning => `- ${warning}`),
+                ...formatIssues('squad', squadValidation.issues),
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        });
+        validationWarnings.push(...context.validationWarnings.map(warning => `- ${context.domainName}: warning -> ${warning}`), ...formatIssues(context.domainName, squadValidation.issues));
+        taskSummaries.push(`- ${context.domainName} -> ${task.status} | assigned=${context.assignedAgentLabel ?? 'sin asignar'} | task=${task.id}`);
+    }
+    return {
+        ok: {
+            run,
+            team,
+            globalLabel,
+            taskSummaries,
+            validationWarnings,
+            configurationChecklist,
+            hasReadyTasks: readyCount > 0,
+            hasBlockedTasks: blockedCount > 0,
+            readyCount,
+            blockedCount,
+            domainContexts,
+        },
+    };
+}
+function buildPlanOnlyMessage(plan) {
+    const lines = [
+        `Ejecucion creada: ${plan.run.id}`,
+        `Team: ${plan.team.name}`,
+        `Objetivo: ${plan.run.goal}`,
+        `Orquestador global: ${plan.globalLabel}`,
+        `Estado inicial: ${plan.run.status}`,
+        '',
+        'Tareas por equipo:',
+        ...plan.taskSummaries,
+    ];
+    if (plan.validationWarnings.length > 0) {
+        lines.push('', 'Advertencias y validaciones:');
+        lines.push(...plan.validationWarnings);
+    }
+    if (plan.configurationChecklist.length > 0) {
+        lines.push('', 'Estado de configuracion del equipo:');
+        lines.push(...plan.configurationChecklist);
+    }
+    lines.push('', 'Siguientes pasos:');
+    lines.push(`- Revisar plan: /run show ${plan.run.id}`);
+    if (plan.hasReadyTasks) {
+        lines.push(`- Ejecutar tareas listas: /run resume ${plan.run.id}`);
+    }
+    if (plan.hasBlockedTasks) {
+        lines.push(`- Si hay equipos blocked, asigna un agente con /team equipo <team> <equipo> <provider>/<agent> y luego usa /run retry ${plan.run.id}`);
+    }
+    return lines.join('\n');
+}
+function buildExecutionReport(plan, finalRun, finalTasks, finalMessages, errorMessage) {
+    const counts = {};
+    for (const task of finalTasks) {
+        counts[task.status] = (counts[task.status] ?? 0) + 1;
+    }
+    const countsLine = Object.entries(counts)
+        .map(([status, n]) => `${status}=${n}`)
+        .sort()
+        .join(' | ');
+    const lines = [
+        `Ejecucion finalizada: ${finalRun.id}`,
+        `Team: ${plan.team.name}`,
+        `Objetivo: ${finalRun.goal}`,
+        `Estado final: ${finalRun.status}`,
+        `Resumen tareas: ${countsLine || 'sin tareas'}`,
+    ];
+    const reportMessages = finalMessages
+        .filter(message => ['run-report', 'task.completed', 'domain-report', 'global.consolidated-report'].includes(message.messageType))
+        .slice(-10);
+    if (reportMessages.length > 0) {
+        lines.push('', 'Reportes y Resultados:');
+        for (const message of reportMessages) {
+            if (message.messageType === 'global.consolidated-report') {
+                lines.push(`\n[REPORTE EJECUTIVO]`);
+                lines.push(message.content);
+            }
+            else {
+                const head = message.content.split('\n').slice(0, 4).join('\n');
+                lines.push(`- [${message.messageType}] ${head}${message.content.split('\n').length > 4 ? '...' : ''}`);
+            }
+        }
+    }
+    if (errorMessage) {
+        lines.push('', `❌ Error durante la ejecucion: ${errorMessage}`);
+    }
+    lines.push('', `Siguientes pasos: /run show ${finalRun.id} | /run messages ${finalRun.id} | /run task <task-id>`);
+    return lines.join('\n');
+}
+function buildInitialDomainExecutionView(plan) {
+    return plan.domainContexts.map(context => {
+        const isReady = Boolean(context.assignedAgentId && context.workspaceEnabled);
+        return {
+            domainName: context.domainName,
+            agentLabel: context.assignedAgentLabel ?? 'sin asignar',
+            status: isReady ? 'waiting' : 'blocked',
+            detail: isReady
+                ? 'en espera de ejecucion'
+                : context.validationWarnings[0] ?? 'requiere configuracion',
+            progressPercent: 0,
+        };
+    });
+}
+function toDomainStatus(phase) {
+    switch (phase) {
+        case 'dispatching':
+            return 'dispatching';
+        case 'executing':
+            return 'executing';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+            return 'failed';
+        case 'blocked':
+            return 'blocked';
+        default:
+            return 'waiting';
+    }
+}
+function formatDomainStatus(status) {
+    switch (status) {
+        case 'waiting':
+            return 'en cola';
+        case 'dispatching':
+            return 'asignando';
+        case 'executing':
+            return 'trabajando';
+        case 'completed':
+            return 'terminado';
+        case 'failed':
+            return 'fallo';
+        case 'blocked':
+            return 'bloqueado';
+        case 'skipped':
+            return 'omitido';
+    }
+}
+function statusColor(status) {
+    switch (status) {
+        case 'completed':
+            return 'green';
+        case 'dispatching':
+        case 'executing':
+            return 'cyan';
+        case 'blocked':
+        case 'skipped':
+            return 'yellow';
+        case 'failed':
+            return 'red';
+        default:
+            return undefined;
+    }
+}
+function PlanReview({ plan, onDone, context, }) {
+    const [phase, setPhase] = React.useState('review');
+    const [progress, setProgress] = React.useState(null);
+    const [domainStates, setDomainStates] = React.useState(() => buildInitialDomainExecutionView(plan));
+    const [messages, setMessages] = React.useState([]);
+    const [error, setError] = React.useState(null);
+    const [finalReport, setFinalReport] = React.useState(null);
+    React.useEffect(() => {
+        if (phase !== 'executing')
+            return;
+        let cancelled = false;
+        void (async () => {
+            let errorMessage = null;
+            try {
+                await resumeOrchestrationRun(plan.run.id, {
+                    onProgress: event => {
+                        if (cancelled)
+                            return;
+                        const nextProgress = {
+                            taskId: event.taskId,
+                            phase: event.phase,
+                            domainName: event.domainName,
+                            agentLabel: event.agentLabel,
+                            detail: event.detail,
+                            output: event.output,
+                            progressPercent: event.progressPercent,
+                        };
+                        setProgress(nextProgress);
+                        context.setAppState(prev => ({
+                            ...prev,
+                            orchestrationActivity: {
+                                runId: plan.run.id,
+                                teamName: plan.team.name,
+                                domainName: event.domainName ?? undefined,
+                                agentLabel: event.agentLabel ?? undefined,
+                                phase: event.phase,
+                                detail: event.detail ?? undefined,
+                                progressPercent: event.progressPercent ?? undefined,
+                                updatedAt: Date.now(),
+                            }
+                        }));
+                        if (event.output) {
+                            setMessages(prev => [
+                                ...prev,
+                                {
+                                    agent: event.agentLabel || event.domainName || 'Sistema',
+                                    content: event.output,
+                                },
+                            ]);
+                        }
+                        if (event.domainName) {
+                            setDomainStates(prev => prev.map(domain => {
+                                if (domain.domainName !== event.domainName) {
+                                    return domain;
+                                }
+                                return {
+                                    ...domain,
+                                    agentLabel: event.agentLabel ?? domain.agentLabel,
+                                    status: toDomainStatus(event.phase),
+                                    detail: event.detail ?? domain.detail,
+                                    progressPercent: event.progressPercent == null
+                                        ? domain.progressPercent
+                                        : Math.round(event.progressPercent),
+                                };
+                            }));
+                        }
+                    },
+                });
+            }
+            catch (e) {
+                errorMessage = e instanceof Error ? e.message : String(e);
+                if (!cancelled) {
+                    setError(errorMessage);
+                }
+            }
+            if (cancelled)
+                return;
+            try {
+                const [finalTasks, finalMessages, finalRun] = await Promise.all([
+                    listOrchestrationTasks(plan.run.id),
+                    listOrchestrationMessages(plan.run.id),
+                    getOrchestrationRunById(plan.run.id),
+                ]);
+                const report = buildExecutionReport(plan, finalRun ?? plan.run, finalTasks, finalMessages, errorMessage);
+                setFinalReport(report);
+                context.setAppState(prev => ({
+                    ...prev,
+                    orchestrationActivity: {
+                        runId: plan.run.id,
+                        teamName: plan.team.name,
+                        phase: 'finished',
+                        detail: 'ejecucion finalizada',
+                        progressPercent: 100,
+                        updatedAt: Date.now(),
+                    }
+                }));
+                // Indexar en SessionMemory para persistencia histórica
+                if (context.messages && context.toolUseContext) {
+                    const runMsg = `Ejecución de orquestación finalizada: ${plan.run.id}. Objetivo: ${plan.run.goal}. Resultado: ${finalRun?.status ?? 'desconocido'}.`;
+                    const reportMsg = `Reporte consolidado:\n${report}`;
+                    const virtualMessages = [
+                        ...context.messages,
+                        createUserMessage({ content: `/orchestrate ${plan.team.name} ${plan.run.goal}` }),
+                        createAssistantMessage({ content: runMsg }),
+                        createAssistantMessage({ content: reportMsg })
+                    ];
+                    void manuallyExtractSessionMemory(virtualMessages, context.toolUseContext).catch(err => {
+                        console.error('Error al indexar reporte en SessionMemory:', err);
+                    });
+                }
+                setPhase('finished');
+            }
+            catch (e) {
+                setPhase('done');
+                const fallbackErr = e instanceof Error ? e.message : String(e);
+                onDone([
+                    buildPlanOnlyMessage(plan),
+                    '',
+                    `No se pudo recolectar el reporte final: ${fallbackErr}`,
+                    errorMessage ? `Error de ejecucion previo: ${errorMessage}` : null,
+                ]
+                    .filter(Boolean)
+                    .join('\n'));
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [phase, plan, context]);
+    // Lifecycle management for global activity state (signals and global AppState)
+    React.useEffect(() => {
+        activityManager.startCLIActivity('orchestration_execution');
+        return () => {
+            logForDebugging('PlanReview lifecycle effect cleanup: ending CLI activity and clearing orchestrationActivity');
+            activityManager.endCLIActivity('orchestration_execution');
+            context.setAppState(prev => ({
+                ...prev,
+                orchestrationActivity: undefined
+            }));
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [context.setAppState]);
+    useInput((_input, key) => {
+        if (phase === 'review') {
+            if (key.return) {
+                setDomainStates(buildInitialDomainExecutionView(plan));
+                setProgress(null);
+                setError(null);
+                setPhase('executing');
+            }
+            else if (key.escape) {
+                onDone(buildPlanOnlyMessage(plan));
+            }
+        }
+        else if (phase === 'finished') {
+            if (key.return || key.escape) {
+                setPhase('done');
+                onDone(finalReport || 'Ejecucion completada.');
+            }
+        }
+    }, { isActive: phase === 'review' || phase === 'finished' });
+    if (phase === 'review') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Plan listo para ", plan.team.name] }), _jsxs(Text, { children: ["Ejecucion: ", plan.run.id] }), _jsxs(Text, { children: ["Objetivo: ", plan.run.goal] }), _jsxs(Text, { children: ["Orquestador global: ", plan.globalLabel] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Tareas por equipo" }), plan.taskSummaries.map((line, i) => (_jsx(Text, { children: line }, i)))] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { children: ["Listas: ", _jsx(Text, { color: "green", children: plan.readyCount }), " | Bloqueadas:", ' ', _jsx(Text, { color: plan.blockedCount > 0 ? 'yellow' : undefined, children: plan.blockedCount })] }) }), plan.validationWarnings.length > 0 ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "yellow", children: "Advertencias" }), plan.validationWarnings.map((line, i) => (_jsx(Text, { color: "yellow", children: line }, i)))] })) : null, plan.configurationChecklist.length > 0 ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Estado de configuracion" }), plan.configurationChecklist.map((line, i) => (_jsx(Text, { children: line }, i)))] })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["[Enter] Ejecutar ahora", plan.hasBlockedTasks ? ' (las bloqueadas se omiten)' : '', "  |  [Esc] Solo planificar"] }) })] }));
+    }
+    if (phase === 'executing') {
+        const progressLine = progress
+            ? [
+                progress.phase,
+                progress.domainName ? `equipo=${progress.domainName}` : null,
+                progress.agentLabel ? `agente=${progress.agentLabel}` : null,
+                progress.detail,
+                progress.progressPercent != null ? `${Math.round(progress.progressPercent)}%` : null,
+            ]
+                .filter(Boolean)
+                .join(' | ')
+            : 'preparando ejecucion...';
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Ejecutando orquestacion ", plan.run.id] }), _jsxs(Text, { children: ["Team: ", plan.team.name] }), _jsx(Text, { children: progressLine }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, underline: true, children: "Equipos y agentes" }), domainStates.map(domain => (_jsxs(Text, { color: statusColor(domain.status), children: [domain.domainName.padEnd(12), " | ", formatDomainStatus(domain.status).padEnd(10), " | ", domain.progressPercent.toString().padStart(3), "% | ", domain.agentLabel] }, domain.domainName)))] }), messages.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, underline: true, children: "Actividad del Swarm (ultimos mensajes)" }), messages.slice(-5).map((msg, i) => (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, marginBottom: 1, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["[", msg.agent, "]"] }), _jsx(Text, { dimColor: true, children: msg.content.length > 200 ? msg.content.substring(0, 200) + '...' : msg.content })] }, i)))] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "La ejecucion avanza por equipos listos; las tareas bloqueadas quedan para corregir y reintentar." }) }), error ? _jsxs(Text, { color: "red", children: ["Error: ", error] }) : null] }));
+    }
+    if (phase === 'finished') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "green", children: "\u00A1Orquestacion Finalizada!" }), _jsxs(Text, { children: ["Team: ", plan.team.name] }), _jsx(Box, { marginTop: 1, padding: 1, borderStyle: "round", borderColor: "green", children: _jsx(Text, { children: finalReport }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[Enter/Esc] Salir y volver al prompt" }) })] }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { children: ["Ejecucion ", plan.run.id, " terminada."] }) }));
+}
+export const call = async (onDone, _context, args) => {
+    const result = await planRun(args ?? '');
+    if ('error' in result) {
+        onDone(result.error);
+        return null;
+    }
+    const plan = result.ok;
+    if (!plan.hasReadyTasks) {
+        onDone(buildPlanOnlyMessage(plan));
+        return null;
+    }
+    return _jsx(PlanReview, { plan: plan, onDone: onDone, context: _context });
+};