agent-rev 0.1.1 → 0.2.3

package/dist/commands/repl.d.ts

@@ -26,4 +26,4 @@ export declare function runRepl(resumeSession?: Session): Promise<void>;
  * NO spawnea CLIs externos. Usa la conexión OAuth de qwen directamente.
  * Prompt estricto: cada rol solo hace lo que debe, sin extras.
  */
-export declare function runRole(role: string, arg: string): Promise<void>;
+export declare function runRole(role: string, arg: string, model?: string): Promise<void>;

package/dist/commands/repl.js

@@ -9,8 +9,8 @@ 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 { AgentEngine, ExitError } from '../core/engine.js';
+import { qwenAuthStatus, QWEN_AGENT_HOME, fetchQwenModels } 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';
@@ -219,6 +219,25 @@ function detectModels(cliName) {
                 return out.trim().split('\n').filter(Boolean);
             }
             case 'aider': return ['default'];
+            case 'agent-orch':
+            case 'agent-impl':
+            case 'agent-rev':
+            case 'agent-explorer': {
+                try {
+                    const out = execSync(`${cliName} --list-models 2>/dev/null`, { encoding: 'utf-8' });
+                    const models = out.trim().split('\n').filter(Boolean);
+                    if (models.length)
+                        return models;
+                }
+                catch { }
+                // fallback: list from opencode since that's typically the underlying CLI
+                try {
+                    const out = execSync('opencode models 2>/dev/null', { encoding: 'utf-8' });
+                    return out.trim().split('\n').filter(Boolean);
+                }
+                catch { }
+                return ['configured'];
+            }
             default: return ['default'];
         }
     }
@@ -634,29 +653,51 @@ async function cmdStatus(fi) {
     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}`);
+async function cmdModels(roleArg, fi, rl) {
+    const auth = await loadAuth();
+    const authedProviders = auth.entries.map(e => e.provider);
+    if (authedProviders.length === 0) {
+        fi.println(chalk.yellow('  No authenticated providers. Run /login first.'));
+        return;
+    }
+    // Fetch models from the OAuth provider (coordinator's native connection)
+    fi.println(chalk.dim('  Fetching models from your OAuth account...'));
+    const prov = authedProviders[0];
+    let models;
+    if (prov === 'qwen') {
+        models = await fetchQwenModels();
     }
     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`));
-        }
+        models = detectModels(prov);
+    }
+    if (!models.length) {
+        fi.println(chalk.red('  No models available.'));
+        return;
+    }
+    // Show numbered list
+    const resume = fi.suspend();
+    const cliConfig = await loadCliConfig();
+    const currentModel = cliConfig.coordinatorModel ?? '(auto)';
+    console.log(chalk.bold.cyan(`\n  Coordinator model  [current: ${currentModel}]\n`));
+    console.log(chalk.dim('  These are your OAuth account models. CLIs are configured separately with /setup.\n'));
+    models.forEach((m, i) => console.log(chalk.dim(`  ${String(i + 1).padStart(2)}. ${m}`)));
+    const modelInput = await ask(rl, chalk.bold('\n  Model # or name (Enter to keep current): '));
+    resume();
+    if (!modelInput.trim()) {
+        fi.println(chalk.dim('  → no change'));
+        return;
     }
+    const num = parseInt(modelInput.trim());
+    const selectedModel = (!isNaN(num) && num >= 1 && num <= models.length)
+        ? models[num - 1]
+        : modelInput.trim();
+    // Save as coordinator model only
+    cliConfig.coordinatorModel = selectedModel;
+    await saveCliConfig(cliConfig);
+    // Update gCoordinatorCmd in memory
+    gCoordinatorCmd = buildCmd(prov, selectedModel);
+    fi.println(chalk.green(`\n  ✓ Coordinator model → ${selectedModel}`));
+    fi.println(chalk.dim(`  CMD: ${gCoordinatorCmd}`));
     fi.println('');
 }
 async function cmdAuthStatus(fi) {
@@ -829,7 +870,8 @@ export async function initCoordinator() {
     }
     // 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';
+    const cliCfg = await loadCliConfig();
+    const activeModel = cliCfg.coordinatorModel || detectModels(activeCli.name)[0] || 'default';
     gCoordinatorCmd = buildCmd(activeCli.name, activeModel);
     return { coordinatorCmd: gCoordinatorCmd, activeCli, installed, rl };
 }
