agent-mp 0.5.24 → 0.5.26

package/dist/commands/repl.js

@@ -11,6 +11,7 @@ import { loadAuth, saveAuth, loadCliConfig, saveCliConfig, loadProjectConfig, re
 import { log } from '../utils/logger.js';
 import { AgentEngine, ExitError } from '../core/engine.js';
 import { qwenAuthStatus, QWEN_AGENT_HOME, fetchQwenModels, loadApiKeyConfig, saveApiKeyConfig, fetchApiKeyModels, DEFAULT_API_BASE_URL } from '../utils/qwen-auth.js';
+import { loadGeminiApiKey, saveGeminiApiKey, geminiAuthStatus, deleteGeminiApiKey, GEMINI_MODELS } from '../utils/gemini.js';
 import { renderWelcomePanel, renderHelpHint, renderSectionBox, renderMultiSectionBox } from '../ui/theme.js';
 import { FixedInput } from '../ui/input.js';
 import { newSession, saveSession } from '../utils/sessions.js';
@@ -299,8 +300,44 @@ async function promptApiKeySetup(rl, askFn) {
     console.log(chalk.green(`\n  ✓ API key saved — ${cfg.model}\n`));
     return true;
 }
+async function promptGeminiKeySetup(rl, askFn) {
+    const existing = await loadGeminiApiKey();
+    if (existing) {
+        console.log(chalk.dim(`  Current: Google Gemini / ${existing.model}`));
+    }
+    const apiKey = await askFn(`  Gemini API Key${existing ? ' [Enter to keep]' : ''}: `);
+    const resolvedKey = apiKey.trim() || existing?.api_key || '';
+    if (!resolvedKey) {
+        console.log(chalk.red('  API key es requerida.'));
+        return false;
+    }
+    console.log(chalk.bold('\n  Modelos disponibles:'));
+    GEMINI_MODELS.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+    const defaultModel = existing?.model ?? 'gemini-2.5-flash';
+    const pick = await askFn(`\n  Modelo [${defaultModel}]: `);
+    const num = parseInt(pick.trim());
+    let chosenModel = defaultModel;
+    if (!isNaN(num) && num >= 1 && num <= GEMINI_MODELS.length) {
+        chosenModel = GEMINI_MODELS[num - 1];
+    }
+    else if (pick.trim()) {
+        chosenModel = pick.trim();
+    }
+    await saveGeminiApiKey({ api_key: resolvedKey, model: chosenModel });
+    console.log(chalk.green(`\n  ✓ Gemini API key guardada — ${chosenModel}\n`));
+    return true;
+}
 async function cmdLogin(rl) {
     console.log(chalk.bold.cyan('\n  Configure API Key\n'));
+    console.log(chalk.bold('  Proveedor:'));
+    console.log(chalk.dim('    1. Qwen / OpenAI-compatible'));
+    console.log(chalk.dim('    2. Google Gemini'));
+    console.log('');
+    const pick = await ask(rl, '  Elegí [1]: ');
+    const choice = pick.trim() || '1';
+    if (choice === '2') {
+        return promptGeminiKeySetup(rl, (q) => ask(rl, q));
+    }
     return promptApiKeySetup(rl, (q) => ask(rl, q));
 }
 async function cmdSetup(rl) {
@@ -566,13 +603,21 @@ 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 geminiStatus = await geminiAuthStatus();
+    const apiKeyCfg = await loadApiKeyConfig();
+    const authRows = [];
+    if (geminiStatus.authenticated) {
+        authRows.push({ key: 'Google Gemini', value: `✓ ${geminiStatus.model}  (activo como coordinador)` });
+    }
+    if (apiKeyCfg?.api_key) {
+        authRows.push({ key: apiKeyCfg.provider, value: `✓ ${apiKeyCfg.model}` });
+    }
+    if (auth.entries.length > 0) {
+        authRows.push({ key: 'OAuth', value: auth.entries.map((e) => `${e.provider} (${e.method})`).join(', ') });
+    }
+    if (authRows.length === 0)
+        authRows.push({ key: 'Status', value: 'none — run /login' });
+    sections.push({ title: 'Auth', rows: authRows });
     const roleRows = [];
     try {
         const projectConfig = await loadProjectConfig(process.cwd());
@@ -627,32 +672,39 @@ async function cmdStatus(fi) {
     fi.println('');
 }
 async function cmdModels(roleArg, fi, rl) {
+    const geminiCfg = await loadGeminiApiKey();
+    const apiKeyCfg = await loadApiKeyConfig();
     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];
+    // Determine active provider from current gCoordinatorCmd
+    const isGeminiActive = gCoordinatorCmd.startsWith('gemini-direct');
+    const activeProvider = isGeminiActive ? 'gemini' : (apiKeyCfg?.provider ?? auth.entries[0]?.provider ?? '');
+    const resume = fi.suspend();
+    const cliConfig = await loadCliConfig();
+    const currentModel = cliConfig.coordinatorModel ?? '(auto)';
     let models;
-    if (prov === 'qwen') {
+    if (isGeminiActive || activeProvider === 'gemini') {
+        models = GEMINI_MODELS;
+    }
+    else if (activeProvider === 'qwen') {
+        console.log(chalk.dim('  Fetching Qwen models...'));
         models = await fetchQwenModels();
+        if (!models.length)
+            models = detectModels('qwen');
+    }
+    else if (apiKeyCfg?.api_key) {
+        models = await fetchApiKeyModels(apiKeyCfg);
+        if (!models.length)
+            models = detectModels(activeProvider);
     }
     else {
-        models = detectModels(prov);
+        models = activeProvider ? detectModels(activeProvider) : [];
     }
     if (!models.length) {
-        fi.println(chalk.red('  No models available.'));
+        resume();
+        fi.println(chalk.red('  No models available. Configure un proveedor primero con /login.'));
         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'));
+    console.log(chalk.bold.cyan(`\n  Coordinator model  [current: ${currentModel}]  provider: ${activeProvider || '?'}\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();
@@ -664,15 +716,66 @@ async function cmdModels(roleArg, fi, rl) {
     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);
+    if (isGeminiActive || activeProvider === 'gemini') {
+        gCoordinatorCmd = `gemini-direct -m ${selectedModel}`;
+        if (geminiCfg)
+            await saveGeminiApiKey({ ...geminiCfg, model: selectedModel });
+    }
+    else {
+        gCoordinatorCmd = buildCmd(activeProvider, selectedModel);
+    }
     fi.println(chalk.green(`\n  ✓ Coordinator model → ${selectedModel}`));
     fi.println(chalk.dim(`  CMD: ${gCoordinatorCmd}`));
     fi.println('');
 }
+/** /provider — switch coordinator provider between configured ones */
+async function cmdProvider(fi, rl) {
+    const geminiCfg = await loadGeminiApiKey();
+    const apiKeyCfg = await loadApiKeyConfig();
+    const options = [];
+    if (geminiCfg?.api_key)
+        options.push({ label: `Google Gemini (${geminiCfg.model})`, value: 'gemini' });
+    if (apiKeyCfg?.api_key)
+        options.push({ label: `${apiKeyCfg.provider} (${apiKeyCfg.model})`, value: apiKeyCfg.provider });
+    if (options.length === 0) {
+        fi.println(chalk.yellow('  No hay proveedores configurados.'));
+        fi.println(chalk.dim('  Usá /login para configurar Qwen o Google Gemini.'));
+        return;
+    }
+    if (options.length === 1) {
+        fi.println(chalk.dim(`  Activo: ${options[0].label}`));
+        fi.println(chalk.dim('  Para agregar Google Gemini: /login → elegí opción 2.'));
+        return;
+    }
+    const resume = fi.suspend();
+    const current = gCoordinatorCmd.startsWith('gemini-direct') ? 'gemini' : (apiKeyCfg?.provider ?? '?');
+    console.log(chalk.bold.cyan(`\n  Cambiar proveedor  [activo: ${current}]\n`));
+    options.forEach((o, i) => console.log(chalk.dim(`  ${i + 1}. ${o.label}`)));
+    const pick = await ask(rl, chalk.bold('\n  Proveedor # (Enter to keep): '));
+    resume();
+    if (!pick.trim()) {
+        fi.println(chalk.dim('  → no change'));
+        return;
+    }
+    const idx = parseInt(pick.trim()) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= options.length) {
+        fi.println(chalk.red('  Opción inválida.'));
+        return;
+    }
+    const chosen = options[idx];
+    const cliConfig = await loadCliConfig();
+    if (chosen.value === 'gemini') {
+        gCoordinatorCmd = `gemini-direct -m ${geminiCfg.model}`;
+    }
+    else {
+        gCoordinatorCmd = `qwen-direct -m ${apiKeyCfg.model}`;
+    }
+    fi.println(chalk.green(`\n  ✓ Proveedor → ${chosen.label}`));
+    fi.println(chalk.dim(`  CMD: ${gCoordinatorCmd}`));
+    fi.println('');
+}
 async function cmdAuthStatus(fi) {
     const auth = await loadAuth();
     const rows = auth.entries.length === 0
@@ -749,9 +852,9 @@ function cmdHelp(fi) {
         { key: '/run rev <id>', value: 'Run only reviewer' },
         { key: '/run explorer [task]', value: 'Run only explorer' },
         { key: '/explorer [task]', value: 'Run explorer (shortcut)' },
-        { key: '/models', value: 'List models for all installed CLIs' },
-        { key: '/models <cli>', value: 'List models for a specific CLI' },
-        { key: '/login', value: 'Configure API key' },
+        { key: '/model', value: 'Cambiar modelo del coordinador' },
+        { key: '/provider', value: 'Cambiar proveedor activo (Gemini / Qwen)' },
+        { key: '/login', value: 'Configurar API key (Qwen o Gemini)' },
         { key: '/logout', value: 'Logout and clear credentials' },
         { key: '/auth-status', value: 'Show authentication status' },
         { key: '/usage', value: 'Check quota status for all role CLIs' },
@@ -806,13 +909,23 @@ export async function initCoordinator() {
         const auth = await loadAuth();
         const currentAuth = auth.activeProvider;
         let activeCli = installed.find((c) => c.name === currentAuth);
-        // Fast-path: API key configured
+        // Fast-path: Gemini API key configured
+        const geminiCfg = await loadGeminiApiKey();
+        if (geminiCfg?.api_key) {
+            gCoordinatorCmd = `gemini-direct -m ${geminiCfg.model}`;
+            console.log(chalk.green(`  ✓ Auth: Google Gemini / ${geminiCfg.model}\n`));
+            const syntheticCli = {
+                name: 'gemini',
+                info: { command: 'gemini-direct', modelFlag: '-m', promptFlag: '-p', description: 'Gemini API key' },
+                path: 'gemini-direct',
+            };
+            return { activeCli: syntheticCli, installed, coordinatorCmd: gCoordinatorCmd };
+        }
+        // Fast-path: Qwen/OpenAI-compatible API key configured
         const apiKeyCfg = await loadApiKeyConfig();
         if (apiKeyCfg?.api_key) {
-            const cliCfg = await loadCliConfig();
-            const model = cliCfg.coordinatorModel || apiKeyCfg.model;
-            gCoordinatorCmd = `qwen-direct -m ${model}`;
-            console.log(chalk.green(`  ✓ Auth: ${apiKeyCfg.provider} / ${model}\n`));
+            gCoordinatorCmd = `qwen-direct -m ${apiKeyCfg.model}`;
+            console.log(chalk.green(`  ✓ Auth: ${apiKeyCfg.provider} / ${apiKeyCfg.model}\n`));
             const syntheticCli = {
                 name: apiKeyCfg.provider,
                 info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' },
@@ -828,6 +941,24 @@ export async function initCoordinator() {
         });
         if (doSetup) {
             const askFn = (q) => new Promise((resolve) => rl.question(q, resolve));
+            // Ask provider
+            rl.question('  Provider: 1=Qwen/OpenAI-compatible  2=Google Gemini [1]: ', async () => { });
+            const providerPick = await new Promise((resolve) => rl.question('  Provider [1]: ', resolve));
+            if (providerPick.trim() === '2') {
+                const ok = await promptGeminiKeySetup(rl, askFn);
+                if (!ok)
+                    return null;
+                const saved = await loadGeminiApiKey();
+                if (!saved)
+                    return null;
+                gCoordinatorCmd = `gemini-direct -m ${saved.model}`;
+                const syntheticCli = {
+                    name: 'gemini',
+                    info: { command: 'gemini-direct', modelFlag: '-m', promptFlag: '-p', description: 'Gemini API key' },
+                    path: 'gemini-direct',
+                };
+                return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed };
+            }
             const ok = await promptApiKeySetup(rl, askFn);
             if (!ok)
                 return null;
@@ -905,7 +1036,7 @@ export async function runRepl(resumeSession) {
         try {
             const dir = await resolveProjectDir(process.cwd());
             const config = await loadProjectConfig(dir);
-            const engine = new AgentEngine(config, dir, gCoordinatorCmd, tempRl, fi, handleCmd);
+            const engine = new AgentEngine(config, dir, () => gCoordinatorCmd, tempRl, fi, handleCmd);
             return await fn(engine);
         }
         finally {
@@ -1066,6 +1197,9 @@ export async function runRepl(resumeSession) {
             case 'model':
                 await withRl((rl) => cmdModels(args[0], fi, rl));
                 break;
+            case 'provider':
+                await withRl((rl) => cmdProvider(fi, rl));
+                break;
             case 'login':
                 await withRl(async (rl) => { await cmdLogin(rl); });
                 break;
@@ -1073,6 +1207,7 @@ export async function runRepl(resumeSession) {
                 const { getApiKeyConfigPath } = await import('../utils/qwen-auth.js');
                 await fs.unlink(path.join(QWEN_AGENT_HOME, 'oauth_creds.json')).catch(() => { });
                 await fs.unlink(await getApiKeyConfigPath()).catch(() => { });
+                await deleteGeminiApiKey();
                 const authStore = await loadAuth();
                 authStore.entries = [];
                 delete authStore.activeProvider;

package/dist/core/engine.d.ts

@@ -9,13 +9,13 @@ export type SlashHandler = (input: string) => Promise<void>;
 export declare class AgentEngine {
     private config;
     private projectDir;
-    private coordinatorCmd;
+    private getCoordinatorCmd;
     private rl?;
     private fi?;
     private slashHandler?;
     private totalTokens;
     private phaseTokens;
-    constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string, rl?: readline.Interface, fi?: FixedInput, slashHandler?: SlashHandler);
+    constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string | (() => string), rl?: readline.Interface, fi?: FixedInput, slashHandler?: SlashHandler);
     /** Start the activity box for a subagent call. Returns { stop, push }. */
     private _startSpinner;
     /** Extract readable text lines from a qwen/CLI streaming chunk. */
@@ -25,15 +25,23 @@ export declare class AgentEngine {
      * El coordinador (CLI activo, ej: Qwen) conversa con el usuario
      * hasta tener toda la info necesaria. Retorna la tarea refinada.
      */
-    runClarification(initialTask: string): Promise<string>;
+    runClarification(initialTask: string): Promise<{
+        task: string;
+        specPath?: string;
+        featureId?: string;
+    }>;
     private runWithFallback;
     private buildRolePrompt;
-    generateTaskId(task: string): Promise<string>;
+    generateTaskId(task: string, featureId?: string): Promise<string>;
+    /** Lists feature IDs that have a raw/ subdirectory in .agent/docs/ */
+    private _listAvailableFeatures;
+    /** Extracts featureId if task is a path like .agent/docs/<featureId> or just <featureId> */
+    private _detectFeaturePath;
     /** Context for the ORCHESTRATOR only — planning-relevant files */
     private buildOrchestratorContext;
     /** Minimal context for COORDINATOR clarification only */
     private buildCoordinatorContext;
-    runOrchestrator(task: string): Promise<{
+    runOrchestrator(task: string, specPath?: string, featureId?: string): Promise<{
         taskId: string;
         plan: TaskPlan;
     }>;

package/dist/core/engine.js

@@ -3,10 +3,11 @@ import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'readline';
 import { CLI_REGISTRY } from '../types.js';
-import { writeJson, readJson, fileExists, writeFile, readFile } from '../utils/fs.js';
+import { writeJson, readJson, fileExists, writeFile, readFile, listDir } from '../utils/fs.js';
 import { log } from '../utils/logger.js';
 import chalk from 'chalk';
 import { callQwenAPI, callQwenAPIFromCreds } from '../utils/qwen-auth.js';
+import { callGeminiAPI } from '../utils/gemini.js';
 import * as fs from 'fs/promises';
 /** Thrown when a slash command inside a conversation requests exit */
 export class ExitError extends Error {
@@ -298,18 +299,24 @@ function looksLikeHallucinatedToolCalls(text) {
         /^\s*<function_call>/m,
         /^\s*```tool_use/im,
     ];
-    if (TOOL_PATTERNS.some(re => re.test(text)))
-        return true;
-    // If the text has NO valid file markers at all, it's also a failure case
+    return TOOL_PATTERNS.some(re => re.test(text));
+}
+/** Check whether the text contains at least one valid === *.md === marker. */
+function hasMdMarkers(text) {
     const fileMarkerMatches = text.match(/===\s+[^\n=]+?\.md\s*===/g);
-    if (!fileMarkerMatches || fileMarkerMatches.length === 0)
-        return true;
-    return false;
+    return !!(fileMarkerMatches && fileMarkerMatches.length > 0);
+}
+/**
+ * When a model returns valid markdown but without === markers, rescue it by
+ * wrapping the whole content as a single architecture.md block.
+ */
+function rescueAsArchitectureMd(text) {
+    return `=== .agent/context/architecture.md ===\n${text.trim()}\n`;
 }
 export class AgentEngine {
     config;
     projectDir;
-    coordinatorCmd;
+    getCoordinatorCmd;
     rl;
     fi;
     slashHandler;
@@ -318,7 +325,7 @@ export class AgentEngine {
     constructor(config, projectDir, coordinatorCmd, rl, fi, slashHandler) {
         this.config = config;
         this.projectDir = projectDir;
-        this.coordinatorCmd = coordinatorCmd || '';
+        this.getCoordinatorCmd = typeof coordinatorCmd === 'function' ? coordinatorCmd : () => coordinatorCmd || '';
         this.rl = rl;
         this.fi = fi;
         this.slashHandler = slashHandler;
@@ -386,13 +393,60 @@ export class AgentEngine {
      * hasta tener toda la info necesaria. Retorna la tarea refinada.
      */
     async runClarification(initialTask) {
-        if (!this.coordinatorCmd) {
-            return initialTask;
-        }
-        const context = await this.buildCoordinatorContext();
+        if (!this.getCoordinatorCmd()) {
+            return { task: initialTask };
+        }
+        // Detect feature ID from initial task (may be undefined — user hasn't provided it yet)
+        let activeFeatureId = this._detectFeaturePath(initialTask) ?? undefined;
+        // List available features so the coordinator can mention them
+        const availableFeatures = await this._listAvailableFeatures();
+        // Context is mutable — rebuilt when activeFeatureId changes mid-conversation
+        let context = await this.buildCoordinatorContext(activeFeatureId);
         let conversationHistory = `TAREA INICIAL: ${initialTask}`;
         // Helper: call coordinator CLI and return response text
         const callCoordinator = async () => {
+            const hasFeature = !!activeFeatureId;
+            const featureListBlock = availableFeatures.length > 0
+                ? `\nFEATURES DISPONIBLES en .agent/docs/:\n${availableFeatures.map(f => `  - ${f}`).join('\n')}\n`
+                : '\nNo hay features en .agent/docs/ todavía.\n';
+            const READY_SENTINEL = '[LISTO_PARA_LANZAR]';
+            const specInstructions = hasFeature ? `
+MODO SPEC: Se cargó la feature "${activeFeatureId}". Los archivos raw están en el contexto.
+Tu objetivo es construir colaborativamente un spec.md con el programador.
+
+FLUJO:
+1. Revisá los archivos raw en el contexto.
+2. Hacé UNA pregunta a la vez para aclarar dudas o completar info faltante.
+3. Cuando tengas todo claro, generá el spec.md con este formato EXACTO:
+
+=== SPEC.MD ===
+# Feature: ${activeFeatureId}
+
+## Objetivo
+[descripción clara del objetivo]
+
+## Alcance
+[qué incluye y qué no incluye]
+
+## Historias de Usuario / Requerimientos
+[detalle de cada requerimiento]
+
+## Criterios de Aceptación
+[lista de criterios verificables]
+
+## Notas Técnicas
+[consideraciones de implementación]
+=== END SPEC.MD ===
+
+4. Cuando el spec esté aprobado por el programador, escribí EXACTAMENTE al final de tu mensaje: ${READY_SENTINEL}` : `
+MODO TAREA LIBRE: El programador no especificó una feature de .agent/docs/.
+${featureListBlock}
+REGLAS:
+- Primero entendé QUÉ quiere hacer el programador. Hacé preguntas hasta tener claro el objetivo.
+- Si hay features disponibles, preguntá si alguna corresponde a esta tarea (mencioná los nombres).
+- Si el programador da un ID de feature, respondé EXACTAMENTE con: CARGAR_FEATURE: <id>
+- SOLO cuando tengas el objetivo completamente claro y el programador esté de acuerdo, escribí EXACTAMENTE al final de tu mensaje: ${READY_SENTINEL}
+- NUNCA escribas ${READY_SENTINEL} si solo recibiste un saludo o no tenés un objetivo concreto.`;
             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.
 
@@ -405,16 +459,46 @@ ${conversationHistory}
 INSTRUCCIONES:
 - Habla de forma NATURAL, como un compañero de equipo.
 - Si necesitas mas info, hace UNA pregunta clara y espera la respuesta.
-- Si ya entendiste el objetivo, decilo claramente y pregunta: "¿Confirmás para lanzar el orchestrator?"
 - NO uses JSON, habla normalmente.
-- Sé breve y directo.`;
+- Sé breve y directo.${specInstructions}`;
             log.info('Coordinador analizando...');
             const envOverride = {};
             let res;
-            if (this.coordinatorCmd.startsWith('qwen')) {
+            if (this.getCoordinatorCmd().startsWith('gemini-direct')) {
+                const model = this.getCoordinatorCmd().match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'gemini-model';
+                const sp = this._startSpinner(`coordinador  ${model}`);
+                try {
+                    const result = await callGeminiAPI(prompt, model, (c) => sp.push(c));
+                    sp.stop();
+                    return result;
+                }
+                catch (err) {
+                    sp.stop();
+                    const msg = err?.message ?? '';
+                    if (msg.startsWith('GEMINI_NOT_CONFIGURED')) {
+                        console.log(chalk.red('\n  ✗ Gemini no configurado.'));
+                        console.log(chalk.yellow('  Ejecutá: /login  y elegí Google Gemini.\n'));
+                    }
+                    else if (msg.startsWith('GEMINI_QUOTA_ZERO')) {
+                        // Strip the GEMINI_QUOTA_ZERO: prefix for display
+                        const detail = msg.replace('GEMINI_QUOTA_ZERO: ', '');
+                        console.log(chalk.red('\n  ✗ Cuota cero en free tier:'));
+                        console.log(chalk.yellow(`  ${detail}\n`));
+                    }
+                    else if (msg.startsWith('GEMINI_QUOTA_EXCEEDED')) {
+                        console.log(chalk.red('\n  ✗ ' + msg.replace('GEMINI_QUOTA_EXCEEDED: ', '')));
+                        console.log(chalk.yellow('  Usá /model para cambiar de modelo o /provider para cambiar de proveedor.\n'));
+                    }
+                    else {
+                        console.log(chalk.red(`\n  ✗ Error Gemini: ${msg}`));
+                    }
+                    throw new Error('COORDINATOR_FAILED');
+                }
+            }
+            else if (this.getCoordinatorCmd().startsWith('qwen')) {
                 // Use Qwen API directly — avoids the qwen CLI's own OAuth flow
                 // which causes mid-session auth popups and breaks display.
-                const model = this.coordinatorCmd.match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'coder-model';
+                const model = this.getCoordinatorCmd().match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'coder-model';
                 const sp = this._startSpinner(`coordinador  ${model}`);
                 try {
                     const result = await callQwenAPI(prompt, model, (c) => sp.push(c));
@@ -430,12 +514,12 @@ INSTRUCCIONES:
                     else {
                         console.log(chalk.red(`\n  ✗ Error Qwen: ${err.message}`));
                     }
-                    return '';
+                    throw new Error('COORDINATOR_FAILED');
                 }
             }
             else {
                 const sp = this._startSpinner(`coordinador`);
-                res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
+                res = await runCli(this.getCoordinatorCmd(), prompt, 600000, envOverride);
                 sp.stop();
             }
             // Extract readable text — search for JSON array even if there's prefix text
@@ -464,42 +548,103 @@ INSTRUCCIONES:
             }
             return responseText;
         };
+        let pendingSpecContent = null;
+        // Extract =\=\= SPEC.MD ===...=== END SPEC.MD === block from coordinator response
+        const extractSpecBlock = (text) => {
+            const match = text.match(/===\s*SPEC\.MD\s*===([\s\S]*?)=== END SPEC\.MD ===/i);
+            return match ? match[1].trim() : null;
+        };
         // 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();
+                let responseText;
+                try {
+                    responseText = await callCoordinator();
+                }
+                catch (err) {
+                    if (err.message === 'COORDINATOR_FAILED') {
+                        // Error ya fue mostrado al usuario — detener sin lanzar al orquestador
+                        throw err;
+                    }
+                    throw err;
+                }
                 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') || 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);
+                    return { task: initialTask }; // fallback vacío sin error
+                // Detect CARGAR_FEATURE: <id> — coordinator signaling a feature was identified
+                const cargarMatch = responseText.match(/CARGAR_FEATURE:\s*([^\s\n]+)/);
+                if (cargarMatch) {
+                    const newFeatureId = cargarMatch[1].trim();
+                    const rawDir = path.join(this.projectDir, '.agent', 'docs', newFeatureId, 'raw');
+                    if (await fileExists(rawDir)) {
+                        activeFeatureId = newFeatureId;
+                        context = await this.buildCoordinatorContext(activeFeatureId);
+                        log.ok(`Feature cargada: ${newFeatureId}`);
+                        conversationHistory += `\n[SISTEMA: Se cargaron los archivos raw de la feature "${newFeatureId}"]`;
+                        needsCoordinatorCall = true;
+                        continue; // re-call coordinator with enriched context
+                    }
+                    else {
+                        console.log(chalk.yellow(`  ⚠ Feature "${newFeatureId}" no encontrada en .agent/docs/`));
+                    }
+                }
+                // Display coordinator response (strip the CARGAR_FEATURE token if present)
+                const displayText = responseText.replace(/CARGAR_FEATURE:\s*\S+\s*/g, '').trim();
+                if (displayText) {
+                    console.log('');
+                    console.log(chalk.cyan('  Coordinador:'));
+                    console.log(chalk.white(`  ${displayText}`));
+                    console.log('');
+                }
+                // Accumulate spec block when in feature mode
+                if (activeFeatureId) {
+                    const specBlock = extractSpecBlock(responseText);
+                    if (specBlock)
+                        pendingSpecContent = specBlock;
+                }
+                // Sentinel-based detection — coordinator explicitly signals readiness
+                if (responseText.includes('[LISTO_PARA_LANZAR]')) {
+                    const confirm = await ask('  ¿Confirmás lanzar el orchestrator? (y/n): ', this.rl);
                     if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 's') {
-                        return conversationHistory;
+                        let specPath;
+                        if (activeFeatureId && pendingSpecContent) {
+                            const specDir = path.join(this.projectDir, '.agent', 'docs', activeFeatureId);
+                            const specFile = path.join(specDir, 'spec.md');
+                            await writeFile(specFile, pendingSpecContent);
+                            log.ok(`spec.md guardado en ${path.relative(this.projectDir, specFile)}`);
+                            specPath = specFile;
+                        }
+                        return { task: conversationHistory, specPath, featureId: activeFeatureId };
                     }
-                    const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl, this.fi);
+                    const correction = await ask('  ¿Qué querés cambiar o agregar?: ', this.rl);
                     conversationHistory += `\nPROGRAMADOR: ${correction}`;
                     needsCoordinatorCall = true;
                     continue;
                 }
             }
             // Ask user — slash commands are handled here without calling coordinator again
-            const answer = await ask('  Tu respuesta: ', this.rl, this.fi);
+            const answer = await ask('  Tu respuesta: ', this.rl);
             const trimmedAnswer = answer.trim();
             if (trimmedAnswer.startsWith('/') && this.slashHandler) {
                 await this.slashHandler(trimmedAnswer);
-                // needsCoordinatorCall is still false — re-prompt without coordinator call
                 continue;
             }
+            // Also detect feature ID in user messages mid-conversation
+            const mentionedFeature = this._detectFeaturePath(trimmedAnswer);
+            if (mentionedFeature && mentionedFeature !== activeFeatureId) {
+                const rawDir = path.join(this.projectDir, '.agent', 'docs', mentionedFeature, 'raw');
+                if (await fileExists(rawDir)) {
+                    activeFeatureId = mentionedFeature;
+                    context = await this.buildCoordinatorContext(activeFeatureId);
+                    log.ok(`Feature detectada en mensaje: ${mentionedFeature}`);
+                    conversationHistory += `\nPROGRAMADOR: ${answer}\n[SISTEMA: Se cargaron los archivos raw de la feature "${mentionedFeature}"]`;
+                    needsCoordinatorCall = true;
+                    continue;
+                }
+            }
             conversationHistory += `\nPROGRAMADOR: ${answer}`;
-            needsCoordinatorCall = true; // got real input, coordinator should respond
+            needsCoordinatorCall = true;
         }
     }
     async runWithFallback(roleName, prompt, phaseName) {
@@ -737,7 +882,11 @@ REGLA: Al terminar, reporta todo lo que encontraste de forma clara y estructurad
         const preamble = preambles[roleName] || '';
         return preamble ? `${preamble}\n\n${taskPrompt}` : taskPrompt;
     }
-    async generateTaskId(task) {
+    async generateTaskId(task, featureId) {
+        if (featureId) {
+            // Use featureId directly — no collision check needed, orchestrator owns the dir
+            return featureId;
+        }
         const today = new Date().toISOString().split('T')[0];
         const short = task.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 30);
         let num = 1;
@@ -749,6 +898,39 @@ REGLA: Al terminar, reporta todo lo que encontraste de forma clara y estructurad
             num++;
         }
     }
+    /** Lists feature IDs that have a raw/ subdirectory in .agent/docs/ */
+    async _listAvailableFeatures() {
+        const docsDir = path.join(this.projectDir, '.agent', 'docs');
+        if (!(await fileExists(docsDir)))
+            return [];
+        let entries = [];
+        try {
+            entries = await listDir(docsDir);
+        }
+        catch {
+            return [];
+        }
+        const features = [];
+        for (const entry of entries) {
+            const rawDir = path.join(docsDir, entry, 'raw');
+            if (await fileExists(rawDir))
+                features.push(entry);
+        }
+        return features.sort();
+    }
+    /** Extracts featureId if task is a path like .agent/docs/<featureId> or just <featureId> */
+    _detectFeaturePath(task) {
+        const trimmed = task.trim();
+        // Match .agent/docs/<featureId> (absolute or relative)
+        const docsMatch = trimmed.match(/(?:^|[/\\])\.agent[/\\]docs[/\\]([^/\\\s]+)/);
+        if (docsMatch)
+            return docsMatch[1];
+        // Match bare directory names that look like feature slugs (contain a hyphen or underscore)
+        if (/^[a-zA-Z0-9]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/.test(trimmed) && /[-_]/.test(trimmed)) {
+            return trimmed;
+        }
+        return null;
+    }
     /** Context for the ORCHESTRATOR only — planning-relevant files */
     async buildOrchestratorContext() {
         let ctx = `Project: ${this.config.project}\nStack: ${this.config.stack}\n`;
@@ -766,23 +948,49 @@ REGLA: Al terminar, reporta todo lo que encontraste de forma clara y estructurad
         return ctx;
     }
     /** Minimal context for COORDINATOR clarification only */
-    async buildCoordinatorContext() {
+    async buildCoordinatorContext(featureId) {
         let ctx = `Project: ${this.config.project}\nStack: ${this.config.stack}\n`;
         const indexPath = path.join(this.projectDir, '.agent', 'INDEX.md');
         if (await fileExists(indexPath)) {
             const content = await readFile(indexPath);
             ctx += `\n--- INDEX ---\n${content.slice(0, 2000)}\n`;
         }
+        if (featureId) {
+            const rawDir = path.join(this.projectDir, '.agent', 'docs', featureId, 'raw');
+            if (await fileExists(rawDir)) {
+                let files = [];
+                try {
+                    files = await listDir(rawDir);
+                }
+                catch { }
+                const mdFiles = files.filter(f => f.endsWith('.md')).sort();
+                if (mdFiles.length > 0) {
+                    ctx += `\n--- FEATURE: ${featureId} ---\n`;
+                    for (const fname of mdFiles) {
+                        const fpath = path.join(rawDir, fname);
+                        const content = await readFile(fpath);
+                        ctx += `\n=== ${fname} ===\n${content}\n`;
+                    }
+                    ctx += `--- END FEATURE ---\n`;
+                }
+            }
+        }
         return ctx;
     }
-    async runOrchestrator(task) {
-        const taskId = await this.generateTaskId(task);
+    async runOrchestrator(task, specPath, featureId) {
+        const taskId = await this.generateTaskId(task, featureId);
         const taskDir = path.join(this.projectDir, '.agent', 'tasks', taskId);
         log.phase(1, 'Planificacion', this.config.roles.orchestrator.cli, this.config.roles.orchestrator.model);
         const context = await this.buildOrchestratorContext();
+        let specContent = '';
+        if (specPath && await fileExists(specPath)) {
+            const raw = await readFile(specPath);
+            specContent = `\nSPEC.MD (documento de referencia):\n${raw}\n`;
+        }
         const prompt = `TAREA: ${task}
 TASK_ID: ${taskId}
 DIRECTORIO_TRABAJO: ${this.projectDir}
+${specContent}
 
 CONTEXTO DEL PROYECTO:
 ${context}
@@ -1621,8 +1829,15 @@ REGLAS DE PATHS:
             log.warn('Documentacion previa preservada (no se modifico nada).');
             return text;
         }
+        // If the model returned valid markdown but without === markers (common with some models),
+        // rescue it by wrapping the whole response as architecture.md
+        let effectiveText = text;
+        if (!hasMdMarkers(text)) {
+            log.warn('Explorer devolvio markdown sin marcadores === *.md === — guardando como architecture.md');
+            effectiveText = rescueAsArchitectureMd(text);
+        }
         // Parse sections separated by === path/file.md === markers
-        const sections = text.split(/===\s+(.+?\.md)\s*===/).slice(1);
+        const sections = effectiveText.split(/===\s+(.+?\.md)\s*===/).slice(1);
         // First pass: collect all valid file writes WITHOUT touching disk yet (transactional)
         const pendingWrites = [];
         for (let i = 0; i < sections.length; i += 2) {
@@ -1634,6 +1849,10 @@ REGLAS DE PATHS:
             content = content.replace(/^```markdown\s*/i, '').replace(/^```\s*$/gm, '').trim();
             if (!content)
                 continue;
+            // If the model emitted literal \n instead of real newlines (single-line output), unescape
+            if (!content.includes('\n') && content.includes('\\n')) {
+                content = content.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+            }
             // All explorer output goes under .agent/context/ — docs/ is manual-only
             const relPath = fileName.replace(/^\.agent\/context\//i, '').replace(/^\/+/, '');
             let targetPath = null;
@@ -1689,7 +1908,42 @@ REGLAS DE PATHS:
         // ══════════════════════════════════════════════════
         // FASE 0 — Clarificacion (Coordinador ↔ Programador)
         // ══════════════════════════════════════════════════
-        const refinedTask = await this.runClarification(task);
+        let clarification;
+        // Retry loop — lets the user fix model/provider inline when coordinator fails
+        while (true) {
+            try {
+                clarification = await this.runClarification(task);
+                break;
+            }
+            catch (err) {
+                if (err.message !== 'COORDINATOR_FAILED')
+                    throw err;
+                console.log('');
+                console.log(chalk.yellow('  ¿Qué querés hacer?'));
+                console.log(chalk.dim('  /model     — cambiar modelo del coordinador'));
+                console.log(chalk.dim('  /provider  — cambiar proveedor (Gemini ↔ Qwen)'));
+                console.log(chalk.dim('  r          — reintentar con la config actual'));
+                console.log(chalk.dim('  c          — cancelar'));
+                console.log('');
+                // Allow slash commands or simple actions here
+                while (true) {
+                    const action = await ask('  > ', this.rl, this.fi);
+                    const t = action.trim();
+                    if (t === 'c' || t === 'cancel')
+                        return;
+                    if (t === 'r')
+                        break; // retry coordinator
+                    if (t.startsWith('/') && this.slashHandler) {
+                        await this.slashHandler(t);
+                        // After slash command, ask again
+                        console.log(chalk.dim('  (r = reintentar  /model  /provider  c = cancelar)'));
+                        continue;
+                    }
+                    console.log(chalk.dim('  r = reintentar · /model · /provider · c = cancelar'));
+                }
+                // Retry — loop back to runClarification
+            }
+        }
         // ══════════════════════════════════════════════════
         // FASE 1 — Planificacion (Orchestrator)
         // ══════════════════════════════════════════════════
@@ -1698,7 +1952,7 @@ REGLAS DE PATHS:
         while (true) {
             try {
                 log.section('FASE 1 — Planificacion');
-                const result = await this.runOrchestrator(refinedTask);
+                const result = await this.runOrchestrator(clarification.task, clarification.specPath, clarification.featureId);
                 taskId = result.taskId;
                 plan = result.plan;
                 break;

package/dist/utils/gemini.d.ts

@@ -0,0 +1,17 @@
+export interface GeminiKeyConfig {
+    api_key: string;
+    model: string;
+}
+export declare function loadGeminiApiKey(): Promise<GeminiKeyConfig | null>;
+export declare function saveGeminiApiKey(cfg: GeminiKeyConfig): Promise<void>;
+export declare function deleteGeminiApiKey(): Promise<void>;
+export declare function geminiAuthStatus(): Promise<{
+    authenticated: boolean;
+    model?: string;
+}>;
+/**
+ * Call Gemini API directly using @google/generative-ai.
+ * When onData is provided, streams response chunks as they arrive.
+ */
+export declare function callGeminiAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
+export declare const GEMINI_MODELS: string[];

package/dist/utils/gemini.js

@@ -0,0 +1,95 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { AGENT_HOME } from './config.js';
+const GEMINI_KEY_FILE = path.join(AGENT_HOME, 'gemini_key.json');
+export async function loadGeminiApiKey() {
+    try {
+        const content = await fs.readFile(GEMINI_KEY_FILE, 'utf-8');
+        const cfg = JSON.parse(content);
+        if (!cfg.api_key)
+            return null;
+        return cfg;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveGeminiApiKey(cfg) {
+    await fs.mkdir(AGENT_HOME, { recursive: true });
+    await fs.writeFile(GEMINI_KEY_FILE, JSON.stringify(cfg, null, 2), 'utf-8');
+}
+export async function deleteGeminiApiKey() {
+    await fs.unlink(GEMINI_KEY_FILE).catch(() => { });
+}
+export async function geminiAuthStatus() {
+    const cfg = await loadGeminiApiKey();
+    if (!cfg?.api_key)
+        return { authenticated: false };
+    return { authenticated: true, model: cfg.model };
+}
+/**
+ * Call Gemini API directly using @google/generative-ai.
+ * When onData is provided, streams response chunks as they arrive.
+ */
+export async function callGeminiAPI(prompt, model = 'gemini-2.5-flash', onData) {
+    const cfg = await loadGeminiApiKey();
+    if (!cfg?.api_key) {
+        throw new Error('GEMINI_NOT_CONFIGURED: Run /login y elegí Google Gemini');
+    }
+    const useModel = (model && model !== 'gemini-model') ? model : cfg.model;
+    const genAI = new GoogleGenerativeAI(cfg.api_key);
+    const gemini = genAI.getGenerativeModel({ model: useModel });
+    const MAX_RETRIES = 3;
+    let lastErr;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            if (!onData) {
+                const result = await gemini.generateContent(prompt);
+                return result.response.text();
+            }
+            const streamResult = await gemini.generateContentStream(prompt);
+            let fullText = '';
+            for await (const chunk of streamResult.stream) {
+                const delta = chunk.text();
+                if (delta) {
+                    fullText += delta;
+                    onData(delta);
+                }
+            }
+            return fullText;
+        }
+        catch (err) {
+            lastErr = err;
+            const msg = err?.message ?? '';
+            // 429 — extract retryDelay and wait
+            if (msg.includes('429') || msg.includes('Too Many Requests')) {
+                // Check for "limit: 0" — free tier doesn't support this model at all
+                if (msg.includes('limit: 0')) {
+                    throw new Error(`GEMINI_QUOTA_ZERO: El modelo ${useModel} requiere plan de pago en Google AI.\n` +
+                        `  Cambiá a un modelo gratuito con /model (ej: gemini-2.5-flash o gemini-1.5-flash).`);
+                }
+                // Extract retry delay in seconds from error
+                const delayMatch = msg.match(/retryDelay["\s:]+(\d+)s/) || msg.match(/retry in ([\d.]+)s/);
+                const delaySecs = delayMatch ? Math.ceil(parseFloat(delayMatch[1])) : 15;
+                if (attempt < MAX_RETRIES) {
+                    onData?.(`\n[Gemini 429 — reintentando en ${delaySecs}s...]`);
+                    await new Promise(r => setTimeout(r, delaySecs * 1000));
+                    continue;
+                }
+                throw new Error(`GEMINI_QUOTA_EXCEEDED: Cuota agotada en ${useModel}. Usá /model para cambiar de modelo.`);
+            }
+            // Other errors — don't retry
+            throw err;
+        }
+    }
+    throw lastErr;
+}
+export const GEMINI_MODELS = [
+    'gemini-flash-latest',
+    'gemini-2.5-flash',
+    'gemini-2.0-flash',
+    'gemini-1.5-flash',
+    'gemini-2.5-pro',
+    'gemini-1.5-pro',
+];

package/package.json

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