agent-mp 0.5.31 → 0.5.34

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

@@ -416,35 +416,17 @@ Los archivos raw YA ESTÁN en el CONTEXTO DEL PROYECTO arriba.
 
 REGLAS CRÍTICAS:
 1. ANTES DE ESCRIBIR CUALQUIER COSA: leé completo el CONTEXTO DEL PROYECTO, incluyendo la sección "TAREA EXISTENTE" si está presente.
-2. SI EXISTE "TAREA EXISTENTE" en el contexto:
-   - Si hay SPEC.MD EXISTENTE: NO lo regeneres. Usalo como referencia.
+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é 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: NO generes otro spec — la tarea ya está definida.
-3. NO preguntes sobre información que ya está en los archivos raw o en TAREA EXISTENTE.
-4. Solo hacé preguntas sobre información que GENUINAMENTE falta y que no podés inferir del contexto.
-5. Si los archivos ya tienen suficiente información para entender el objetivo, NO hagas preguntas — usá el spec existente.
-6. Cuando tengas todo claro (o si ya hay spec), generá el spec.md SOLO si NO existe uno previo:
-
-=== SPEC.MD ===
-# Feature: ${activeFeatureId}
-
-## Objetivo
-[descripción clara del objetivo]
-
-## Alcance
-[qué incluye y qué no incluye]
-
-## Historias de Usuario / Requerimientos
-[detalle de cada requerimiento]
-
-## Criterios de Aceptación
-[lista de criterios verificables]
-
-## Notas Técnicas
-[consideraciones de implementación]
-=== END SPEC.MD ===
-
-7. Cuando el spec esté aprobado (o si ya existe), escribí EXACTAMENTE al final: ${READY_SENTINEL}` : `
+   - 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}` : `
 MODO TAREA LIBRE — No se especificó feature todavía.
 ${featureListBlock}
 REGLAS:
@@ -468,9 +450,10 @@ ${conversationHistory}
 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.
 - 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 o la conversación.
+- 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}`;
@@ -621,12 +604,38 @@ INSTRUCCIONES GENERALES:
                     const confirm = await ask('  ¿Confirmás lanzar el orchestrator? (y/n): ', this.rl);
                     if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 's') {
                         let specPath;
-                        if (activeFeatureId && pendingSpecContent) {
+                        if (activeFeatureId) {
                             const specDir = path.join(this.projectDir, '.agent', 'docs', activeFeatureId);
                             const specFile = path.join(specDir, 'spec.md');
-                            await writeFile(specFile, pendingSpecContent);
-                            log.ok(`spec.md guardado en ${path.relative(this.projectDir, specFile)}`);
-                            specPath = specFile;
+                            // 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;
+                            }
                         }
                         return { task: conversationHistory, specPath, featureId: activeFeatureId };
                     }
@@ -1034,6 +1043,31 @@ REGLA: Al terminar, reporta todo lo que encontraste de forma clara y estructurad
         const taskId = await this.generateTaskId(task, featureId);
         const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
         log.phase(1, 'Planificacion', this.config.roles.orchestrator.cli, this.config.roles.orchestrator.model);
+        // VERIFICAR SI YA EXISTE UN PLAN PARA ESTA TAREA
+        const existingPlanPath = path.join(taskDir, 'plan.json');
+        if (await fileExists(existingPlanPath)) {
+            const existingPlan = await readJson(existingPlanPath);
+            console.log(chalk.yellow('\n  ⚠️  Ya existe un plan para esta tarea:'));
+            console.log(chalk.dim(`  Descripción: ${existingPlan.description?.slice(0, 100) || 'N/A'}`));
+            console.log(chalk.dim(`  Steps: ${existingPlan.steps?.length || 0}`));
+            const action = await ask('\n  ¿Qué querés hacer? (v=ver plan completo / r=regenerar / m=mantener y continuar): ', this.rl);
+            if (action.toLowerCase() === 'v') {
+                console.log('');
+                console.log(chalk.cyan('  === plan.json ==='));
+                console.log(chalk.white(JSON.stringify(existingPlan, null, 2).slice(0, 2000)));
+                console.log(chalk.cyan('  ================='));
+                const retry = await ask('  ¿Regenerar igual? (y/n): ', this.rl);
+                if (retry.toLowerCase() !== 'y') {
+                    log.info('Usando plan existente.');
+                    return { taskId, plan: existingPlan };
+                }
+            }
+            else if (action.toLowerCase() === 'm') {
+                log.info('Usando plan existente.');
+                return { taskId, plan: existingPlan };
+            }
+            // Si es 'r', continúa generando nuevo plan
+        }
         const context = await this.buildOrchestratorContext();
         let specContent = '';
         if (specPath && await fileExists(specPath)) {
@@ -1051,10 +1085,15 @@ ${context}
 INSTRUCCIONES CRÍTICAS:
 1. Si hay SPEC.MD, ESE ES EL DOCUMENTO PRIMARIO — define completamente la tarea. Los archivos raw son solo contexto histórico, NO los uses para definir la implementación.
 2. Ignorá cualquier información que NO tenga relación directa con la tarea del spec.md (ej: listas de modelos, ejemplos genéricos, etc.).
-3. Generá steps CONCRETOS y DIRECTOS para implementar lo que dice el spec.md — sin sobre-analizar.
-4. Si el spec.md dice "script que muestra la hora", los steps son: (1) crear el script, (2) hacerlo ejecutable. No más.
-5. Definí acceptance_criteria medibles leyendo archivos.
-6. Responde SOLO con este JSON exacto, sin texto adicional:
+3. **GENERÁ STEPS DE IMPLEMENTACIÓN CONCRETOS** — NO steps sobre "leer", "analizar", "identificar". El implementor ya sabe leer.
+   - ❌ MAL: "Leer spec.md para identificar requerimientos"
+   - ❌ MAL: "Analizar archivos raw como contexto"
+   - ✅ BIEN: "Crear script clock.sh con formato HH:MM:SS, sleep 1, trap SIGINT"
+   - ✅ BIEN: "Hacer ejecutable el script con chmod +x"
+4. Cada step debe tener una descripción de **ACCIÓN** (crear, modificar, instalar, configurar) y los archivos específicos que se van a crear/modificar.
+5. Si el spec.md dice "script que muestra la hora", los steps son: (1) crear el script, (2) hacerlo ejecutable. No más.
+6. Definí acceptance_criteria medibles leyendo archivos.
+7. Responde SOLO con este JSON exacto, sin texto adicional:
 
 {"plan":{"task_id":"${taskId}","description":"${task}","steps":[{"num":1,"description":"descripcion concreta del paso","files":["archivo/a/crear.ts"],"status":"pending"}],"acceptance_criteria":["criterio verificable"],"deliberation":{"needed":false,"question":""}}}`;
         const res = await this.runWithFallback('orchestrator', prompt, 'Planificacion');

package/package.json

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