@@ -928,31 +970,133 @@ export async function runRepl(resumeSession) {
             resume();
         }
     };
+    // Show coordinator header before the REPL loop (once, at startup)
+    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)));
+            fi.println(chalk.bold(`    ── FASE 0 — Clarificacion ──`));
+            fi.println(chalk.dim(`  → El coordinador va a conversar con vos para entender la tarea.`));
+            fi.println(chalk.dim(`  → Cuando el coordinador tenga claro el objetivo, te va a pedir confirmación para lanzar el plan.`));
+            fi.println(chalk.dim('  ' + '─'.repeat(42)));
+        }
+    }
+    catch { }
+    // Command handler — used by the main loop AND by the engine during mid-conversation
+    const handleCmd = async (trimmed) => {
+        const parts = trimmed.slice(1).split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        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': {
+                const dir = process.cwd();
+                const config = await loadProjectConfig(dir);
+                if (args[0] === 'orch' || args[0] === 'orchestrator') {
+                    const task = args.slice(1).join(' ');
+                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
+                    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 engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
+                    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 engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
+                    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 engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
+                    await engine.runFullCycle(task);
+                }
+                break;
+            }
+            case 'models':
+            case 'model':
+                await withRl((rl) => cmdModels(args[0], fi, rl));
+                break;
+            case 'login':
+                await withRl(async (rl) => { await cmdLogin(rl); });
+                break;
+            case 'logout': {
+                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();
+                throw new ExitError();
+            }
+            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();
+                throw new ExitError();
+            default:
+                fi.println(chalk.red(`  Unknown command: /${cmd}`));
+                fi.println(chalk.dim('  Type /help for available commands'));
+        }
+        fi.redrawBox();
+    };
     // 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++) {
@@ -972,128 +1116,29 @@ export async function runRepl(resumeSession) {
                     fi.println(chalk.red('  No roles configured. Run /config-multi first.'));
                 }
                 else {
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi);
+                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
                     await engine.runFullCycle(trimmed);
                     session.messages.push({ role: 'agent', content: `[task cycle completed for: ${trimmed}]`, ts: new Date().toISOString() });
                     await saveSession(session);
                 }
             }
             catch (err) {
+                if (err instanceof ExitError)
+                    return;
                 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'));
-            }
+            await handleCmd(trimmed);
         }
         catch (err) {
+            if (err instanceof ExitError)
+                return;
             fi.println(chalk.red(`  Error: ${err.message}`));
+            fi.redrawBox();
         }
