agent-rev 0.1.0

package/dist/core/engine.js

@@ -0,0 +1,905 @@
+import { spawn, execSync } from 'child_process';
+import * as path from 'path';
+import * as os from 'os';
+import * as readline from 'readline';
+import { CLI_REGISTRY } from '../types.js';
+import { writeJson, readJson, fileExists, writeFile, readFile } from '../utils/fs.js';
+import { log } from '../utils/logger.js';
+import chalk from 'chalk';
+import { QWEN_AGENT_HOME } from '../utils/qwen-auth.js';
+import { callQwenAPI } from '../utils/qwen-auth.js';
+import * as fs from 'fs/promises';
+/** Parse --help output to detect current flags */
+function detectCliFlags(cliName) {
+    try {
+        const help = execSync(`${cliName} --help 2>&1`, { encoding: 'utf-8', timeout: 10000 });
+        const result = {};
+        // Detect model flag
+        const modelFlagMatch = help.match(/--model\s/);
+        if (modelFlagMatch)
+            result.modelFlag = '--model';
+        const mFlagMatch = help.match(/(?:^|\s)-m\s/);
+        if (mFlagMatch && !result.modelFlag)
+            result.modelFlag = '-m';
+        // Detect extra flags — look for common patterns
+        const extraCandidates = [];
+        const flagPatterns = [
+            '--yolo', '--dangerously-skip-permissions', '--yes', '--auto',
+            '--output-format', '-o', '--json',
+        ];
+        for (const fp of flagPatterns) {
+            if (help.includes(fp))
+                extraCandidates.push(fp);
+        }
+        if (extraCandidates.length > 0)
+            result.extraFlags = extraCandidates.join(' ');
+        // Detect prompt/positional flag
+        if (help.includes('--prompt'))
+            result.promptFlag = '--prompt';
+        else if (help.includes('-p'))
+            result.promptFlag = '-p';
+        else if (help.includes('-p '))
+            result.promptFlag = '-p';
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/** Rebuild a CLI command from scratch using detected flags */
+function rebuildCmd(cliName, model, flags) {
+    const info = CLI_REGISTRY[cliName];
+    if (!info)
+        return `${cliName} ${flags.modelFlag || '--model'} ${model}`;
+    const modelFlag = flags.modelFlag || info.modelFlag;
+    const extra = flags.extraFlags || info.extraFlags;
+    const promptFlag = flags.promptFlag || info.promptFlag;
+    if (cliName === 'codex')
+        return `codex exec -m ${model}`;
+    if (cliName === 'cn')
+        return `cn --auto -p`;
+    if (cliName === 'opencode')
+        return `opencode run ${modelFlag ? `${modelFlag} ${model}` : model}`;
+    const extraStr = extra ? ` ${extra}` : '';
+    const promptStr = promptFlag ? ` ${promptFlag}` : '';
+    return `${info.command} ${modelFlag} ${model}${extraStr}${promptStr}`.trim();
+}
+async function ask(prompt, rl, fi) {
+    if (fi) {
+        fi.println(chalk.cyan(`  ${prompt}`));
+        const answer = await fi.readLine();
+        // Echo user response right-aligned (chat style, per line)
+        const userLines = answer.trim().split('\n').filter(l => l.trim());
+        for (let i = 0; i < userLines.length; i++) {
+            const prefix = (i === 0) ? chalk.dim('usuario: ') : '         ';
+            const msg = `${prefix}${chalk.white(userLines[i])}`;
+            const rawLen = msg.replace(/\x1b\[[0-9;]*m/g, '').length;
+            const padding = ' '.repeat(Math.max(0, fi.cols - rawLen - 2));
+            fi.println(`${padding}${msg}`);
+        }
+        return answer;
+    }
+    if (rl) {
+        return new Promise((resolve) => rl.question(prompt, resolve));
+    }
+    const tempRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => tempRl.question(prompt, (a) => { tempRl.close(); resolve(a); }));
+}
+function runCli(cmd, prompt, timeoutMs = 600000, envOverride) {
+    // Si el comando es "qwen-direct", usar la API directa sin CLI
+    if (cmd.startsWith('qwen-direct')) {
+        const model = cmd.includes('-m') ? cmd.split('-m')[1]?.trim().split(/\s/)[0] : 'coder-model';
+        return callQwenAPI(prompt, model)
+            .then(output => ({ output, exitCode: 0 }))
+            .catch(err => ({ output: `Error: ${err.message}`, exitCode: 1 }));
+    }
+    return new Promise((resolve, reject) => {
+        const parts = cmd.trim().split(/\s+/);
+        let fullCmd;
+        let fullArgs;
+        if (cmd.includes('codex exec')) {
+            fullCmd = 'codex';
+            const rest = parts.slice(1);
+            fullArgs = rest.filter((p) => p !== '-p' && p !== '--prompt').concat([prompt]);
+        }
+        else if (cmd.includes('opencode run')) {
+            // opencode run -m model "message" — strip any -p/--prompt flags (opencode uses -p for password)
+            fullCmd = 'opencode';
+            const rest = parts.slice(1).filter((p) => p !== '-p' && p !== '--prompt');
+            fullArgs = rest.concat([prompt]);
+        }
+        else if (parts[0] === 'opencode' && !cmd.includes('run')) {
+            // opencode -m model → needs "run" subcommand, strip -p (opencode uses -p for password)
+            fullCmd = 'opencode';
+            const rest = parts.slice(1).filter((p) => p !== '-p' && p !== '--prompt');
+            fullArgs = ['run'].concat(rest).concat([prompt]);
+        }
+        else if (parts.includes('-p')) {
+            fullCmd = parts[0];
+            fullArgs = parts.slice(1).filter((p) => p !== '-p' && p !== '--prompt').concat(['-p', prompt]);
+        }
+        else {
+            fullCmd = parts[0];
+            fullArgs = parts.slice(1).concat([prompt]);
+        }
+        // Configurar entorno: si es qwen, usar QWEN_CODE_HOME separado
+        const baseEnv = process.env;
+        const finalEnv = {};
+        for (const [key, value] of Object.entries(baseEnv)) {
+            if (value !== undefined) {
+                finalEnv[key] = value;
+            }
+        }
+        if (fullCmd === 'qwen' && envOverride?.QWEN_CODE_HOME) {
+            finalEnv.QWEN_CODE_HOME = envOverride.QWEN_CODE_HOME;
+        }
+        const child = spawn(fullCmd, fullArgs, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            env: finalEnv,
+        });
+        let output = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => { output += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('close', (code) => { resolve({ output: output + stderr, exitCode: code || 0 }); });
+        child.on('error', reject);
+    });
+}
+function extractTokens(output) {
+    const u = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
+    const im = output.match(/"input_tokens":\s*(\d+)/);
+    const om = output.match(/"output_tokens":\s*(\d+)/);
+    const cm = output.match(/"cache_read_input_tokens":\s*(\d+)/);
+    if (im)
+        u.input_tokens = parseInt(im[1]);
+    if (om)
+        u.output_tokens = parseInt(om[1]);
+    if (cm)
+        u.cache_read_input_tokens = parseInt(cm[1]);
+    return u;
+}
+/** Extract the final text response from a CLI output (handles qwen/claude streaming JSON events) */
+function extractCliText(output) {
+    const trimmed = output.trim();
+    // Try to parse as a JSON array of events (qwen/claude streaming format)
+    try {
+        const events = JSON.parse(trimmed);
+        if (Array.isArray(events)) {
+            // Look for result event first
+            for (const item of events) {
+                if (item.type === 'result' && typeof item.result === 'string')
+                    return item.result;
+            }
+            // Fallback: collect all assistant text content
+            const texts = [];
+            for (const item of events) {
+                if (item.type === 'assistant' && Array.isArray(item.message?.content)) {
+                    for (const c of item.message.content) {
+                        if (c.type === 'text' && typeof c.text === 'string')
+                            texts.push(c.text);
+                    }
+                }
+            }
+            if (texts.length > 0)
+                return texts.join('\n');
+        }
+    }
+    catch { }
+    return trimmed;
+}
+function extractJson(text) {
+    let c = text.trim();
+    if (c.startsWith('```')) {
+        c = c.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+    }
+    const first = c.indexOf('{');
+    const last = c.lastIndexOf('}');
+    if (first === -1 || last === -1)
+        throw new Error('No JSON found');
+    return JSON.parse(c.slice(first, last + 1));
+}
+export class AgentEngine {
+    config;
+    projectDir;
+    coordinatorCmd;
+    rl;
+    fi;
+    totalTokens = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
+    phaseTokens = [];
+    constructor(config, projectDir, coordinatorCmd, rl, fi) {
+        this.config = config;
+        this.projectDir = projectDir;
+        this.coordinatorCmd = coordinatorCmd || '';
+        this.rl = rl;
+        this.fi = fi;
+    }
+    /**
+     * FASE 0 — Clarificacion con el programador.
+     * El coordinador (CLI activo, ej: Qwen) conversa con el usuario
+     * hasta tener toda la info necesaria. Retorna la tarea refinada.
+     */
+    async runClarification(initialTask) {
+        if (!this.coordinatorCmd) {
+            return initialTask;
+        }
+        log.section('FASE 0 — Clarificacion');
+        log.info('El coordinador va a conversar con vos para entender la tarea.');
+        log.info('Cuando el coordinador tenga claro el objetivo, te va a pedir confirmación para lanzar el plan.');
+        log.divider();
+        const context = await this.buildCoordinatorContext();
+        let conversationHistory = `TAREA INICIAL: ${initialTask}`;
+        // Loop de clarificacion
+        while (true) {
+            const prompt = `Sos el COORDINADOR de un equipo multi-agente de desarrollo.
+Tu trabajo es ENTENDER lo que el programador necesita haciendo PREGUNTAS si es necesario.
+
+CONTEXTO DEL PROYECTO:
+${context}
+
+CONVERSACION PREVIA:
+${conversationHistory}
+
+INSTRUCCIONES:
+- Habla de forma NATURAL, como un compañero de equipo.
+- Si necesitas mas info, hace UNA pregunta clara y espera la respuesta.
+- Si ya entendiste el objetivo, decilo claramente y pregunta: "¿Confirmás para lanzar el orchestrator?"
+- NO uses JSON, habla normalmente.
+- Sé breve y directo.`;
+            log.info('Coordinador analizando...');
+            // Usar credenciales corporativas si es qwen
+            const envOverride = {};
+            const corporateCreds = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+            const personalCreds = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
+            if (this.coordinatorCmd.startsWith('qwen')) {
+                // Check if corporate credentials exist
+                let corporateCredsContent = null;
+                try {
+                    corporateCredsContent = await fs.readFile(corporateCreds, 'utf-8');
+                }
+                catch {
+                    console.log(chalk.red('\n  ✗ No hay credenciales corporativas de Qwen.'));
+                    console.log(chalk.yellow('  Ejecutá /login para autenticarte.\n'));
+                    return initialTask;
+                }
+                // Backup personal creds
+                let personalBackup = null;
+                try {
+                    personalBackup = await fs.readFile(personalCreds, 'utf-8');
+                }
+                catch { }
+                // Copy corporate creds to personal location
+                await fs.writeFile(personalCreds, corporateCredsContent);
+                const res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
+                // Restore personal creds
+                if (personalBackup) {
+                    await fs.writeFile(personalCreds, personalBackup);
+                }
+                else {
+                    // No personal backup, remove the file
+                    await fs.unlink(personalCreds).catch(() => { });
+                }
+                // Extraer texto legible del output (Qwen CLI devuelve JSON con eventos)
+                let responseText = res.output.trim();
+                try {
+                    const json = JSON.parse(res.output);
+                    if (Array.isArray(json)) {
+                        // Buscar el resultado final
+                        for (const item of json) {
+                            if (item.type === 'result' && typeof item.result === 'string') {
+                                responseText = item.result;
+                                break;
+                            }
+                            if (item.type === 'assistant' && item.message?.content?.length > 0) {
+                                const textContent = item.message.content.find((c) => c.type === 'text');
+                                if (textContent?.text) {
+                                    responseText = textContent.text;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // No es JSON, usar el output directo
+                }
+                console.log('');
+                console.log(chalk.cyan('  Coordinador:'));
+                console.log(chalk.white(`  ${responseText}`));
+                console.log('');
+                // Verificar si el coordinador quiere lanzar el orchestrator EXPLICITAMENTE
+                // Solo si pregunta "confirmás" o similar
+                const lower = responseText.toLowerCase();
+                if ((lower.includes('confirm') || lower.includes('procedo') || lower.includes('lanzo el plan')) &&
+                    (lower.includes('orchestrator') || lower.includes('plan'))) {
+                    const confirm = await ask('  ¿Confirmás lanzar el orchestrator? (y/n): ', this.rl, this.fi);
+                    if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 's') {
+                        return conversationHistory;
+                    }
+                    const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl, this.fi);
+                    conversationHistory += `\nPROGRAMADOR: ${correction}`;
+                    continue;
+                }
+                // Si no, seguir conversando
+                const answer = await ask('  Tu respuesta: ', this.rl, this.fi);
+                conversationHistory += `\nPROGRAMADOR: ${answer}`;
+            }
+            else {
+                // Para otros CLIs, usar normalmente
+                const res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
+                // Extraer texto legible del output
+                let responseText = res.output.trim();
+                try {
+                    const json = JSON.parse(res.output);
+                    if (Array.isArray(json)) {
+                        for (const item of json) {
+                            if (item.type === 'result' && typeof item.result === 'string') {
+                                responseText = item.result;
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch { }
+                console.log('');
+                console.log(chalk.cyan('  Coordinador:'));
+                console.log(chalk.white(`  ${responseText}`));
+                console.log('');
+                const lower = responseText.toLowerCase();
+                if ((lower.includes('confirm') || lower.includes('procedo')) &&
+                    (lower.includes('orchestrator') || lower.includes('plan'))) {
+                    const confirm = await ask('  ¿Confirmás lanzar el orchestrator? (y/n): ', this.rl, this.fi);
+                    if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 's') {
+                        return conversationHistory;
+                    }
+                    const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl, this.fi);
+                    conversationHistory += `\nPROGRAMADOR: ${correction}`;
+                    continue;
+                }
+                const answer = await ask('  Tu respuesta: ', this.rl, this.fi);
+                conversationHistory += `\nPROGRAMADOR: ${answer}`;
+            }
+        }
+    }
+    async runWithFallback(roleName, prompt, phaseName) {
+        const roleMap = {
+            orchestrator: 'orchestrator',
+            implementor: 'implementor',
+            reviewer: 'reviewer',
+        };
+        const key = roleMap[roleName];
+        const role = this.config.roles[key];
+        if (!role)
+            throw new Error(`Role "${roleName}" not configured`);
+        const trackTokens = (output, cli, model) => {
+            const tokens = extractTokens(output);
+            this.totalTokens.input_tokens += tokens.input_tokens;
+            this.totalTokens.output_tokens += tokens.output_tokens;
+            this.totalTokens.cache_read_input_tokens += tokens.cache_read_input_tokens;
+            if (phaseName) {
+                this.phaseTokens.push({
+                    phase: phaseName,
+                    cli,
+                    model,
+                    role: roleName,
+                    input: tokens.input_tokens,
+                    output: tokens.output_tokens,
+                });
+            }
+        };
+        // Inject role-specific system prompt
+        const rolePrompt = this.buildRolePrompt(roleName, prompt);
+        /** Try a cmd, and if it fails, auto-detect flags from --help and retry */
+        const tryWithAutoRepair = async (cliName, model, currentCmd) => {
+            try {
+                const result = await runCli(currentCmd, rolePrompt);
+                if (result.exitCode !== 0) {
+                    const detail = result.output.trim().slice(0, 500);
+                    throw new Error(`${cliName} exited with code ${result.exitCode}${detail ? `\n${detail}` : ''}`);
+                }
+                return result.output;
+            }
+            catch (err) {
+                log.warn(`${cliName} failed, detecting flags from --help: ${err.message}`);
+                const detected = detectCliFlags(cliName);
+                if (Object.keys(detected).length === 0) {
+                    log.warn(`Could not detect flags for ${cliName}`);
+                    return null;
+                }
+                const newCmd = rebuildCmd(cliName, model, detected);
+                log.info(`Rebuilt command: ${newCmd}`);
+                // Update config so next time we use the new flags
+                const roleKey = key;
+                if (cliName === role.cli && model === role.model) {
+                    // Update primary role cmd
+                    ;
+                    role.cmd = newCmd;
+                }
+                else if (role.fallback && cliName === role.fallback.cli && model === role.fallback.model) {
+                    ;
+                    role.fallback.cmd = newCmd;
+                }
+                else if (this.config.fallback_global && cliName === this.config.fallback_global.cli && model === this.config.fallback_global.model) {
+                    ;
+                    this.config.fallback_global.cmd = newCmd;
+                }
+                // Persist to .agent/config.json
+                try {
+                    const configPath = path.join(this.projectDir, '.agent', 'config.json');
+                    const savedConfig = await readJson(configPath);
+                    // Update the specific role's cmd
+                    if (savedConfig.roles && savedConfig.roles[roleKey]) {
+                        if (cliName === savedConfig.roles[roleKey].cli && model === savedConfig.roles[roleKey].model) {
+                            savedConfig.roles[roleKey].cmd = newCmd;
+                            if (savedConfig.roles[roleKey].fallback?.cli === role.fallback?.cli) {
+                                savedConfig.roles[roleKey].fallback.cmd = role.fallback?.cmd || '';
+                            }
+                        }
+                        else if (role.fallback && cliName === savedConfig.roles[roleKey].fallback?.cli) {
+                            savedConfig.roles[roleKey].fallback.cmd = newCmd;
+                        }
+                    }
+                    if (this.config.fallback_global && savedConfig.fallback_global) {
+                        if (cliName === savedConfig.fallback_global.cli) {
+                            savedConfig.fallback_global.cmd = newCmd;
+                        }
+                    }
+                    await writeJson(configPath, savedConfig);
+                    log.ok(`Updated .agent/config.json with new flags for ${cliName}`);
+                }
+                catch {
+                    // Config file might not exist yet
+                }
+                // Retry with new command
+                try {
+                    const result = await runCli(newCmd, rolePrompt);
+                    if (result.exitCode !== 0) {
+                        const detail = result.output.trim().slice(0, 500);
+                        throw new Error(`${cliName} (repaired) exited with code ${result.exitCode}${detail ? `\n${detail}` : ''}`);
+                    }
+                    log.ok(`${cliName} succeeded with repaired flags`);
+                    return result.output;
+                }
+                catch (retryErr) {
+                    log.warn(`Repaired ${cliName} also failed: ${retryErr.message}`);
+                    return null;
+                }
+            }
+        };
+        // Try primary
+        log.info(`Launching ${roleName}: ${role.cli} (${role.model})`);
+        const primaryResult = await tryWithAutoRepair(role.cli, role.model, role.cmd);
+        if (primaryResult !== null) {
+            trackTokens(primaryResult, role.cli, role.model);
+            return primaryResult;
+        }
+        // Try individual fallback
+        if (role.fallback) {
+            log.warn(`Trying individual fallback for ${roleName}: ${role.fallback.cli} (${role.fallback.model})`);
+            const fallbackResult = await tryWithAutoRepair(role.fallback.cli, role.fallback.model, role.fallback.cmd);
+            if (fallbackResult !== null) {
+                trackTokens(fallbackResult, role.fallback.cli, role.fallback.model);
+                return fallbackResult;
+            }
+        }
+        // Try global fallback
+        if (this.config.fallback_global) {
+            const fb = this.config.fallback_global;
+            log.warn(`Trying global fallback: ${fb.cli} (${fb.model})`);
+            const globalResult = await tryWithAutoRepair(fb.cli, fb.model, fb.cmd);
+            if (globalResult !== null) {
+                trackTokens(globalResult, fb.cli, fb.model);
+                return globalResult;
+            }
+        }
+        // All options exhausted
+        throw new Error(`${roleName} failed: primary + individual fallback + global fallback all failed`);
+    }
+    buildRolePrompt(roleName, taskPrompt) {
+        // Role preambles are minimal — each role gets only what it needs.
+        // The actual task context is in taskPrompt.
+        const preambles = {
+            orchestrator: `ROL: ORCHESTRATOR — solo planifica, nunca implementa.
+REGLA: Tu unica salida debe ser el JSON del plan. Sin explicaciones, sin texto extra.`,
+            implementor: `ROL: IMPLEMENTOR — solo ejecuta los steps del plan usando tus herramientas.
+REGLA: Usa tus herramientas (read_file, write_file, run_shell_command, etc.) para ejecutar cada step.
+REGLA: NO tomes decisiones de arquitectura. NO modifiques el plan.
+REGLA: Al terminar, responde SOLO con el JSON de progreso indicado.`,
+            reviewer: `ROL: REVIEWER — solo valida, nunca modifica codigo.
+REGLA: Usa tus herramientas (read_file, grep_search, etc.) para leer los archivos y verificar criterios.
+REGLA: NO modifiques archivos. NO implementes correcciones.
+REGLA: Al terminar, responde SOLO con el JSON de resultado indicado.`,
+        };
+        const preamble = preambles[roleName] || '';
+        return preamble ? `${preamble}\n\n${taskPrompt}` : taskPrompt;
+    }
+    async generateTaskId(task) {
+        const today = new Date().toISOString().split('T')[0];
+        const short = task.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 30);
+        let num = 1;
+        while (true) {
+            const id = `${today}_${String(num).padStart(3, '0')}_${short}`;
+            const dir = path.join(this.projectDir, '.agent', 'tasks', id);
+            if (!(await fileExists(dir)))
+                return id;
+            num++;
+        }
+    }
+    /** Context for the ORCHESTRATOR only — planning-relevant files */
+    async buildOrchestratorContext() {
+        let ctx = `Project: ${this.config.project}\nStack: ${this.config.stack}\n`;
+        ctx += `Approved dirs: ${this.config.structure.approved_dirs.join(', ')}\n`;
+        ctx += `Forbidden dirs: ${this.config.structure.forbidden_dirs.join(', ')}\n`;
+        // Only planning-relevant docs — no architecture.md (that's built by previous tasks)
+        const planningFiles = ['.agent/INDEX.md', '.agent/rules/structure.md', '.agent/rules/patterns.md'];
+        for (const f of planningFiles) {
+            const fp = path.join(this.projectDir, f);
+            if (await fileExists(fp)) {
+                const content = await readFile(fp);
+                ctx += `\n--- ${f} ---\n${content.slice(0, 5000)}\n`;
+            }
+        }
+        return ctx;
+    }
+    /** Minimal context for COORDINATOR clarification only */
+    async buildCoordinatorContext() {
+        let ctx = `Project: ${this.config.project}\nStack: ${this.config.stack}\n`;
+        const indexPath = path.join(this.projectDir, '.agent', 'INDEX.md');
+        if (await fileExists(indexPath)) {
+            const content = await readFile(indexPath);
+            ctx += `\n--- INDEX ---\n${content.slice(0, 2000)}\n`;
+        }
+        return ctx;
+    }
+    async runOrchestrator(task) {
+        const taskId = await this.generateTaskId(task);
+        const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
+        log.phase(1, 'Planificacion', this.config.roles.orchestrator.cli, this.config.roles.orchestrator.model);
+        const context = await this.buildOrchestratorContext();
+        const prompt = `TAREA: ${task}
+TASK_ID: ${taskId}
+DIRECTORIO_TRABAJO: ${this.projectDir}
+
+CONTEXTO DEL PROYECTO:
+${context}
+
+INSTRUCCIONES:
+1. Analiza la tarea y el contexto del proyecto.
+2. Descompone en steps concretos y verificables.
+3. Define acceptance_criteria medibles (cada criterio debe poder verificarse leyendo un archivo).
+4. 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');
+        // Extract text content (handles streaming CLI formats like qwen/opencode)
+        const text = extractCliText(res);
+        try {
+            const json = extractJson(text);
+            const plan = (json.plan || json);
+            // Validate required fields
+            if (!plan.task_id || !Array.isArray(plan.steps) || !Array.isArray(plan.acceptance_criteria)) {
+                throw new Error('Missing required fields in plan');
+            }
+            // Engine constructs progress — orchestrator is never responsible for this
+            const progress = {
+                task_id: taskId,
+                created_at: new Date().toISOString(),
+                steps: plan.steps.map((s) => ({ num: s.num, description: s.description, files: s.files || [], status: 'pending' })),
+                status: 'planned',
+            };
+            await writeJson(path.join(taskDir, 'plan.json'), plan);
+            await writeJson(path.join(taskDir, 'progress.json'), progress);
+            await writeFile(path.join(taskDir, 'request.md'), `# Request\n\n${task}\n`);
+            log.ok('plan.json generated');
+            log.ok('progress.json generated');
+            log.ok('request.md generated');
+            log.info(`Steps: ${plan.steps.length}`);
+            for (const step of plan.steps) {
+                log.info(`  Step ${step.num}: ${step.description}`);
+            }
+            log.info(`Acceptance criteria: ${plan.acceptance_criteria.length}`);
+            for (const ac of plan.acceptance_criteria) {
+                log.info(`  - ${ac}`);
+            }
+            if (plan.deliberation?.needed)
+                log.warn(`Deliberation needed: ${plan.deliberation.question}`);
+            return { taskId, plan };
+        }
+        catch (e) {
+            log.error('Failed to parse orchestrator response');
+            log.error(`Detail: ${e.message}`);
+            log.error('Raw output (first 500 chars):');
+            log.info(text.slice(0, 500));
+            throw new Error(`Invalid orchestrator response: ${e.message}`);
+        }
+    }
+    async runDeliberation(taskId, plan) {
+        if (!this.config.deliberation || !plan.deliberation.needed)
+            return;
+        const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
+        const debateDir = path.join(taskDir, 'debate');
+        const maxRounds = this.config.deliberation.max_rounds;
+        const question = plan.deliberation.question;
+        const pRole = this.config.deliberation.proposer;
+        const cRole = this.config.deliberation.critic;
+        log.section('Deliberation');
+        for (let round = 1; round <= maxRounds; round++) {
+            log.info(`Round ${round}/${maxRounds}`);
+            const propPrompt = `TAREA: ${plan.description}\nPREGUNTA: ${question}\nGenera propuesta tecnica. Responde SOLO JSON: {"proposal":"...","justification":"..."}`;
+            const propRes = await runCli(pRole.cmd, propPrompt);
+            await writeFile(path.join(debateDir, `round-${round}-proposal.md`), propRes.output);
+            const critPrompt = `PROPUESTA: ${propRes.output}\nAnaliza y responde SOLO JSON: {"analysis":"...","verdict":"ACCEPT"}`;
+            const critRes = await runCli(cRole.cmd, critPrompt);
+            await writeFile(path.join(debateDir, `round-${round}-critique.md`), critRes.output);
+            if (critRes.output.includes('ACCEPT')) {
+                log.ok(`Accepted in round ${round}`);
+                plan.deliberation.resolved = true;
+                plan.deliberation.rounds = round;
+                await writeJson(path.join(taskDir, 'plan.json'), plan);
+                return;
+            }
+        }
+        plan.deliberation.resolved = true;
+        plan.deliberation.rounds = maxRounds;
+        await writeJson(path.join(taskDir, 'plan.json'), plan);
+    }
+    async runImplementor(taskId, plan) {
+        const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
+        log.phase(2, 'Implementacion', this.config.roles.implementor.cli, this.config.roles.implementor.model);
+        const structurePath = path.join(this.projectDir, '.agent', 'rules', 'structure.md');
+        let structureRules = '';
+        if (await fileExists(structurePath)) {
+            structureRules = await readFile(structurePath);
+        }
+        // Build steps list — implementor gets ONLY steps and structure rules (no acceptance_criteria, no deliberation)
+        const stepsText = plan.steps.map((s) => `Step ${s.num}: ${s.description}${s.files?.length ? `\n  Archivos: ${s.files.join(', ')}` : ''}`).join('\n');
+        const prompt = `TAREA: ${plan.description}
+DIRECTORIO_TRABAJO: ${this.projectDir}
+
+STEPS A EJECUTAR EN ORDEN:
+${stepsText}
+
+${structureRules ? `REGLAS DE ESTRUCTURA:\n${structureRules}\n` : ''}
+INSTRUCCIONES:
+1. Ejecuta cada step EN ORDEN usando tus herramientas (read_file, write_file, run_shell_command, etc.)
+2. Para cada step: lee lo necesario, luego crea/modifica los archivos indicados.
+3. NO tomes decisiones de arquitectura fuera del plan.
+4. Al terminar todos los steps, responde SOLO con este JSON:
+
+{"status":"completed","steps_done":[1,2,3],"notes":"resumen breve de lo que se hizo"}`;
+        const res = await this.runWithFallback('implementor', prompt, 'Implementacion');
+        // Extract text from streaming CLI output (qwen/claude return event arrays)
+        const text = extractCliText(res);
+        let progress;
+        try {
+            const json = extractJson(text);
+            progress = (json.progress || json);
+        }
+        catch {
+            // CLI executed the task but didn't return structured JSON — build synthetic progress
+            log.warn('Implementor did not return JSON progress — building from plan');
+            const now = new Date().toISOString();
+            progress = {
+                task_id: taskId,
+                created_at: now,
+                status: 'completed',
+                steps: plan.steps.map((s) => ({ ...s, status: 'completed', completed_at: now })),
+            };
+        }
+        await writeJson(path.join(taskDir, 'progress.json'), progress);
+        log.ok('progress.json updated');
+        return progress;
+    }
+    async runReviewer(taskId, plan, progress) {
+        const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
+        log.phase(3, 'Review', this.config.roles.reviewer.cli, this.config.roles.reviewer.model);
+        // Collect all files the implementor should have created/modified
+        const targetFiles = [...new Set(plan.steps.flatMap((s) => s.files || []))];
+        const prompt = `TAREA: ${plan.description}
+DIRECTORIO_TRABAJO: ${this.projectDir}
+
+ACCEPTANCE CRITERIA A VERIFICAR:
+${plan.acceptance_criteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}
+
+ARCHIVOS A REVISAR:
+${targetFiles.length ? targetFiles.map((f) => `- ${f}`).join('\n') : '(revisar archivos creados por el implementor segun los steps)'}
+
+STEPS EJECUTADOS:
+${plan.steps.map((s) => `Step ${s.num}: ${s.description}`).join('\n')}
+
+INSTRUCCIONES:
+1. Usa read_file/grep_search para leer cada archivo listado en ARCHIVOS A REVISAR.
+2. Para cada criterio de ACCEPTANCE CRITERIA: verifica si se cumple en el codigo real leido.
+3. Un criterio es PASS solo si hay evidencia directa en los archivos leidos. Si no pudiste leer el archivo, es FAIL.
+4. NO modifiques nada. NO implementes correcciones.
+5. Al terminar, responde SOLO con este JSON:
+
+{"result":{"verdict":"PASS","criteria_results":[{"criteria":"criterio exacto","status":"PASS","notes":"evidencia encontrada"}],"explanation":"resumen"}}`;
+        const res = await this.runWithFallback('reviewer', prompt, 'Review');
+        // Extract text from streaming CLI output
+        const text = extractCliText(res);
+        let verdict = 'PASS';
+        let md = `# Result - ${taskId}\n\n`;
+        try {
+            const json = extractJson(text);
+            const result = json.result || json;
+            verdict = result.verdict || 'PASS';
+            const criteriaResults = result.criteria_results || [];
+            md += `**Verdict: ${verdict}**\n\n## Criteria\n\n`;
+            for (const cr of criteriaResults) {
+                const icon = cr.status === 'PASS' ? '✓' : '✗';
+                md += `${icon} ${cr.criteria}${cr.notes ? ` — ${cr.notes}` : ''}\n`;
+            }
+            md += `\n## Explanation\n\n${result.explanation || ''}\n`;
+        }
+        catch {
+            // Reviewer ran but didn't return structured JSON — use raw text as explanation
+            log.warn('Reviewer did not return JSON — using raw output');
+            // Check if text contains FAIL/PASS keywords
+            if (text.toLowerCase().includes('fail'))
+                verdict = 'FAIL';
+            md += `**Verdict: ${verdict}**\n\n## Review\n\n${text}\n`;
+        }
+        await writeFile(path.join(taskDir, 'result.md'), md);
+        progress.validation = { status: verdict, reviewed_at: new Date().toISOString(), reviewer: this.config.roles.reviewer.model };
+        await writeJson(path.join(taskDir, 'progress.json'), progress);
+        log.verdict(verdict);
+        return { verdict };
+    }
+    async runFullCycle(task) {
+        // Header is now shown by the REPL before the first user message
+        // ══════════════════════════════════════════════════
+        // FASE 0 — Clarificacion (Coordinador ↔ Programador)
+        // ══════════════════════════════════════════════════
+        const refinedTask = await this.runClarification(task);
+        // ══════════════════════════════════════════════════
+        // FASE 1 — Planificacion (Orchestrator)
+        // ══════════════════════════════════════════════════
+        let taskId;
+        let plan;
+        while (true) {
+            try {
+                log.section('FASE 1 — Planificacion');
+                const result = await this.runOrchestrator(refinedTask);
+                taskId = result.taskId;
+                plan = result.plan;
+                break;
+            }
+            catch (err) {
+                log.error(`Orchestrator fallo: ${err.message}`);
+                console.log('');
+                const action = await ask('  Que hacemos? (r=reintentar / s=saltar / c=cancelar): ', this.rl, this.fi);
+                if (action.toLowerCase() === 'r')
+                    continue;
+                if (action.toLowerCase() === 's') {
+                    log.info('Planificacion saltada.');
+                    return;
+                }
+                log.info('Ciclo cancelado.');
+                return;
+            }
+        }
+        // Deliberation opcional
+        if (plan.deliberation.needed && this.config.deliberation) {
+            const a = await ask('\n  El plan requiere deliberacion. Ejecutar? (y/N): ', this.rl, this.fi);
+            if (a.toLowerCase() === 'y')
+                await this.runDeliberation(taskId, plan);
+        }
+        // ══════════════════════════════════════════════════
+        // COORDINADOR: Mostrar plan y preguntar
+        // ══════════════════════════════════════════════════
+        log.divider();
+        log.ok(`Plan generado: .agent/tasks/${taskId}/plan.json`);
+        log.info(`Steps: ${plan.steps.length} | Criteria: ${plan.acceptance_criteria.length}`);
+        const confirm1 = await ask('\n  El plan esta listo. Ejecutar implementador? (y/N): ', this.rl, this.fi);
+        if (confirm1.toLowerCase() !== 'y') {
+            log.info('Implementacion cancelada por el usuario.');
+            log.info(`Plan guardado en: .agent/tasks/${taskId}/`);
+            return;
+        }
+        // ══════════════════════════════════════════════════
+        // FASE 2 — Implementacion (Implementor)
+        // ══════════════════════════════════════════════════
+        let progress;
+        while (true) {
+            try {
+                log.section('FASE 2 — Implementacion');
+                progress = await this.runImplementor(taskId, plan);
+                break;
+            }
+            catch (err) {
+                log.error(`Implementor fallo: ${err.message}`);
+                console.log('');
+                const action = await ask('  Que hacemos? (r=reintentar / f=feedback / c=cancelar): ', this.rl, this.fi);
+                if (action.toLowerCase() === 'r')
+                    continue;
+                if (action.toLowerCase() === 'f') {
+                    const feedback = await ask('  Tu feedback: ', this.rl, this.fi);
+                    log.info(`Feedback registrado: ${feedback}`);
+                    continue;
+                }
+                log.info('Ciclo cancelado.');
+                return;
+            }
+        }
+        // ══════════════════════════════════════════════════
+        // COORDINADOR: Verificar y preguntar
+        // ══════════════════════════════════════════════════
+        log.divider();
+        log.ok('Implementacion completada.');
+        const confirm2 = await ask('\n  Ejecutar reviewer para validar? (y/N): ', this.rl, this.fi);
+        if (confirm2.toLowerCase() !== 'y') {
+            log.info('Review cancelado por el usuario.');
+            return;
+        }
+        // ══════════════════════════════════════════════════
+        // FASE 3 — Review (Reviewer)
+        // ══════════════════════════════════════════════════
+        let review;
+        while (true) {
+            try {
+                log.section('FASE 3 — Review');
+                review = await this.runReviewer(taskId, plan, progress);
+                break;
+            }
+            catch (err) {
+                log.error(`Reviewer fallo: ${err.message}`);
+                const action = await ask('  Que hacemos? (r=reintentar / c=cancelar): ', this.rl, this.fi);
+                if (action.toLowerCase() === 'r')
+                    continue;
+                log.info('Review cancelado.');
+                return;
+            }
+        }
+        // Si FAIL, volver al programador
+        if (review.verdict === 'FAIL') {
+            log.warn('Review resulto FAIL.');
+            const action = await ask('  Que hacemos? (r=re-implementar / c=cancelar): ', this.rl, this.fi);
+            if (action.toLowerCase() === 'r') {
+                const feedback = await ask('  Feedback adicional para el implementor: ', this.rl, this.fi);
+                // TODO: re-run implementor with feedback
+                log.info(`Feedback: ${feedback}`);
+                log.info('Re-implementacion pendiente — usa /run impl para continuar.');
+            }
+        }
+        // ══════════════════════════════════════════════════
+        // FASE 4 — Reporte final (Coordinador)
+        // ══════════════════════════════════════════════════
+        log.section('FASE 4 — Reporte Final');
+        log.header(`TAREA: ${taskId}`);
+        log.verdict(review.verdict);
+        // Tabla de tokens por fase
+        if (this.phaseTokens.length > 0) {
+            console.log('');
+            console.log('  Tokens por fase:');
+            console.log('  ┌────────────────────┬────────────┬────────────────┬────────────┬──────────┬──────────┐');
+            console.log('  │ Fase               │ CLI        │ Modelo         │ Rol        │ Input    │ Output   │');
+            console.log('  ├────────────────────┼────────────┼────────────────┼────────────┼──────────┼──────────┤');
+            for (const pt of this.phaseTokens) {
+                const phase = pt.phase.padEnd(18);
+                const cli = pt.cli.padEnd(10);
+                const model = pt.model.padEnd(14);
+                const role = pt.role.padEnd(10);
+                const input = String(pt.input).padStart(8);
+                const output = String(pt.output).padStart(8);
+                console.log(`  │ ${phase} │ ${cli} │ ${model} │ ${role} │ ${input} │ ${output} │`);
+            }
+            console.log('  ├────────────────────┼────────────┼────────────────┼────────────┼──────────┼──────────┤');
+            const totalIn = String(this.totalTokens.input_tokens).padStart(8);
+            const totalOut = String(this.totalTokens.output_tokens).padStart(8);
+            console.log(`  │ ${'TOTAL'.padEnd(18)} │ ${''.padEnd(10)} │ ${''.padEnd(14)} │ ${''.padEnd(10)} │ ${totalIn} │ ${totalOut} │`);
+            console.log('  └────────────────────┴────────────┴────────────────┴────────────┴──────────┴──────────┘');
+        }
+        // Generar tokens.md
+        const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
+        let tokensMd = `# Tokens - ${taskId}\n\n| Fase | CLI | Modelo | Rol | Input | Output |\n|------|-----|--------|-----|-------|--------|\n`;
+        for (const pt of this.phaseTokens) {
+            tokensMd += `| ${pt.phase} | ${pt.cli} | ${pt.model} | ${pt.role} | ${pt.input} | ${pt.output} |\n`;
+        }
+        tokensMd += `| **TOTAL** | | | | **${this.totalTokens.input_tokens}** | **${this.totalTokens.output_tokens}** |\n`;
+        await writeFile(path.join(taskDir, 'tokens.md'), tokensMd);
+        log.divider();
+        log.info(`Archivos: .agent/tasks/${taskId}/`);
+        log.info('  plan.json | progress.json | result.md | tokens.md | request.md');
+    }
+}