agent-mp 0.5.33 → 0.5.35

package/dist/commands/repl.js

@@ -855,6 +855,9 @@ function cmdHelp(fi) {
         { key: '/run rev <id>', value: 'Run only reviewer' },
         { key: '/run explorer [task]', value: 'Run only explorer' },
         { key: '/explorer [task]', value: 'Run explorer (shortcut)' },
+        { key: '/orch <feature-id>', value: 'Lanza SOLO orchestrator — genera plan.json' },
+        { key: '/impl <task-id>', value: 'Lanza SOLO implementor — ejecuta plan existente' },
+        { key: '/rev <task-id>', value: 'Lanza SOLO reviewer — valida implementación' },
         { key: '/model', value: 'Cambiar modelo del coordinador' },
         { key: '/provider', value: 'Cambiar proveedor activo (Gemini / Qwen)' },
         { key: '/login', value: 'Configurar API key (Qwen o Gemini)' },
@@ -1196,6 +1199,59 @@ export async function runRepl(resumeSession) {
                 });
                 break;
             }
+            // Comandos cortos para lanzar roles directamente
+            case 'orch': {
+                // /orch <feature-id> — lanza solo orchestrator sin preguntas
+                const featureId = args.join(' ').trim();
+                if (!featureId) {
+                    fi.println(chalk.red('  Uso: /orch <feature-id>'));
+                    break;
+                }
+                await withEngine(async (engine) => {
+                    const result = await engine.runOrchestrator(`.agent/docs/${featureId}`, undefined, featureId);
+                    fi.println(chalk.green(`  ✓ Task ID: ${result.taskId}`));
+                    fi.println(chalk.green(`  ✓ Plan: .agent/tasks/${result.taskId}/plan.json`));
+                });
+                break;
+            }
+            case 'impl': {
+                // /impl <task-id> — lanza solo implementor con plan existente
+                const taskId = args.join(' ').trim();
+                if (!taskId) {
+                    fi.println(chalk.red('  Uso: /impl <task-id>'));
+                    break;
+                }
+                await withEngine(async (engine) => {
+                    const taskDir = path.join(engine['projectDir'], '.agent', 'tasks', taskId);
+                    if (!await fileExists(taskDir)) {
+                        fi.println(chalk.red(`  ✗ Task "${taskId}" no existe`));
+                        return;
+                    }
+                    const plan = await readJson(path.join(taskDir, 'plan.json'));
+                    await engine.runImplementor(taskId, plan);
+                    fi.println(chalk.green(`  ✓ Implementación completada`));
+                });
+                break;
+            }
+            case 'rev': {
+                // /rev <task-id> — lanza solo reviewer
+                const taskId = args.join(' ').trim();
+                if (!taskId) {
+                    fi.println(chalk.red('  Uso: /rev <task-id>'));
+                    break;
+                }
+                await withEngine(async (engine) => {
+                    const taskDir = path.join(engine['projectDir'], '.agent', 'tasks', taskId);
+                    if (!await fileExists(taskDir)) {
+                        fi.println(chalk.red(`  ✗ Task "${taskId}" no existe`));
+                        return;
+                    }
+                    const plan = await readJson(path.join(taskDir, 'plan.json'));
+                    const progress = await readJson(path.join(taskDir, 'progress.json'));
+                    await engine.runReviewer(taskId, plan, progress);
+                });
+                break;
+            }
             case 'models':
             case 'model':
                 await withRl((rl) => cmdModels(args[0], fi, rl));

package/dist/core/engine.js

