@iaforged/context-code 1.1.7 → 1.1.9

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

@@ -1,628 +1,13 @@
-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';
-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 };
+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." });
 }
-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'].includes(message.messageType))
-        .slice(-6);
-    if (reportMessages.length > 0) {
-        lines.push('', 'Reportes:');
-        for (const message of reportMessages) {
-            const head = message.content.split('\n').slice(0, 4).join('\n');
-            lines.push(`- [${message.messageType}] ${head}`);
-        }
-    }
-    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, }) {
-    const [phase, setPhase] = React.useState('review');
-    const [progress, setProgress] = React.useState(null);
-    const [domainStates, setDomainStates] = React.useState(() => buildInitialDomainExecutionView(plan));
-    const [error, setError] = 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,
-                            progressPercent: event.progressPercent,
-                        };
-                        setProgress(nextProgress);
-                        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);
-                setPhase('done');
-                onDone(report);
-            }
-            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, onDone]);
-    useInput((_input, key) => {
-        if (phase !== 'review')
-            return;
-        if (key.return) {
-            setDomainStates(buildInitialDomainExecutionView(plan));
-            setProgress(null);
-            setError(null);
-            setPhase('executing');
-        }
-        else if (key.escape) {
-            onDone(buildPlanOnlyMessage(plan));
-        }
-    }, { isActive: phase === 'review' });
-    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, children: "Equipos y agentes" }), domainStates.map(domain => (_jsxs(Text, { color: statusColor(domain.status), children: [domain.domainName.padEnd(10), " | ", formatDomainStatus(domain.status).padEnd(10), " | ", domain.progressPercent.toString().padStart(3), "% | ", domain.agentLabel, " | ", domain.detail] }, domain.domainName)))] }), _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] }));
-    }
-    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 });
-};

package/dist/src/commands/tasks/index.js

@@ -2,7 +2,7 @@ const tasks = {
     type: 'local-jsx',
     name: 'tasks',
     aliases: ['bashes'],
-    description: 'Listar y gestionar tareas en segundo plano',
+    description: 'Transicion: despriorizado en modo agent-first',
     load: () => import('./tasks.js'),
 };
 export default tasks;

package/dist/src/commands/tasks/tasks.js

@@ -1,5 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { BackgroundTasksDialog } from '../../components/tasks/BackgroundTasksDialog.js';
-export async function call(onDone, context) {
-    return _jsx(BackgroundTasksDialog, { toolUseContext: context, onDone: onDone });
+import { Text } from '../../ink.js';
+export async function call(onDone, _context) {
+    onDone([
+        '/tasks ya no es el flujo principal en modo agent-first.',
+        'Para trabajar, crea/ajusta agentes con /agent y pide el objetivo directamente.',
+        'El hilo principal se encarga de la delegacion.',
+    ].join('\n'));
+    return _jsx(Text, { dimColor: true, children: "/tasks despriorizado en agent-first." });
 }

package/dist/src/commands/team/index.js

@@ -2,8 +2,8 @@ export default {
     aliases: ['teams'],
     type: 'local-jsx',
     name: 'team',
-    description: 'Gestiona equipos de swarm y sus perfiles de provider/agente',
-    argumentHint: '[list|create <name>|show <name>|orchestrator|equipo <team> <equipo> <provider>/<agent>|add-member <team> <equipo> <provider>/<agent> [duty]]',
+    description: 'Transicion: usa /agent para configurar roles y delegacion',
+    argumentHint: '[migrado a /agent]',
     isEnabled: () => true,
     load: () => import('./team.js'),
 };