agent-rev 0.1.0

package/dist/commands/repl.js

@@ -0,0 +1,1167 @@
+import * as readline from 'readline';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as os from 'os';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { CLI_REGISTRY } from '../types.js';
+import { writeJson, ensureDir, readJson, listDir, fileExists } from '../utils/fs.js';
+import { loadAuth, saveAuth, loadCliConfig, saveCliConfig, loadProjectConfig } from '../utils/config.js';
+import { log } from '../utils/logger.js';
+import { AgentEngine } from '../core/engine.js';
+import { qwenAuthStatus, QWEN_AGENT_HOME } from '../utils/qwen-auth.js';
+import { renderWelcomePanel, renderHelpHint, renderSectionBox, renderMultiSectionBox } from '../ui/theme.js';
+import { FixedInput } from '../ui/input.js';
+import { newSession, saveSession } from '../utils/sessions.js';
+// Package info
+function getPkgInfo() {
+    const __filename = new URL(import.meta.url).pathname;
+    const __dirname = path.dirname(__filename);
+    const p = path.join(__dirname, '..', '..', 'package.json');
+    try {
+        const c = JSON.parse(fsSync.readFileSync(p, 'utf-8'));
+        return { name: c.name, version: c.version };
+    }
+    catch {
+        return { name: 'agent-mp', version: '0.1.0' };
+    }
+}
+const pkgInfo = getPkgInfo();
+const CLI_AUTH_COMMANDS = {
+    opencode: 'opencode providers login',
+    qwen: 'qwen auth qwen-oauth',
+    gemini: 'gemini auth login',
+    claude: 'claude auth login',
+    codex: 'codex auth login',
+    cn: 'cn auth login',
+};
+const CLI_AUTH_STATUS = {
+    qwen: 'qwen auth status',
+    claude: 'claude auth status',
+    gemini: 'gemini auth status',
+    codex: 'codex auth status',
+};
+// Check if CLI is installed
+function isCliInstalled(cliName) {
+    try {
+        execSync(`which ${cliName}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkCliAuth(cliName) {
+    // For qwen: use qwenAuthStatus which attempts token refresh + fetches email
+    if (cliName === 'qwen') {
+        const { authenticated, email } = await qwenAuthStatus();
+        return { ok: authenticated, email };
+    }
+    // For other CLIs, use their status command
+    const statusCmd = CLI_AUTH_STATUS[cliName];
+    if (!statusCmd)
+        return { ok: true };
+    try {
+        const out = execSync(`${statusCmd} 2>&1`, { encoding: 'utf-8' });
+        const ok = out.includes('Authentication Method') ||
+            out.includes('Logged in') ||
+            out.includes('authenticated') ||
+            out.includes('✓') ||
+            out.includes('session active');
+        return { ok };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function ask(rl, q) {
+    return new Promise((resolve) => rl.question(q, resolve));
+}
+function arrowSelect(title, options) {
+    return new Promise((resolve) => {
+        const maxVisible = 12;
+        const total = options.length;
+        const visible = Math.min(maxVisible, total);
+        let selected = 0;
+        let offset = 0;
+        let linesDrawn = 0;
+        if (!process.stdin.isTTY) {
+            resolve(options[0]);
+            return;
+        }
+        const clearDrawn = () => {
+            if (linesDrawn > 0) {
+                // Move up linesDrawn lines, clearing each
+                for (let i = 0; i < linesDrawn; i++) {
+                    process.stdout.write('\x1b[1A'); // up one line
+                    process.stdout.write('\x1b[2K'); // clear entire line
+                }
+            }
+        };
+        const draw = () => {
+            clearDrawn();
+            // Scroll offset
+            if (total > maxVisible) {
+                if (selected < offset)
+                    offset = selected;
+                else if (selected >= offset + maxVisible)
+                    offset = selected - maxVisible + 1;
+            }
+            const lines = [];
+            lines.push(chalk.bold(`  ${title}`));
+            lines.push(chalk.dim('  ─────────────────────────────────'));
+            const end = Math.min(offset + maxVisible, total);
+            for (let i = offset; i < end; i++) {
+                if (i === selected) {
+                    lines.push(chalk.cyan(`  ❯ ${options[i]}`));
+                }
+                else {
+                    lines.push(`    ${options[i]}`);
+                }
+            }
+            process.stdout.write(lines.join('\n') + '\n');
+            linesDrawn = lines.length;
+        };
+        // Take raw control of stdin
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdout.write('\x1b[?25l'); // hide cursor
+        draw();
+        const onData = (buf) => {
+            const key = buf.toString();
+            if (key === '\x1b[A' && selected > 0) {
+                selected--;
+                draw();
+            }
+            else if (key === '\x1b[B' && selected < total - 1) {
+                selected++;
+                draw();
+            }
+            else if (key === '\r' || key === '\n') {
+                finish(options[selected]);
+            }
+            else if (key === '\x03') {
+                finish(options[0]);
+            }
+        };
+        const finish = (value) => {
+            process.stdin.removeListener('data', onData);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdout.write('\x1b[?25h'); // show cursor
+            // Replace menu with final selection
+            clearDrawn();
+            console.log(chalk.dim(`  ${title}`) + ' ' + chalk.green(value));
+            // Force flush and reset
+            process.stdout.write('');
+            resolve(value);
+        };
+        process.stdin.on('data', onData);
+    });
+}
+async function selectOption(rl, title, options) {
+    // Pause readline so arrowSelect can take raw control of stdin
+    rl.pause();
+    const result = await arrowSelect(title, options);
+    // Ensure raw mode is completely off
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+    // Reset terminal using stty to ensure clean state
+    try {
+        execSync('stty sane', { stdio: 'ignore' });
+    }
+    catch { }
+    rl.resume();
+    return result;
+}
+function detectInstalledClis() {
+    const installed = [];
+    for (const [name, info] of Object.entries(CLI_REGISTRY)) {
+        try {
+            const p = execSync(`which ${info.command}`, { encoding: 'utf-8' }).trim();
+            installed.push({ name, info, path: p });
+        }
+        catch { }
+    }
+    return installed;
+}
+function detectModels(cliName) {
+    try {
+        switch (cliName) {
+            case 'claude': {
+                const help = execSync('claude --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/'([^']+)'/g)?.map((m) => m.replace(/'/g, '')).filter(Boolean);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['opus', 'sonnet', 'haiku'];
+            }
+            case 'qwen': return ['coder-model'];
+            case 'gemini': {
+                const help = execSync('gemini --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/'([^']+)'/g)?.map((m) => m.replace(/'/g, '')).filter(Boolean);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['gemini-2.5-pro', 'gemini-2.5-flash'];
+            }
+            case 'codex': {
+                const help = execSync('codex --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/-m\s+(\S+)/g)?.map((m) => m.split(/\s+/)[1]);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['gpt-4o'];
+            }
+            case 'cn': return ['default (hub)'];
+            case 'opencode': {
+                const out = execSync('opencode models 2>/dev/null', { encoding: 'utf-8' });
+                return out.trim().split('\n').filter(Boolean);
+            }
+            case 'aider': return ['default'];
+            default: return ['default'];
+        }
+    }
+    catch {
+        return ['default'];
+    }
+}
+function buildCmd(cliName, model) {
+    const info = CLI_REGISTRY[cliName];
+    if (!info)
+        return `${cliName} -m ${model}`;
+    if (cliName === 'codex')
+        return `codex exec -m ${model}`;
+    if (cliName === 'cn' && model === 'default (hub)')
+        return 'cn --auto -p';
+    if (cliName === 'opencode')
+        return `opencode run -m ${model}`;
+    const extra = info.extraFlags ? ` ${info.extraFlags}` : '';
+    const promptFlag = info.promptFlag ? ` ${info.promptFlag}` : '';
+    return `${info.command} ${info.modelFlag} ${model}${extra}${promptFlag}`.trim();
+}
+async function cmdLogin(rl) {
+    console.log(chalk.bold.cyan('\n  Login\n'));
+    // If active provider is Qwen, do fresh OAuth for corporate account
+    const auth = await loadAuth();
+    if (auth.activeProvider === 'qwen') {
+        console.log(chalk.dim('  Qwen login for corporate account\n'));
+        console.log(chalk.dim('  Corporate credentials stored in: ~/.agent-cli/\n'));
+        console.log(chalk.yellow('  IMPORTANT: Use your CORPORATE account when prompted.\n'));
+        console.log(chalk.yellow('  The browser will open. If you see your personal account,'));
+        console.log(chalk.yellow('  log out and sign in with your corporate account.\n'));
+        try {
+            const { execSync } = await import('child_process');
+            const personalCreds = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
+            const corporateCreds = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+            // Backup personal credentials
+            let personalBackup = null;
+            if (await fileExists(personalCreds)) {
+                personalBackup = await fs.readFile(personalCreds, 'utf-8');
+                await fs.unlink(personalCreds);
+            }
+            // Remove corporate creds to force fresh login
+            await fs.unlink(corporateCreds).catch(() => { });
+            // Login with Qwen CLI - forces fresh login since personal creds are backed up
+            execSync('qwen auth qwen-oauth', { stdio: 'inherit' });
+            // Copy NEW credentials to corporate directory
+            if (await fileExists(personalCreds)) {
+                const newCreds = await fs.readFile(personalCreds, 'utf-8');
+                await fs.writeFile(corporateCreds, newCreds);
+            }
+            // Restore personal credentials
+            if (personalBackup) {
+                await fs.writeFile(personalCreds, personalBackup);
+            }
+            const emailInput = await ask(rl, '  Your email (optional, for display): ');
+            auth.entries = auth.entries.filter((e) => e.provider !== 'qwen');
+            auth.entries.push({ provider: 'qwen', method: 'oauth', ...(emailInput.trim() ? { email: emailInput.trim() } : {}) });
+            await saveAuth(auth);
+            console.log(chalk.green('  Corporate auth recorded'));
+            return true;
+        }
+        catch (err) {
+            console.log(chalk.red('  Login failed: ' + err.message));
+            return false;
+        }
+    }
+    // For other providers, use their CLI
+    console.log(chalk.dim('  Available providers:'));
+    for (const [id, cmd] of Object.entries(CLI_AUTH_COMMANDS)) {
+        const installed = isCliInstalled(id) ? chalk.green('✓') : chalk.red('✗');
+        console.log(chalk.dim(`    ${installed} ${id} - uses: ${cmd}`));
+    }
+    const provider = await ask(rl, '\n  Provider: ');
+    const authCmd = CLI_AUTH_COMMANDS[provider.trim()];
+    if (!authCmd) {
+        console.log(chalk.red(`  No auth command for: ${provider}`));
+        return false;
+    }
+    console.log(chalk.blue(`  Running: ${authCmd}`));
+    console.log(chalk.dim('  (This will open your browser for login)\n'));
+    try {
+        execSync(authCmd, { stdio: 'inherit' });
+        const auth = await loadAuth();
+        auth.entries = auth.entries.filter((e) => e.provider !== provider.trim());
+        auth.entries.push({ provider: provider.trim(), method: 'oauth' });
+        auth.activeProvider = provider.trim();
+        await saveAuth(auth);
+        console.log(chalk.green(`  Auth recorded for ${provider}`));
+        return true;
+    }
+    catch {
+        console.log(chalk.red('  Login failed.'));
+        return false;
+    }
+}
+async function cmdSetup(rl) {
+    console.log(chalk.bold.cyan('\n  Setup Wizard\n'));
+    const installed = detectInstalledClis();
+    if (installed.length === 0) {
+        console.log(chalk.red('  No CLIs detected. Install at least one.'));
+        return;
+    }
+    console.log(chalk.bold('  Detected CLIs:'));
+    for (const c of installed)
+        log.cliList(c.name, c.path);
+    console.log(chalk.bold('\n  Multi-CLI Configuration'));
+    const cliConfig = await loadCliConfig();
+    const roles = ['orchestrator', 'implementor', 'reviewer'];
+    for (const role of roles) {
+        console.log(chalk.yellow(`\n  ${role.toUpperCase()}`));
+        const cliName = await selectOption(rl, `CLI for ${role}:`, installed.map((c) => c.name));
+        if (!CLI_REGISTRY[cliName]) {
+            console.log(chalk.red(`  Unknown CLI: ${cliName}`));
+            return;
+        }
+        const models = detectModels(cliName);
+        const model = await selectOption(rl, `Model for ${cliName}:`, models);
+        cliConfig.roles[role] = { cli: cliName, model };
+        // Ask about fallback for this role
+        const fbAnswer = await ask(rl, `  Configure fallback for ${role}? (y/N): `);
+        if (fbAnswer.toLowerCase() === 'y') {
+            const otherClis = installed.filter((c) => c.name !== cliName);
+            if (otherClis.length === 0) {
+                console.log(chalk.dim('  No other CLIs available for fallback.'));
+            }
+            else {
+                const fbCliName = await selectOption(rl, `Fallback CLI for ${role}:`, otherClis.map((c) => c.name));
+                const fbModels = detectModels(fbCliName);
+                const fbModel = await selectOption(rl, `Fallback model for ${fbCliName}:`, fbModels);
+                cliConfig.roles[role].fallbackCli = fbCliName;
+                cliConfig.roles[role].fallbackModel = fbModel;
+            }
+        }
+    }
+    const delib = await ask(rl, '\n  Enable deliberation? (y/N): ');
+    if (delib.toLowerCase() === 'y') {
+        cliConfig.deliberation.enabled = true;
+        const rounds = await ask(rl, '  Max rounds [4]: ');
+        cliConfig.deliberation.max_rounds = parseInt(rounds) || 4;
+        console.log(chalk.yellow('\n  PROPOSER'));
+        cliConfig.roles.proposer = { cli: (await ask(rl, '  CLI: ')).trim(), model: (await ask(rl, '  Model: ')).trim() };
+        console.log(chalk.yellow('\n  CRITIC'));
+        cliConfig.roles.critic = { cli: (await ask(rl, '  CLI: ')).trim(), model: (await ask(rl, '  Model: ')).trim() };
+    }
+    // Global fallback
+    console.log(chalk.yellow('\n  FALLBACK GLOBAL'));
+    console.log(chalk.dim('  Si un rol Y su fallback individual fallan, se usa este CLI como ultimo recurso.'));
+    const globalFbAnswer = await ask(rl, '  Configurar fallback global? (y/N): ');
+    if (globalFbAnswer.toLowerCase() === 'y') {
+        const fbCliName = await selectOption(rl, 'Fallback global CLI:', installed.map((c) => c.name));
+        const fbModels = detectModels(fbCliName);
+        const fbModel = await selectOption(rl, `Fallback global model for ${fbCliName}:`, fbModels);
+        cliConfig.fallback_global = { cli: fbCliName, model: fbModel };
+    }
+    else {
+        delete cliConfig.fallback_global;
+    }
+    await saveCliConfig(cliConfig);
+    const projectDir = process.cwd();
+    const projectName = path.basename(projectDir);
+    // Helper to build a CliRole with optional fallback
+    const buildRoleWithFallback = (roleKey) => {
+        const r = cliConfig.roles[roleKey];
+        const cli = r?.cli || '';
+        const model = r?.model || '';
+        const base = { cli, model, cmd: buildCmd(cli, model) };
+        if (r?.fallbackCli && r?.fallbackModel) {
+            return { ...base, fallback: { cli: r.fallbackCli, model: r.fallbackModel, cmd: buildCmd(r.fallbackCli, r.fallbackModel) } };
+        }
+        return base;
+    };
+    const agentConfig = {
+        project: projectName,
+        description: '',
+        stack: 'generic',
+        roles: {
+            orchestrator: buildRoleWithFallback('orchestrator'),
+            implementor: buildRoleWithFallback('implementor'),
+            reviewer: buildRoleWithFallback('reviewer'),
+        },
+        deliberation: cliConfig.deliberation.enabled ? {
+            proposer: { cli: cliConfig.roles.proposer?.cli || '', model: cliConfig.roles.proposer?.model || '', cmd: buildCmd(cliConfig.roles.proposer?.cli || '', cliConfig.roles.proposer?.model || '') },
+            critic: { cli: cliConfig.roles.critic?.cli || '', model: cliConfig.roles.critic?.model || '', cmd: buildCmd(cliConfig.roles.critic?.cli || '', cliConfig.roles.critic?.model || '') },
+            max_rounds: cliConfig.deliberation.max_rounds,
+            stop_on: 'ACCEPT',
+            output_dir: '.agent/tasks/{ID}/debate/',
+        } : undefined,
+        fallback_global: cliConfig.fallback_global ? { cli: cliConfig.fallback_global.cli, model: cliConfig.fallback_global.model, cmd: buildCmd(cliConfig.fallback_global.cli, cliConfig.fallback_global.model) } : undefined,
+        structure: { approved_dirs: ['.'], forbidden_dirs: ['node_modules', 'dist', '.git'] },
+    };
+    await ensureDir(path.join(projectDir, '.agent'));
+    await writeJson(path.join(projectDir, '.agent', 'config.json'), agentConfig);
+    console.log(chalk.green('  .agent/config.json generated'));
+    const templates = {
+        '.agent/INDEX.md': `# ${projectName} - Agent Entry Point\n\n## Navegacion por rol\n| Si sos... | Lee primero... |\n|-----------|----------------|\n| ORCHESTRATOR | .agent/rules/workflow.md |\n| IMPLEMENTOR | .agent/tasks/{ID}/plan.json |\n| REVIEWER | .agent/rules/workflow.md |\n`,
+        '.agent/rules/workflow.md': '# Agent Workflow Contract\n\n## REGLA #1 - Separacion de roles\nUn rol NUNCA ejecuta acciones de otro rol.\n\n## Roles\n- ORCHESTRATOR: planifica\n- IMPLEMENTOR: ejecuta\n- REVIEWER: valida\n',
+        '.agent/rules/structure.md': '# Estructura\n\n## Aprobados\n.\n\n## Prohibidos\nnode_modules, dist, .git\n',
+        '.agent/rules/patterns.md': '# Patrones\n\n- kebab-case: archivos\n- PascalCase: clases\n- camelCase: variables\n',
+        '.agent/context/architecture.md': '# Arquitectura - NIVEL 0\n\n| Servicio | Stack | Puerto | Detalle |\n|----------|-------|--------|---------|\n| - | - | - | - |\n',
+        '.agent/AGENT.md': '# Sub-Agentes\n\n1. Lee .agent/INDEX.md\n2. Lee .agent/rules/workflow.md\n3. Actua SOLO dentro de tu rol\n',
+    };
+    for (const [fp, content] of Object.entries(templates)) {
+        await fs.mkdir(path.join(projectDir, path.dirname(fp)), { recursive: true });
+        await fs.writeFile(path.join(projectDir, fp), content, 'utf-8');
+    }
+    console.log(chalk.green('  Templates generated'));
+    console.log(chalk.green('\n  Setup complete!'));
+}
+async function cmdConfigMulti(rl) {
+    console.log(chalk.bold.cyan('\n  Multi-CLI Configuration\n'));
+    const installed = detectInstalledClis();
+    if (installed.length === 0) {
+        console.log(chalk.red('  No CLIs detected.'));
+        return;
+    }
+    console.log(chalk.bold('  Detected CLIs:'));
+    for (const c of installed)
+        log.cliList(c.name, c.path);
+    const cliConfig = await loadCliConfig();
+    const roles = ['orchestrator', 'implementor', 'reviewer'];
+    for (const role of roles) {
+        const current = cliConfig.roles[role];
+        const fbInfo = current?.fallbackCli ? ` | fb: ${current.fallbackCli}/${current.fallbackModel}` : '';
+        console.log(chalk.yellow(`\n  ${role.toUpperCase()}${current ? ` [current: ${current.cli}/${current.model}${fbInfo}]` : ''}`));
+        const cliName = await selectOption(rl, `CLI for ${role}:`, installed.map((c) => c.name));
+        const models = detectModels(cliName);
+        const model = await selectOption(rl, `Model for ${cliName}:`, models);
+        cliConfig.roles[role] = { cli: cliName, model };
+        // Ask about fallback for this role
+        const fbAnswer = await ask(rl, `  Configure fallback for ${role}? (y/N): `);
+        if (fbAnswer.toLowerCase() === 'y') {
+            const otherClis = installed.filter((c) => c.name !== cliName);
+            if (otherClis.length === 0) {
+                console.log(chalk.dim('  No other CLIs available for fallback.'));
+            }
+            else {
+                const fbCliName = await selectOption(rl, `Fallback CLI for ${role}:`, otherClis.map((c) => c.name));
+                const fbModels = detectModels(fbCliName);
+                const fbModel = await selectOption(rl, `Fallback model for ${fbCliName}:`, fbModels);
+                cliConfig.roles[role].fallbackCli = fbCliName;
+                cliConfig.roles[role].fallbackModel = fbModel;
+            }
+        }
+        else {
+            delete cliConfig.roles[role].fallbackCli;
+            delete cliConfig.roles[role].fallbackModel;
+        }
+    }
+    // Global fallback
+    const currentGlobalFb = cliConfig.fallback_global;
+    console.log(chalk.yellow(`\n  FALLBACK GLOBAL${currentGlobalFb ? ` [current: ${currentGlobalFb.cli}/${currentGlobalFb.model}]` : ''}`));
+    console.log(chalk.dim('  Si un rol Y su fallback individual fallan, se usa este CLI como ultimo recurso.'));
+    const globalFbAnswer = await ask(rl, '  Configurar fallback global? (y/N): ');
+    if (globalFbAnswer.toLowerCase() === 'y') {
+        const fbCliName = await selectOption(rl, 'Fallback global CLI:', installed.map((c) => c.name));
+        const fbModels = detectModels(fbCliName);
+        const fbModel = await selectOption(rl, `Fallback global model for ${fbCliName}:`, fbModels);
+        cliConfig.fallback_global = { cli: fbCliName, model: fbModel };
+    }
+    else {
+        delete cliConfig.fallback_global;
+    }
+    await saveCliConfig(cliConfig);
+    const projectDir = process.cwd();
+    const projectName = path.basename(projectDir);
+    // Helper to build a CliRole with optional fallback
+    const buildRoleWithFallback = (roleKey) => {
+        const r = cliConfig.roles[roleKey];
+        const cli = r?.cli || '';
+        const model = r?.model || '';
+        const base = { cli, model, cmd: buildCmd(cli, model) };
+        if (r?.fallbackCli && r?.fallbackModel) {
+            return { ...base, fallback: { cli: r.fallbackCli, model: r.fallbackModel, cmd: buildCmd(r.fallbackCli, r.fallbackModel) } };
+        }
+        return base;
+    };
+    const agentConfig = {
+        project: projectName,
+        description: '',
+        stack: 'generic',
+        roles: {
+            orchestrator: buildRoleWithFallback('orchestrator'),
+            implementor: buildRoleWithFallback('implementor'),
+            reviewer: buildRoleWithFallback('reviewer'),
+        },
+        deliberation: cliConfig.deliberation?.enabled ? {
+            proposer: { cli: cliConfig.roles.proposer?.cli || '', model: cliConfig.roles.proposer?.model || '', cmd: buildCmd(cliConfig.roles.proposer?.cli || '', cliConfig.roles.proposer?.model || '') },
+            critic: { cli: cliConfig.roles.critic?.cli || '', model: cliConfig.roles.critic?.model || '', cmd: buildCmd(cliConfig.roles.critic?.cli || '', cliConfig.roles.critic?.model || '') },
+            max_rounds: cliConfig.deliberation.max_rounds,
+            stop_on: 'ACCEPT',
+            output_dir: '.agent/tasks/{ID}/debate/',
+        } : undefined,
+        fallback_global: cliConfig.fallback_global ? { cli: cliConfig.fallback_global.cli, model: cliConfig.fallback_global.model, cmd: buildCmd(cliConfig.fallback_global.cli, cliConfig.fallback_global.model) } : undefined,
+        structure: { approved_dirs: ['.'], forbidden_dirs: ['node_modules', 'dist', '.git'] },
+    };
+    await ensureDir(path.join(projectDir, '.agent'));
+    await writeJson(path.join(projectDir, '.agent', 'config.json'), agentConfig);
+    console.log(chalk.green('\n  Config updated'));
+}
+async function cmdConfigOneRole(rl, role) {
+    const installed = detectInstalledClis();
+    if (installed.length === 0) {
+        console.log(chalk.red('  No CLIs detected.'));
+        return;
+    }
+    const cliConfig = await loadCliConfig();
+    const current = cliConfig.roles[role];
+    console.log(chalk.yellow(`\n  ${role.toUpperCase()}${current ? ` [current: ${current.cli}/${current.model}]` : ''}`));
+    const cliName = await selectOption(rl, `CLI for ${role}:`, installed.map((c) => c.name));
+    const models = detectModels(cliName);
+    const model = await selectOption(rl, `Model for ${cliName}:`, models);
+    cliConfig.roles[role] = { cli: cliName, model };
+    await saveCliConfig(cliConfig);
+    // Regenerate .agent/config.json if it exists
+    const projectDir = process.cwd();
+    const projectName = path.basename(projectDir);
+    const r = cliConfig.roles;
+    const buildRoleWithFallback = (roleKey) => {
+        const rr = r[roleKey];
+        const cli = rr?.cli || '';
+        const mod = rr?.model || '';
+        const base = { cli, model: mod, cmd: buildCmd(cli, mod) };
+        if (rr?.fallbackCli && rr?.fallbackModel) {
+            return { ...base, fallback: { cli: rr.fallbackCli, model: rr.fallbackModel, cmd: buildCmd(rr.fallbackCli, rr.fallbackModel) } };
+        }
+        return base;
+    };
+    const agentConfig = {
+        project: projectName,
+        description: '',
+        stack: 'generic',
+        roles: {
+            orchestrator: buildRoleWithFallback('orchestrator'),
+            implementor: buildRoleWithFallback('implementor'),
+            reviewer: buildRoleWithFallback('reviewer'),
+            ...(r.explorer ? { explorer: { cli: r.explorer.cli, model: r.explorer.model, cmd: buildCmd(r.explorer.cli, r.explorer.model) } } : {}),
+        },
+        deliberation: cliConfig.deliberation?.enabled ? {
+            proposer: { cli: r.proposer?.cli || '', model: r.proposer?.model || '', cmd: buildCmd(r.proposer?.cli || '', r.proposer?.model || '') },
+            critic: { cli: r.critic?.cli || '', model: r.critic?.model || '', cmd: buildCmd(r.critic?.cli || '', r.critic?.model || '') },
+            max_rounds: cliConfig.deliberation.max_rounds,
+            stop_on: 'ACCEPT',
+            output_dir: '.agent/tasks/{ID}/debate/',
+        } : undefined,
+        fallback_global: cliConfig.fallback_global ? { cli: cliConfig.fallback_global.cli, model: cliConfig.fallback_global.model, cmd: buildCmd(cliConfig.fallback_global.cli, cliConfig.fallback_global.model) } : undefined,
+        structure: { approved_dirs: ['.'], forbidden_dirs: ['node_modules', 'dist', '.git'] },
+    };
+    await ensureDir(path.join(projectDir, '.agent'));
+    await writeJson(path.join(projectDir, '.agent', 'config.json'), agentConfig);
+    console.log(chalk.green(`\n  ✓ ${role} updated → ${cliName}/${model}`));
+}
+async function cmdStatus(fi) {
+    const cliConfig = await loadCliConfig();
+    const auth = await loadAuth();
+    const sections = [];
+    sections.push({
+        title: 'Auth',
+        rows: [
+            { key: 'Providers', value: auth.entries.map((e) => `${e.provider} (${e.method})`).join(', ') || 'none' },
+            ...(auth.activeProvider ? [{ key: 'Active', value: auth.activeProvider }] : []),
+        ],
+    });
+    const roleRows = [];
+    try {
+        const projectConfig = await loadProjectConfig(process.cwd());
+        for (const [role, r] of Object.entries(projectConfig.roles)) {
+            if (!r)
+                continue;
+            const fb = r.fallback ? ` → fallback: ${r.fallback.cmd}` : '';
+            roleRows.push({ key: role, value: r.cmd + fb });
+        }
+    }
+    catch {
+        // fallback to cliConfig if no project config
+        for (const [role, r] of Object.entries(cliConfig.roles)) {
+            const fb = r.fallbackCli ? ` → ${r.fallbackCli}/${r.fallbackModel}` : '';
+            roleRows.push({ key: role, value: `${r.cli} -m ${r.model}${fb}` });
+        }
+    }
+    if (cliConfig.fallback_global) {
+        roleRows.push({ key: 'global fallback', value: `${cliConfig.fallback_global.cli}/${cliConfig.fallback_global.model}` });
+    }
+    sections.push({ title: 'Roles — full cmd', rows: roleRows });
+    const dir = process.cwd();
+    try {
+        const config = await loadProjectConfig(dir);
+        const projectRows = [
+            { key: 'Name', value: config.project },
+            { key: 'Stack', value: config.stack },
+        ];
+        const tasksDir = path.join(dir, '.agent', 'tasks');
+        const tasks = await listDir(tasksDir);
+        if (tasks.length > 0) {
+            const taskList = tasks.sort().reverse().slice(0, 5).map((t) => {
+                try {
+                    const progress = JSON.parse(fsSync.readFileSync(path.join(tasksDir, t, 'progress.json'), 'utf-8'));
+                    const s = progress?.status || '?';
+                    const icon = s === 'completed' ? '✓' : s === 'planned' ? '○' : '✗';
+                    return `${icon} ${t}`;
+                }
+                catch {
+                    return `? ${t}`;
+                }
+            }).join('  ');
+            projectRows.push({ key: 'Tasks', value: `${tasks.length} total  ${taskList}` });
+        }
+        sections.push({ title: 'Project', rows: projectRows });
+    }
+    catch {
+        sections.push({ title: 'Project', rows: [{ key: 'Config', value: 'not found — run /setup' }] });
+    }
+    fi.println('');
+    fi.println(renderMultiSectionBox(sections));
+    fi.println('');
+}
+async function cmdModels(provider, fi) {
+    const installed = detectInstalledClis();
+    if (provider) {
+        const info = CLI_REGISTRY[provider];
+        if (!info) {
+            fi.println(chalk.red(`  Unknown: ${provider}`));
+            return;
+        }
+        const models = detectModels(provider);
+        fi.println(chalk.bold(`\n  ${info.name} models:`));
+        for (const m of models)
+            fi.println(`    ${m}`);
+    }
+    else {
+        for (const c of installed) {
+            const models = detectModels(c.name);
+            fi.println(chalk.bold(`\n  ${c.name} (${c.path}):`));
+            for (const m of models.slice(0, 10))
+                fi.println(`    ${m}`);
+            if (models.length > 10)
+                fi.println(chalk.dim(`    ... and ${models.length - 10} more`));
+        }
+    }
+    fi.println('');
+}
+async function cmdAuthStatus(fi) {
+    const auth = await loadAuth();
+    const rows = auth.entries.length === 0
+        ? [{ key: 'Status', value: 'Not logged in' }]
+        : auth.entries.map((e) => ({
+            key: e.provider,
+            value: `${e.method}${e.provider === auth.activeProvider ? '  (active)' : ''}${e.email ? `  ${e.email}` : ''}`,
+        }));
+    fi.println(renderSectionBox('Auth Status', rows));
+}
+function cmdHelp(fi) {
+    const commands = [
+        { key: '/setup', value: 'Full interactive setup wizard' },
+        { key: '/setup orch', value: 'Reconfigure orchestrator only' },
+        { key: '/setup impl', value: 'Reconfigure implementor only' },
+        { key: '/setup rev', value: 'Reconfigure reviewer only' },
+        { key: '/setup explorer', value: 'Reconfigure explorer only' },
+        { key: '/config-multi', value: 'Reconfigure all agents at once' },
+        { key: '/status', value: 'Show current configuration and tasks' },
+        { key: '/run <task>', value: 'Full cycle: orchestrator → implementor → reviewer' },
+        { key: '/run orch <task>', value: 'Run only orchestrator' },
+        { key: '/run impl <id>', value: 'Run only implementor' },
+        { key: '/run rev <id>', value: 'Run only reviewer' },
+        { key: '/models', value: 'List models for all installed CLIs' },
+        { key: '/models <cli>', value: 'List models for a specific CLI' },
+        { key: '/login', value: 'Login (Qwen OAuth or CLI auth)' },
+        { key: '/logout', value: 'Logout and clear credentials' },
+        { key: '/auth-status', value: 'Show authentication status' },
+        { key: '/tasks', value: 'List all tasks' },
+        { key: '/clear', value: 'Clear the screen' },
+        { key: '/help', value: 'Show this help' },
+        { key: '/exit', value: 'Exit agent-mp' },
+    ];
+    fi.println(renderSectionBox('Commands', commands));
+}
+async function cmdTasks(fi) {
+    const dir = process.cwd();
+    const tasksDir = path.join(dir, '.agent', 'tasks');
+    const tasks = await listDir(tasksDir);
+    if (tasks.length === 0) {
+        fi.println(renderSectionBox('Tasks', [{ key: '—', value: 'No tasks yet' }]));
+        return;
+    }
+    const rows = [];
+    for (const t of tasks.sort().reverse()) {
+        try {
+            const progress = await readJson(path.join(tasksDir, t, 'progress.json'));
+            const s = progress?.status || 'unknown';
+            const icon = s === 'completed' ? '✓' : s === 'planned' ? '○' : '✗';
+            rows.push({ key: `${icon} ${t}`, value: s });
+        }
+        catch {
+            rows.push({ key: `? ${t}`, value: 'unknown' });
+        }
+    }
+    fi.println(renderSectionBox('Tasks', rows));
+}
+// Coordinator CLI for clarification phase
+let gCoordinatorCmd = '';
+/**
+ * Shared coordinator setup: detect CLIs, pick coordinator, check auth.
+ * Returns { coordinatorCmd, activeCli, installed, rl } or null if setup failed.
+ */
+export async function initCoordinator() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    // Step 1: Detect installed CLIs
+    const installed = detectInstalledClis();
+    if (installed.length === 0) {
+        console.log(chalk.red('  No CLIs detected. Install at least one: qwen, claude, gemini, codex'));
+        rl.close();
+        return null;
+    }
+    // Step 2: Pick coordinator
+    const auth = await loadAuth();
+    const currentAuth = auth.activeProvider;
+    let activeCli = installed.find((c) => c.name === currentAuth);
+    // Check if corporate credentials exist for qwen
+    const hasCorporateCreds = (() => {
+        if (currentAuth === 'qwen') {
+            const corporateCreds = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+            try {
+                const stats = fsSync.statSync(corporateCreds);
+                return stats.isFile();
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    })();
+    // If no active provider OR no corporate credentials, show selector
+    if (!activeCli || !hasCorporateCreds) {
+        // No coordinator configured - show selector
+        const qwenInstalled = installed.find((c) => c.name === 'qwen');
+        if (!qwenInstalled) {
+            console.log(chalk.red('  Qwen CLI not found. Install with: npm install -g @qwen-code/qwen-code'));
+            rl.close();
+            return null;
+        }
+        // Show selector (even if only one option)
+        const selectedName = await selectOption(rl, 'Select AI service for coordinator:', ['qwen']);
+        activeCli = qwenInstalled;
+        auth.activeProvider = 'qwen';
+        auth.entries = auth.entries.filter((e) => e.provider !== 'qwen');
+        auth.entries.push({ provider: 'qwen', method: 'oauth' });
+        await saveAuth(auth);
+    }
+    // If activeCli is already set, skip selection and use existing coordinator
+    console.log(chalk.dim(`\n  Checking ${activeCli.name} auth...`));
+    let authResult = await checkCliAuth(activeCli.name);
+    if (!authResult.ok) {
+        console.log(chalk.yellow(`  ${activeCli.name} session not found.`));
+        console.log(chalk.blue(`  Opening browser for ${activeCli.name} login...`));
+        console.log(chalk.dim('  (Use your corporate account)\n'));
+        const authCmd = CLI_AUTH_COMMANDS[activeCli.name];
+        if (authCmd) {
+            try {
+                // For qwen, do corporate login flow
+                if (activeCli.name === 'qwen') {
+                    const personalCreds = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
+                    const corporateCreds = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+                    let personalBackup = null;
+                    if (await fileExists(personalCreds)) {
+                        personalBackup = await fs.readFile(personalCreds, 'utf-8');
+                        await fs.unlink(personalCreds);
+                    }
+                    await fs.unlink(corporateCreds).catch(() => { });
+                    execSync('qwen auth qwen-oauth', { stdio: 'inherit' });
+                    if (await fileExists(personalCreds)) {
+                        const newCreds = await fs.readFile(personalCreds, 'utf-8');
+                        await fs.writeFile(corporateCreds, newCreds);
+                    }
+                    if (personalBackup) {
+                        await fs.writeFile(personalCreds, personalBackup);
+                    }
+                    authResult = await checkCliAuth(activeCli.name);
+                }
+                else {
+                    execSync(authCmd, { stdio: 'inherit' });
+                    authResult = await checkCliAuth(activeCli.name);
+                }
+                if (authResult.ok) {
+                    console.log(chalk.green(`  ${activeCli.name} authenticated successfully\n`));
+                }
+                else {
+                    console.log(chalk.red(`  ${activeCli.name} auth failed. Try /login.\n`));
+                }
+            }
+            catch {
+                console.log(chalk.yellow(`  Login interrupted. Type /login to retry.\n`));
+            }
+        }
+    }
+    else {
+        const emailStr = authResult.email ? chalk.dim(` (${authResult.email})`) : '';
+        console.log(chalk.green(`  ${activeCli.name} session active${emailStr}\n`));
+    }
+    // Save email to auth store if we have it
+    if (authResult.email) {
+        const auth2 = await loadAuth();
+        const entry = auth2.entries.find((e) => e.provider === activeCli.name);
+        if (entry)
+            entry.email = authResult.email;
+        await saveAuth(auth2);
+    }
+    // Build coordinator command using the ACTIVE CLI (not orchestrator)
+    // The coordinator converses naturally using whatever CLI is active (qwen, claude, etc.)
+    const activeModel = detectModels(activeCli.name)[0] || 'default';
+    gCoordinatorCmd = buildCmd(activeCli.name, activeModel);
+    return { coordinatorCmd: gCoordinatorCmd, activeCli, installed, rl };
+}
+/** REPL mode — interactive loop */
+export async function runRepl(resumeSession) {
+    const init = await initCoordinator();
+    if (!init)
+        return;
+    const { activeCli } = init;
+    const rl = init.rl;
+    const session = resumeSession ?? newSession(process.cwd());
+    // Show project status and FORCE role configuration if missing
+    let hasRoles = false;
+    let welcomeRoles;
+    let welcomeProject = path.basename(process.cwd());
+    let welcomeStack = 'generic';
+    try {
+        const config = await loadProjectConfig(process.cwd());
+        welcomeProject = config.project;
+        welcomeStack = config.stack;
+        if (config.roles?.orchestrator?.cli && config.roles?.implementor?.cli && config.roles?.reviewer?.cli) {
+            hasRoles = true;
+            welcomeRoles = {
+                orchestrator: `${config.roles.orchestrator.cli}/${config.roles.orchestrator.model}`,
+                implementor: `${config.roles.implementor.cli}/${config.roles.implementor.model}`,
+                reviewer: `${config.roles.reviewer.cli}/${config.roles.reviewer.model}`,
+            };
+        }
+    }
+    catch { }
+    if (!hasRoles) {
+        console.log(chalk.yellow('\n  Todos los roles deben estar configurados antes de trabajar.'));
+        console.log(chalk.yellow('  Configurando roles ahora...\n'));
+        await cmdConfigMulti(rl);
+        // Re-check
+        try {
+            const config = await loadProjectConfig(process.cwd());
+            welcomeProject = config.project;
+            welcomeStack = config.stack;
+            if (config.roles?.orchestrator?.cli && config.roles?.implementor?.cli && config.roles?.reviewer?.cli) {
+                hasRoles = true;
+                welcomeRoles = {
+                    orchestrator: `${config.roles.orchestrator.cli}/${config.roles.orchestrator.model}`,
+                    implementor: `${config.roles.implementor.cli}/${config.roles.implementor.model}`,
+                    reviewer: `${config.roles.reviewer.cli}/${config.roles.reviewer.model}`,
+                };
+            }
+        }
+        catch { }
+        if (!hasRoles) {
+            console.log(chalk.red('\n  Error: roles no configurados. Saliendo.'));
+            rl.close();
+            return;
+        }
+    }
+    // Print welcome panel + hint (before fixed input takes over)
+    process.stdout.write(renderWelcomePanel({
+        version: `${pkgInfo.name} v${pkgInfo.version}`,
+        cliName: pkgInfo.name,
+        activeModel: activeCli.name,
+        user: process.env.USER || process.env.LOGNAME || 'user',
+        project: welcomeProject,
+        stack: welcomeStack,
+        roles: welcomeRoles,
+    }) + '\n');
+    process.stdout.write(renderHelpHint() + '\n\n');
+    // Fixed-bottom input — owns the last 3 terminal rows permanently
+    const fi = new FixedInput();
+    fi.setup();
+    // If resuming, print past conversation history
+    if (resumeSession && resumeSession.messages.length > 0) {
+        const date = new Date(resumeSession.createdAt).toLocaleString();
+        fi.println(chalk.dim(`  ─── Resuming session from ${date} (${resumeSession.messages.length} messages) ───`));
+        for (const msg of resumeSession.messages) {
+            if (msg.role === 'user') {
+                const lines = msg.content.split('\n').filter(l => l.trim());
+                for (let i = 0; i < lines.length; i++) {
+                    const prefix = i === 0 ? chalk.dim('usuario: ') : '         ';
+                    fi.println(`${prefix}${chalk.white(lines[i])}`);
+                }
+            }
+            else {
+                fi.println(chalk.cyan(msg.content.split('\n').map(l => `  ${l}`).join('\n')));
+            }
+        }
+        fi.println(chalk.dim('  ─── Continue below ───'));
+        fi.println('');
+    }
+    // Helper: run a wizard command that needs readline (suspends fixed input)
+    const withRl = async (fn) => {
+        const resume = fi.suspend();
+        try {
+            await fn(rl);
+        }
+        finally {
+            resume();
+        }
+    };
+    // Main REPL loop
+    let firstMessage = true;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const line = await fi.readLine();
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Show coordinator header before the first user message
+        if (firstMessage && !trimmed.startsWith('/')) {
+            firstMessage = false;
+            try {
+                const dir = process.cwd();
+                const config = await loadProjectConfig(dir);
+                if (config.roles?.orchestrator?.cli) {
+                    fi.println('');
+                    fi.println(chalk.bold.cyan('═'.repeat(46)));
+                    fi.println(chalk.bold.cyan(`  COORDINADOR — ${config.project}`));
+                    fi.println(chalk.bold.cyan('═'.repeat(46)));
+                    fi.println(chalk.blue(`  → Rol: COORDINADOR (solo orquesta, nunca ejecuta)`));
+                    fi.println(chalk.dim('  ' + '─'.repeat(42)));
+                }
+            }
+            catch { }
+        }
+        // Show user message in the scroll area (chat style, right-aligned per line)
+        const userLines = trimmed.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}`);
+        }
+        if (!trimmed.startsWith('/')) {
+            session.messages.push({ role: 'user', content: trimmed, ts: new Date().toISOString() });
+            await saveSession(session);
+            try {
+                const dir = process.cwd();
+                const config = await loadProjectConfig(dir);
+                if (!config.roles?.orchestrator?.cli) {
+                    fi.println(chalk.red('  No roles configured. Run /config-multi first.'));
+                }
+                else {
+                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                    await engine.runFullCycle(trimmed);
+                    session.messages.push({ role: 'agent', content: `[task cycle completed for: ${trimmed}]`, ts: new Date().toISOString() });
+                    await saveSession(session);
+                }
+            }
+            catch (err) {
+                fi.println(chalk.red(`  Error: ${err.message}`));
+            }
+            fi.redrawBox();
+            continue;
+        }
+        const parts = trimmed.slice(1).split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        try {
+            switch (cmd) {
+                case 'setup': {
+                    const sub = args[0]?.toLowerCase();
+                    const roleMap = {
+                        orch: 'orchestrator', impl: 'implementor', rev: 'reviewer',
+                        explorer: 'explorer', proposer: 'proposer', critic: 'critic',
+                    };
+                    if (sub && roleMap[sub]) {
+                        await withRl((rl) => cmdConfigOneRole(rl, roleMap[sub]));
+                    }
+                    else {
+                        await withRl(cmdSetup);
+                    }
+                    break;
+                }
+                case 'config-multi':
+                    await withRl(cmdConfigMulti);
+                    break;
+                case 'status':
+                    await cmdStatus(fi);
+                    break;
+                case 'run':
+                    if (args[0] === 'orch' || args[0] === 'orchestrator') {
+                        const task = args.slice(1).join(' ');
+                        const dir = process.cwd();
+                        const config = await loadProjectConfig(dir);
+                        const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                        const result = await engine.runOrchestrator(task);
+                        fi.println(chalk.green(`  Task ID: ${result.taskId}`));
+                    }
+                    else if (args[0] === 'impl' || args[0] === 'implementor') {
+                        const taskId = args[1];
+                        const dir = process.cwd();
+                        const config = await loadProjectConfig(dir);
+                        const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                        const taskDir = path.join(dir, '.agent', 'tasks', taskId);
+                        const plan = await readJson(path.join(taskDir, 'plan.json'));
+                        await engine.runImplementor(taskId, plan);
+                    }
+                    else if (args[0] === 'rev' || args[0] === 'reviewer') {
+                        const taskId = args[1];
+                        const dir = process.cwd();
+                        const config = await loadProjectConfig(dir);
+                        const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                        const taskDir = path.join(dir, '.agent', 'tasks', taskId);
+                        const plan = await readJson(path.join(taskDir, 'plan.json'));
+                        const progress = await readJson(path.join(taskDir, 'progress.json'));
+                        await engine.runReviewer(taskId, plan, progress);
+                    }
+                    else {
+                        const task = args.join(' ');
+                        const dir = process.cwd();
+                        const config = await loadProjectConfig(dir);
+                        const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                        await engine.runFullCycle(task);
+                    }
+                    break;
+                case 'models':
+                    await cmdModels(args[0], fi);
+                    break;
+                case 'login':
+                    await withRl(async (rl) => { await cmdLogin(rl); });
+                    break;
+                case 'logout': {
+                    // Clear OAuth credentials and auth store
+                    const credsPath = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+                    await fs.unlink(credsPath).catch(() => { });
+                    const authStore = await loadAuth();
+                    authStore.entries = [];
+                    delete authStore.activeProvider;
+                    await saveAuth(authStore);
+                    fi.println(chalk.dim('  Logged out. Credentials cleared.'));
+                    fi.teardown();
+                    rl.close();
+                    return;
+                }
+                case 'auth-status':
+                    await cmdAuthStatus(fi);
+                    break;
+                case 'tasks':
+                    await cmdTasks(fi);
+                    break;
+                case 'clear':
+                    fi.teardown();
+                    console.clear();
+                    fi.setup();
+                    break;
+                case 'help':
+                    cmdHelp(fi);
+                    break;
+                case 'exit':
+                case 'quit':
+                    fi.println(chalk.dim('  Bye!'));
+                    fi.teardown();
+                    rl.close();
+                    return;
+                default:
+                    fi.println(chalk.red(`  Unknown command: /${cmd}`));
+                    fi.println(chalk.dim('  Type /help for available commands'));
+            }
+        }
+        catch (err) {
+            fi.println(chalk.red(`  Error: ${err.message}`));
+        }
+        // Always redraw box after each command
+        fi.redrawBox();
+    }
+}
+/**
+ * Direct role execution — agent-mp MISMO actúa como rol.
+ * NO spawnea CLIs externos. Usa la conexión OAuth de qwen directamente.
+ * Prompt estricto: cada rol solo hace lo que debe, sin extras.
+ */
+export async function runRole(role, arg) {
+    const init = await initCoordinator();
+    if (!init)
+        process.exit(1);
+    const { coordinatorCmd } = init;
+    const rl = init.rl;
+    const dir = process.cwd();
+    let config;
+    try {
+        config = await loadProjectConfig(dir);
+    }
+    catch {
+        console.log(chalk.red('  No project config found. Run /setup first.'));
+        rl.close();
+        process.exit(1);
+    }
+    // Validate roles are configured
+    if (!config.roles?.orchestrator?.cli || !config.roles?.implementor?.cli || !config.roles?.reviewer?.cli) {
+        console.log(chalk.red('  Roles not configured. Run setup first.'));
+        rl.close();
+        process.exit(1);
+    }
+    console.log(chalk.bold.cyan(`\n  Agent-mp — Rol: ${role.toUpperCase()}\n`));
+    const engine = new AgentEngine(config, dir, coordinatorCmd, rl);
+    try {
+        switch (role.toLowerCase()) {
+            case 'orchestrator':
+            case 'orch': {
+                const result = await engine.runOrchestrator(arg);
+                log.ok(`Task ID: ${result.taskId}`);
+                break;
+            }
+            case 'implementor':
+            case 'impl': {
+                const taskDir = path.join(dir, '.agent', 'tasks', arg);
+                const plan = await readJson(path.join(taskDir, 'plan.json'));
+                await engine.runImplementor(arg, plan);
+                break;
+            }
+            case 'reviewer':
+            case 'rev': {
+                const taskDir = path.join(dir, '.agent', 'tasks', arg);
+                const plan = await readJson(path.join(taskDir, 'plan.json'));
+                const progress = await readJson(path.join(taskDir, 'progress.json'));
+                await engine.runReviewer(arg, plan, progress);
+                break;
+            }
+            case 'coordinator':
+            case 'coord': {
+                console.log(chalk.yellow('  Coordinator mode requires interactive REPL.'));
+                console.log(chalk.yellow('  Run `agent-mp` without --rol to start the interactive loop.'));
+                process.exit(1);
+            }
+            default:
+                console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer`));
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`  Error: ${err.message}`));
+        process.exit(1);
+    }
+    rl.close();
+}