@@ -414,19 +414,46 @@ export class AgentEngine {
 MODO SPEC — Feature cargada: "${activeFeatureId}"
 Los archivos raw YA ESTÁN en el CONTEXTO DEL PROYECTO arriba.
 
+TU ÚNICO TRABAJO: Construir colaborativamente un **SPEC.MD FUNCIONAL** con el programador.
+
 REGLAS CRÍTICAS:
-1. ANTES DE ESCRIBIR CUALQUIER COSA: leé completo el CONTEXTO DEL PROYECTO, incluyendo la sección "TAREA EXISTENTE" si está presente.
+1. ANTES DE ESCRIBIR CUALQUIER COSA: leé completo el CONTEXTO DEL PROYECTO, incluyendo "TAREA EXISTENTE" si está presente.
 2. SI EXISTE SPEC.MD en el contexto (bajo "SPEC.MD EXISTENTE"):
    - **NO lo regeneres desde cero** — ese documento es VIVO y lo edita el humano.
-   - Identificá qué secciones ya están completas (Objetivo, Alcance, Criterios, etc.).
+   - Identificá qué secciones ya están completas.
    - Identificá qué información FALTA o está incompleta.
    - Hacé SOLO las preguntas necesarias para completar lo que falta.
-   - Si el spec.md ya está completo, NO hagas preguntas — usá el existente.
-3. SI EXISTE "TAREA EXISTENTE" en el contexto:
-   - Si hay RESULTADO PREVIO: FAIL: informá al usuario qué falló y preguntá si quiere corregir eso específico.
-   - Si ya hay plan.json: la tarea ya está definida — NO generes spec.
-4. NUNCA reemplaces el spec.md existente — si necesitás actualizarlo, solo sugerí los cambios puntuales.
-5. Cuando tengas todo claro (o si ya hay spec), escribí EXACTAMENTE al final: ${READY_SENTINEL}` : `
+   - Si el spec.md ya está completo, NO hagas preguntas — decí "El spec está listo. Usá /orch para lanzar la planificación".
+3. EL SPEC.MD DEBE SER FUNCIONAL — describí QUÉ se va a construir, no CÓMO:
+   
+   **Para endpoints/nuevas features:**
+   - Endpoint: método y ruta (ej: POST /users)
+   - Request: datos de entrada (body, params, query) con tipos y validaciones
+   - Response: datos de salida con estructura y códigos HTTP
+   - Proceso por capas: Controller → Service → Repository (qué pasa en cada una)
+   - Reglas de negocio: validaciones, condiciones, excepciones
+   
+   **Para fixes/correcciones:**
+   - Comportamiento actual: cómo funciona ahora (el problema)
+   - Comportamiento esperado: cómo debe funcionar después
+   - Casos afectados: qué funcionalidades existentes pueden impactarse
+   - Criterios de aceptación: cómo se verifica que está fixeado
+   
+   **Para scripts/utilidades:**
+   - Entrada: qué recibe (parámetros, archivos, input de usuario)
+   - Salida: qué produce (archivo, output en consola, resultado)
+   - Proceso: pasos que ejecuta (sin detalles de implementación)
+   - Manejo de errores: qué pasa si falla
+
+4. NUNCA incluyas en el spec:
+   - Nombres de archivos específicos (eso lo define el orchestrator)
+   - Pasos de implementación (eso lo define el plan.json)
+   - Tecnologías específicas a menos que el programador las mencione
+
+5. Cuando el spec.md esté completo (o si ya existe y está completo):
+   - Confirmá con el programador que está listo
+   - Indicá que puede usar **/orch <feature-id>** para lanzar la planificación
+   - Escribí EXACTAMENTE al final: ${READY_SENTINEL}` : `
 MODO TAREA LIBRE — No se especificó feature todavía.
 ${featureListBlock}
 REGLAS:
@@ -437,7 +464,7 @@ REGLAS:
 - Cuando el objetivo esté claro, escribí EXACTAMENTE al final: ${READY_SENTINEL}
 - NUNCA escribas ${READY_SENTINEL} si solo recibiste un saludo o falta información concreta.`;
             const prompt = `Sos el COORDINADOR de un equipo de desarrollo de software.
-Tu trabajo es entender qué necesita el programador usando la información disponible y haciendo SOLO las preguntas estrictamente necesarias.
+Tu ÚNICO TRABAJO es construir colaborativamente un **SPEC.MD FUNCIONAL** con el programador.
 
 REGLA DE ORO: ANTES de escribir cualquier respuesta, LEÉ COMPLETO el CONTEXTO DEL PROYECTO que está arriba. Toda la información que necesitás para no hacer preguntas obvias está ahí.
 
@@ -451,12 +478,14 @@ INSTRUCCIONES GENERALES:
 - Hablá en forma NATURAL, como un compañero de equipo experimentado.
 - ANTES DE RESPONDER: leé todo el CONTEXTO DEL PROYECTO, incluyendo "TAREA EXISTENTE" si está presente.
 - **SPEC.MD ES DOCUMENTO VIVO**: Si ya existe spec.md, NO lo regeneres — es un documento que el humano va construyendo y editando. Solo identificá qué falta y preguntá para completar.
+- Tu rol es **SOLO clarificación funcional** — NO lanzás el orchestrator, implementador, ni reviewer. Eso lo hace el programador manualmente con /orch, /impl, /rev.
 - Si hay una TAREA EXISTENTE con RESULTADO PREVIO: FAIL, informá al usuario qué falló y preguntá si quiere corregir eso específico.
 - Si ya hay SPEC.MD o plan.json para la tarea, NO los regeneres — usá los existentes.
 - NO preguntés cosas que ya están respondidas en los archivos raw, TAREA EXISTENTE, SPEC.MD o la conversación.
 - Hacé como máximo UNA pregunta por turno.
 - NO uses JSON, hablá normalmente.
-- Sé directo y eficiente — respetá el tiempo del programador.${specInstructions}`;
+- Sé directo y eficiente — respetá el tiempo del programador.
+- **Cuando el spec esté listo**: Confirmá que el programador puede usar **/orch <feature-id>** para lanzar la planificación.${specInstructions}`;
             log.info('Coordinador analizando...');
             const envOverride = {};
             let res;
@@ -601,48 +630,48 @@ INSTRUCCIONES GENERALES:
                 }
                 // Sentinel-based detection — coordinator explicitly signals readiness
                 if (responseText.includes('[LISTO_PARA_LANZAR]')) {
-                    const confirm = await ask('  ¿Confirmás lanzar el orchestrator? (y/n): ', this.rl);
-                    if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 's') {
-                        let specPath;
-                        if (activeFeatureId) {
-                            const specDir = path.join(this.projectDir, '.agent', 'docs', activeFeatureId);
-                            const specFile = path.join(specDir, 'spec.md');
-                            // Si ya existe spec.md y hay contenido nuevo, ACTUALIZAR incrementalmente
-                            if (await fileExists(specFile) && pendingSpecContent) {
-                                const existingSpec = await readFile(specFile);
-                                // Si el contenido es sustancialmente diferente, preguntar al usuario
-                                if (existingSpec.trim() !== pendingSpecContent.trim()) {
-                                    console.log(chalk.yellow('\n  ⚠️  Ya existe un spec.md con este contenido:'));
-                                    console.log(chalk.dim('  ' + existingSpec.split('\n').slice(0, 10).join('\n  ')));
-                                    const action = await ask('\n  ¿Qué querés hacer? (r=reemplazar / m=mantener el existente / e=editar): ', this.rl);
-                                    if (action.toLowerCase() === 'r') {
-                                        await writeFile(specFile, pendingSpecContent);
-                                        log.ok(`spec.md reemplazado`);
-                                    }
-                                    else if (action.toLowerCase() === 'e') {
-                                        console.log(chalk.dim('  Editá el archivo spec.md manualmente y luego volvé a ejecutar.'));
-                                        return { task: conversationHistory, specPath: undefined, featureId: activeFeatureId };
-                                    }
-                                    else {
-                                        log.ok(`spec.md existente mantenido`);
-                                    }
+                    // El spec está listo — guardar y retornar SIN preguntar si lanzar orchestrator
+                    let specPath;
+                    if (activeFeatureId) {
+                        const specDir = path.join(this.projectDir, '.agent', 'docs', activeFeatureId);
+                        const specFile = path.join(specDir, 'spec.md');
+                        // Si ya existe spec.md y hay contenido nuevo, ACTUALIZAR incrementalmente
+                        if (await fileExists(specFile) && pendingSpecContent) {
+                            const existingSpec = await readFile(specFile);
+                            // Si el contenido es sustancialmente diferente, preguntar al usuario
+                            if (existingSpec.trim() !== pendingSpecContent.trim()) {
+                                console.log(chalk.yellow('\n  ⚠️  Ya existe un spec.md con este contenido:'));
+                                console.log(chalk.dim('  ' + existingSpec.split('\n').slice(0, 10).join('\n  ')));
+                                const action = await ask('\n  ¿Qué querés hacer? (r=reemplazar / m=mantener el existente / e=editar): ', this.rl);
+                                if (action.toLowerCase() === 'r') {
+                                    await writeFile(specFile, pendingSpecContent);
+                                    log.ok(`spec.md reemplazado`);
+                                }
+                                else if (action.toLowerCase() === 'e') {
+                                    console.log(chalk.dim('  Editá el archivo spec.md manualmente y luego volvé a ejecutar.'));
+                                    return { task: conversationHistory, specPath: undefined, featureId: activeFeatureId };
+                                }
+                                else {
+                                    log.ok(`spec.md existente mantenido`);
                                 }
                             }
-                            else if (pendingSpecContent) {
-                                // No existe spec.md — crearlo
-                                await writeFile(specFile, pendingSpecContent);
-                                log.ok(`spec.md guardado en ${path.relative(this.projectDir, specFile)}`);
-                            }
-                            if (await fileExists(specFile)) {
-                                specPath = specFile;
+                            else {
+                                log.ok(`spec.md ya está actualizado`);
                             }
                         }
-                        return { task: conversationHistory, specPath, featureId: activeFeatureId };
+                        else if (pendingSpecContent) {
+                            // No existe spec.md — crearlo
+                            await writeFile(specFile, pendingSpecContent);
+                            log.ok(`spec.md guardado en ${path.relative(this.projectDir, specFile)}`);
+                        }
+                        if (await fileExists(specFile)) {
+                            specPath = specFile;
+                        }
                     }
-                    const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl);
-                    conversationHistory += `\nPROGRAMADOR: ${correction}`;
-                    needsCoordinatorCall = true;
-                    continue;
+                    console.log(chalk.green('\n  ✓ Spec.md listo. Para continuar usá:'));
+                    console.log(chalk.dim(`    /orch ${activeFeatureId || '<feature-id>'}`));
+                    console.log(chalk.dim('  Esto generará el plan.json de implementación.\n'));
+                    return { task: conversationHistory, specPath, featureId: activeFeatureId };
                 }
             }
             // Ask user — slash commands are handled here without calling coordinator again

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-mp",
-  "version": "0.5.33",
+  "version": "0.5.35",
   "description": "Deterministic multi-agent CLI orchestrator — plan, code, review",
   "type": "module",
   "main": "./dist/index.js",