-        // Always redraw box after each command
-        fi.redrawBox();
     }
 }
 /**
@@ -1101,7 +1146,7 @@ export async function runRepl(resumeSession) {
  * 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) {
+export async function runRole(role, arg, model) {
     const init = await initCoordinator();
     if (!init)
         process.exit(1);
@@ -1123,7 +1168,20 @@ export async function runRole(role, arg) {
         rl.close();
         process.exit(1);
     }
-    console.log(chalk.bold.cyan(`\n  Agent-mp — Rol: ${role.toUpperCase()}\n`));
+    // Override model if passed via --model flag
+    if (model) {
+        const roleKey = role.toLowerCase().startsWith('orch') ? 'orchestrator'
+            : role.toLowerCase().startsWith('impl') ? 'implementor'
+                : role.toLowerCase().startsWith('rev') ? 'reviewer'
+                    : role.toLowerCase().startsWith('exp') ? 'explorer'
+                        : undefined;
+        if (roleKey && config.roles[roleKey]) {
+            const r = config.roles[roleKey];
+            r.model = model;
+            r.cmd = r.cmd.replace(/(-m|--model)\s+\S+/, `$1 ${model}`);
+        }
+    }
+    console.log(chalk.bold.cyan(`\n  Agent-mp — Rol: ${role.toUpperCase()}${model ? ` (${model})` : ''}\n`));
     const engine = new AgentEngine(config, dir, coordinatorCmd, rl);
     try {
         switch (role.toLowerCase()) {

package/dist/commands/setup.js

@@ -57,6 +57,24 @@ function detectModels(cliName) {
             }
             case 'aider':
                 return ['default'];
+            case 'agent-orch':
+            case 'agent-impl':
+            case 'agent-rev':
+            case 'agent-explorer': {
+                try {
+                    const out = execSync(`${cliName} --list-models 2>/dev/null`, { encoding: 'utf-8' });
+                    const models = out.trim().split('\n').filter(Boolean);
+                    if (models.length)
+                        return models;
+                }
+                catch { }
+                try {
+                    const out = execSync('opencode models 2>/dev/null', { encoding: 'utf-8' });
+                    return out.trim().split('\n').filter(Boolean);
+                }
+                catch { }
+                return ['configured'];
+            }
             default:
                 return ['default'];
         }

package/dist/core/engine.d.ts

@@ -1,15 +1,21 @@
 import * as readline from 'readline';
 import { AgentConfig, TaskPlan, TaskProgress } from '../types.js';
 import type { FixedInput } from '../ui/input.js';
+/** Thrown when a slash command inside a conversation requests exit */
+export declare class ExitError extends Error {
+    constructor();
+}
+export type SlashHandler = (input: string) => Promise<void>;
 export declare class AgentEngine {
     private config;
     private projectDir;
     private coordinatorCmd;
     private rl?;
     private fi?;
+    private slashHandler?;
     private totalTokens;
     private phaseTokens;
-    constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string, rl?: readline.Interface, fi?: FixedInput);
+    constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string, rl?: readline.Interface, fi?: FixedInput, slashHandler?: SlashHandler);
     /**
      * FASE 0 — Clarificacion con el programador.
      * El coordinador (CLI activo, ej: Qwen) conversa con el usuario

package/dist/core/engine.js

@@ -9,6 +9,10 @@ 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';
+/** Thrown when a slash command inside a conversation requests exit */
+export class ExitError extends Error {
+    constructor() { super('exit'); }
+}
 /** Parse --help output to detect current flags */
 function detectCliFlags(cliName) {
     try {
@@ -205,14 +209,16 @@ export class AgentEngine {
     coordinatorCmd;
     rl;
     fi;
+    slashHandler;
     totalTokens = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
     phaseTokens = [];
-    constructor(config, projectDir, coordinatorCmd, rl, fi) {
+    constructor(config, projectDir, coordinatorCmd, rl, fi, slashHandler) {
         this.config = config;
         this.projectDir = projectDir;
         this.coordinatorCmd = coordinatorCmd || '';
         this.rl = rl;
         this.fi = fi;
+        this.slashHandler = slashHandler;
     }
     /**
      * FASE 0 — Clarificacion con el programador.
@@ -223,14 +229,10 @@ export class AgentEngine {
         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) {
+        // Helper: call coordinator CLI and return response text
+        const callCoordinator = async () => {
             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.
 
@@ -247,12 +249,11 @@ INSTRUCCIONES:
 - 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');
+            let res;
             if (this.coordinatorCmd.startsWith('qwen')) {
-                // Check if corporate credentials exist
+                const corporateCreds = path.join(QWEN_AGENT_HOME, 'oauth_creds.json');
+                const personalCreds = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
                 let corporateCredsContent = null;
                 try {
                     corporateCredsContent = await fs.readFile(corporateCreds, 'utf-8');
@@ -260,93 +261,63 @@ INSTRUCCIONES:
                 catch {
                     console.log(chalk.red('\n  ✗ No hay credenciales corporativas de Qwen.'));
                     console.log(chalk.yellow('  Ejecutá /login para autenticarte.\n'));
-                    return initialTask;
+                    return '';
                 }
-                // 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
+                res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
                 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;
+                res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
+            }
+            // Extract readable text (Qwen CLI returns JSON events)
+            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;
+                        }
+                        if (item.type === 'assistant' && item.message?.content?.length > 0) {
+                            const t = item.message.content.find((c) => c.type === 'text');
+                            if (t?.text) {
+                                responseText = t.text;
                                 break;
                             }
                         }
                     }
                 }
-                catch { }
+            }
+            catch { }
+            return responseText;
+        };
+        // Clarification loop — coordinator is only called when there is new user input
+        let needsCoordinatorCall = true;
+        while (true) {
+            if (needsCoordinatorCall) {
+                needsCoordinatorCall = false;
+                const responseText = await callCoordinator();
+                if (!responseText)
+                    return initialTask; // auth error
                 console.log('');
                 console.log(chalk.cyan('  Coordinador:'));
                 console.log(chalk.white(`  ${responseText}`));
                 console.log('');
+                // If coordinator is asking for confirmation to launch the plan
                 const lower = responseText.toLowerCase();
-                if ((lower.includes('confirm') || lower.includes('procedo')) &&
+                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') {
@@ -354,11 +325,20 @@ INSTRUCCIONES:
                     }
                     const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl, this.fi);
                     conversationHistory += `\nPROGRAMADOR: ${correction}`;
+                    needsCoordinatorCall = true;
                     continue;
                 }
-                const answer = await ask('  Tu respuesta: ', this.rl, this.fi);
-                conversationHistory += `\nPROGRAMADOR: ${answer}`;
             }
+            // Ask user — slash commands are handled here without calling coordinator again
+            const answer = await ask('  Tu respuesta: ', this.rl, this.fi);
+            const trimmedAnswer = answer.trim();
+            if (trimmedAnswer.startsWith('/') && this.slashHandler) {
+                await this.slashHandler(trimmedAnswer);
+                // needsCoordinatorCall is still false — re-prompt without coordinator call
+                continue;
+            }
+            conversationHistory += `\nPROGRAMADOR: ${answer}`;
+            needsCoordinatorCall = true; // got real input, coordinator should respond
         }
     }
     async runWithFallback(roleName, prompt, phaseName) {

package/dist/index.js

@@ -5,7 +5,7 @@ import * as os from 'os';
 import * as fs from 'fs/promises';
 import * as readline from 'readline';
 import chalk from 'chalk';
-import { AGENT_HOME } from './utils/config.js';
+import { AGENT_HOME, PKG_NAME } from './utils/config.js';
 import { runRepl, runRole } from './commands/repl.js';
 import { setupCommand } from './commands/setup.js';
 import { getLastSessionForDir, listSessions, loadSession } from './utils/sessions.js';
@@ -18,6 +18,8 @@ program
     .option('--continue', 'Resume the last session in the current directory')
     .option('--resume [id]', 'Resume any saved session by ID (omit ID to pick from list)')
     .option('--rol <role>', 'Run a specific role directly: orchestrator | implementor | reviewer | coordinator')
+    .option('--models [cli]', 'List available models (optionally filter by CLI name)')
+    .option('--model [cli]', 'Alias for --models')
     .option('--reset-coordinator', 'Clear coordinator selection (re-pick on next run)')
     .option('--reset-auth', 'Wipe all auth credentials and start fresh')
     .addHelpText('after', `
@@ -64,16 +66,21 @@ const ROLE_BINS = {
     'agent-rev': 'reviewer',
     'agent-explorer': 'explorer',
 };
-const binName = path.basename(process.argv[1]).replace(/\.(js|ts|mjs)$/, '');
-const nativeRole = ROLE_BINS[binName];
+const nativeRole = ROLE_BINS[PKG_NAME];
 if (nativeRole) {
-    // Role-specific CLI: accept task as positional arg or prompt for it
-    const taskArg = process.argv.slice(2).filter(a => !a.startsWith('-')).join(' ').trim();
+    // Parse --model flag if provided
+    const args = process.argv.slice(2);
+    const modelIdx = args.findIndex(a => a === '--model' || a === '-m');
+    let model;
+    if (modelIdx !== -1 && args[modelIdx + 1]) {
+        model = args[modelIdx + 1];
+    }
+    const taskArg = args.filter((a, i) => !a.startsWith('-') && i !== modelIdx + 1).join(' ').trim();
     if (!taskArg) {
-        console.error(chalk.red(`  Usage: ${binName} "<task description or task-id>"`));
+        console.error(chalk.red(`  Usage: ${PKG_NAME} [--model <model>] "<task description or task-id>"`));
         process.exit(1);
     }
-    await runRole(nativeRole, taskArg);
+    await runRole(nativeRole, taskArg, model);
     process.exit(0);
 }
 // ─────────────────────────────────────────────────────────────────────────────
@@ -99,6 +106,54 @@ program.action(async (task, options) => {
         }
         process.exit(0);
     }
+    // --models / --model: list models for authenticated providers only
+    if (options.models !== undefined || options.model !== undefined) {
+        const { execSync } = await import('child_process');
+        const { loadAuth } = await import('./utils/config.js');
+        const filter = typeof options.models === 'string' ? options.models
+            : typeof options.model === 'string' ? options.model
+                : undefined;
+        const auth = await loadAuth();
+        const authedProviders = auth.entries.map(e => e.provider);
+        if (authedProviders.length === 0) {
+            console.log(chalk.yellow('  No authenticated providers. Run /login first.'));
+            process.exit(0);
+        }
+        const targets = filter ? [filter] : authedProviders;
+        const { fetchQwenModels } = await import('./utils/qwen-auth.js');
+        for (const provider of targets) {
+            try {
+                let models = [];
+                if (provider === 'qwen') {
+                    models = await fetchQwenModels();
+                }
+                else if (provider === 'opencode') {
+                    models = execSync('opencode models 2>/dev/null', { encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
+                }
+                else if (provider === 'claude') {
+                    const help = execSync('claude --help 2>/dev/null', { encoding: 'utf-8' });
+                    models = help.match(/'([^']+)'/g)?.map(m => m.replace(/'/g, '')).filter(Boolean) ?? ['opus', 'sonnet', 'haiku'];
+                }
+                else if (provider === 'gemini') {
+                    models = execSync('gemini models 2>/dev/null', { encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
+                    if (!models.length)
+                        models = ['gemini-2.5-pro', 'gemini-2.5-flash'];
+                }
+                else {
+                    models = ['default'];
+                }
+                const email = auth.entries.find(e => e.provider === provider)?.email;
+                const label = email ? `${provider} (${email})` : provider;
+                console.log(chalk.bold.cyan(`\n  ${label}:`));
+                models.forEach(m => console.log(chalk.dim(`    ${m}`)));
+            }
+            catch {
+                console.log(chalk.dim(`  ${provider}: (unavailable)`));
+            }
+        }
+        console.log('');
+        process.exit(0);
+    }
     // --continue: resume last session for current dir
     if (options.continue) {
         const session = await getLastSessionForDir(process.cwd());

package/dist/types.js

@@ -55,4 +55,36 @@ export const CLI_REGISTRY = {
         promptFlag: '-p',
         promptPosition: 'flag',
     },
+    'agent-orch': {
+        name: 'Agent Orch',
+        command: 'agent-orch',
+        modelFlag: '--model',
+        extraFlags: '',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
+    'agent-impl': {
+        name: 'Agent Impl',
+        command: 'agent-impl',
+        modelFlag: '--model',
+        extraFlags: '',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
+    'agent-rev': {
+        name: 'Agent Rev',
+        command: 'agent-rev',
+        modelFlag: '--model',
+        extraFlags: '',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
+    'agent-explorer': {
+        name: 'Agent Explorer',
+        command: 'agent-explorer',
+        modelFlag: '--model',
+        extraFlags: '',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
 };

package/dist/utils/config.d.ts

@@ -1,4 +1,5 @@
 import { AgentConfig } from '../types.js';
+export declare const PKG_NAME: string;
 export declare const AGENT_HOME: string;
 export declare const AUTH_FILE: string;
 export declare const CONFIG_FILE: string;

package/dist/utils/config.js

@@ -2,13 +2,9 @@ import { promises as fs } from 'fs';
 import * as fsSync from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-function getAgentHome() {
-    const known = ['agent-mp', 'agent-orch', 'agent-impl', 'agent-rev', 'agent-explorer'];
-    const binName = path.basename(process.argv[1]).replace(/\.(js|ts|mjs)$/, '');
-    if (known.includes(binName)) {
-        return path.join(os.homedir(), `.${binName}`);
-    }
-    // dev mode (tsx src/index.ts) — read name from package.json
+const KNOWN_PKGS = ['agent-mp', 'agent-orch', 'agent-impl', 'agent-rev', 'agent-explorer'];
+function resolvePackageName() {
+    // 1. Read package.json (reliable for both global installs and dev mode)
     const __filename = new URL(import.meta.url).pathname;
     const __dirname = path.dirname(__filename);
     for (const p of [
@@ -17,15 +13,19 @@ function getAgentHome() {
     ]) {
         try {
             const pkg = JSON.parse(fsSync.readFileSync(p, 'utf-8'));
-            if (pkg.name && known.includes(pkg.name)) {
-                return path.join(os.homedir(), `.${pkg.name}`);
-            }
+            if (pkg.name && KNOWN_PKGS.includes(pkg.name))
+                return pkg.name;
         }
         catch { }
     }
-    return path.join(os.homedir(), '.agent-mp');
+    // 2. Fallback: binary name (e.g. running from a symlink in PATH)
+    const bin = path.basename(process.argv[1]).replace(/\.(js|ts|mjs)$/, '');
+    if (KNOWN_PKGS.includes(bin))
+        return bin;
+    return 'agent-mp';
 }
-export const AGENT_HOME = getAgentHome();
+export const PKG_NAME = resolvePackageName();
+export const AGENT_HOME = path.join(os.homedir(), `.${PKG_NAME}`);
 export const AUTH_FILE = path.join(AGENT_HOME, 'auth.json');
 export const CONFIG_FILE = path.join(AGENT_HOME, 'config.json');
 export async function loadAuth() {

package/dist/utils/qwen-auth.d.ts

@@ -8,5 +8,6 @@ export declare function qwenAuthStatus(): Promise<{
     authenticated: boolean;
     email?: string;
 }>;
+export declare function fetchQwenModels(): Promise<string[]>;
 export declare function getQwenAccessToken(): Promise<string | null>;
 export declare function callQwenAPI(prompt: string, model?: string): Promise<string>;

package/dist/utils/qwen-auth.js

@@ -216,6 +216,23 @@ export async function qwenAuthStatus() {
         return { authenticated: false };
     return { authenticated: true };
 }
+export async function fetchQwenModels() {
+    const token = await loadToken();
+    if (!token)
+        return [];
+    try {
+        const res = await fetch('https://chat.qwen.ai/api/models', {
+            headers: { Authorization: `Bearer ${token.accessToken}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.data ?? []).map((m) => m.id).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 export async function getQwenAccessToken() {
     const token = await loadToken();
     return token?.accessToken || null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-rev",
-  "version": "0.1.1",
-  "description": "Reviewer agent — validates and reviews implementation against the plan",
+  "version": "0.2.3",
+  "description": "Reviewer agent — validates and reviews code written by the implementor",
   "type": "module",
   "main": "./dist/index.js",
   "files": [
@@ -15,14 +15,7 @@
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build"
   },
-  "keywords": [
-    "ai",
-    "agent",
-    "orchestrator",
-    "multi-agent",
-    "cli",
-    "coding"
-  ],
+  "keywords": ["ai", "agent", "reviewer", "multi-agent", "cli", "coding"],
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",