agent-mp 0.5.23 → 0.5.25

package/dist/commands/repl.d.ts

@@ -1,4 +1,3 @@
-import * as readline from 'readline';
 import { CliInfo } from '../types.js';
 import { Session } from '../utils/sessions.js';
 /**
@@ -17,7 +16,6 @@ export declare function initCoordinator(): Promise<{
         info: CliInfo;
         path: string;
     }>;
-    rl: readline.Interface;
 } | null>;
 /** REPL mode — interactive loop */
 export declare function runRepl(resumeSession?: Session): Promise<void>;

package/dist/commands/repl.js

@@ -795,60 +795,59 @@ export async function initCoordinator() {
         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);
-    // ── Fast-path: 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`));
-        const syntheticCli = {
-            name: apiKeyCfg.provider,
-            info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' },
-            path: 'qwen-direct',
-        };
-        return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed, rl };
-    }
-    // ── No API key — prompt to configure one ─────────────────────────────────
-    console.log(chalk.yellow('\n  No auth configured.'));
-    console.log(chalk.dim('  Configure an API key to continue.\n'));
-    const doSetup = await new Promise((resolve) => {
-        rl.question('  Set up API key now? (y/N): ', (a) => resolve(a.trim().toLowerCase() === 'y'));
-    });
-    if (doSetup) {
-        const askFn = (q) => new Promise((resolve) => rl.question(q, resolve));
-        const ok = await promptApiKeySetup(rl, askFn);
-        if (!ok) {
-            rl.close();
+    try {
+        // 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'));
             return null;
         }
-        const saved = await loadApiKeyConfig();
-        if (!saved) {
-            rl.close();
-            return null;
+        // Step 2: Pick coordinator
+        const auth = await loadAuth();
+        const currentAuth = auth.activeProvider;
+        let activeCli = installed.find((c) => c.name === currentAuth);
+        // Fast-path: 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`));
+            const syntheticCli = {
+                name: apiKeyCfg.provider,
+                info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' },
+                path: 'qwen-direct',
+            };
+            return { activeCli: syntheticCli, installed, coordinatorCmd: gCoordinatorCmd };
         }
-        gCoordinatorCmd = `qwen-direct -m ${saved.model}`;
-        const syntheticCli = {
-            name: saved.provider,
-            info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' },
-            path: 'qwen-direct',
-        };
-        return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed, rl };
+        // No API key — prompt to configure one
+        console.log(chalk.yellow('\n  No auth configured.'));
+        console.log(chalk.dim('  Configure an API key to continue.\n'));
+        const doSetup = await new Promise((resolve) => {
+            rl.question('  Set up API key now? (y/N): ', (a) => resolve(a.trim().toLowerCase() === 'y'));
+        });
+        if (doSetup) {
+            const askFn = (q) => new Promise((resolve) => rl.question(q, resolve));
+            const ok = await promptApiKeySetup(rl, askFn);
+            if (!ok)
+                return null;
+            const saved = await loadApiKeyConfig();
+            if (!saved)
+                return null;
+            gCoordinatorCmd = `qwen-direct -m ${saved.model}`;
+            const syntheticCli = {
+                name: saved.provider,
+                info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' },
+                path: 'qwen-direct',
+            };
+            return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed };
+        }
+        console.log(chalk.dim('  Run: agent-mp setup api-key'));
+        return null;
+    }
+    finally {
+        rl.close();
     }
-    console.log(chalk.dim('  Run: agent-mp setup api-key'));
-    rl.close();
-    return null;
 }
 /** REPL mode — interactive loop */
 export async function runRepl(resumeSession) {
@@ -856,7 +855,6 @@ export async function runRepl(resumeSession) {
     if (!init)
         return;
     const { activeCli } = init;
-    const rl = init.rl;
     const session = resumeSession ?? newSession(process.cwd());
     // Resolve actual project root (may be deeper than cwd)
     const projectDir = await resolveProjectDir(process.cwd());
@@ -879,10 +877,48 @@ export async function runRepl(resumeSession) {
         }
     }
     catch { }
+    // Fixed-bottom input — owns the last terminal rows
+    const fi = new FixedInput();
+    fi.setup();
+    // Helper: run a wizard command that needs readline (suspends fixed input)
+    const withRl = async (fn) => {
+        const resume = fi.suspend();
+        const tempRl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        try {
+            await fn(tempRl);
+        }
+        finally {
+            tempRl.close();
+            resume();
+        }
+    };
+    // Helper to create engine with readline (suspends fixed input)
+    const withEngine = async (fn) => {
+        const resume = fi.suspend();
+        const tempRl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        try {
+            const dir = await resolveProjectDir(process.cwd());
+            const config = await loadProjectConfig(dir);
+            const engine = new AgentEngine(config, dir, gCoordinatorCmd, tempRl, fi, handleCmd);
+            return await fn(engine);
+        }
+        finally {
+            tempRl.close();
+            resume();
+        }
+    };
     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);
+        await withRl(async (tempRl) => {
+            await cmdConfigMulti(tempRl);
+        });
         // Re-check
         try {
             const config = await loadProjectConfig(process.cwd());
@@ -900,7 +936,6 @@ export async function runRepl(resumeSession) {
         catch { }
         if (!hasRoles) {
             console.log(chalk.red('\n  Error: roles no configurados. Saliendo.'));
-            rl.close();
             return;
         }
     }
@@ -932,9 +967,6 @@ export async function runRepl(resumeSession) {
         }
     }
     catch { }
-    // 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();
@@ -954,16 +986,6 @@ export async function runRepl(resumeSession) {
         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();
-        }
-    };
     // 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+/);
@@ -991,58 +1013,53 @@ export async function runRepl(resumeSession) {
                 await cmdStatus(fi);
                 break;
             case 'run': {
-                const dir = await resolveProjectDir(process.cwd());
-                const config = await loadProjectConfig(dir);
-                if (args[0] === 'orch' || args[0] === 'orchestrator') {
-                    // Ensure documentation exists before orchestrator runs
-                    const contextDir = path.join(dir, '.agent', 'context');
-                    const archPath = path.join(contextDir, 'architecture.md');
-                    if (!(await fileExists(archPath))) {
-                        fi.println(chalk.yellow('\n  ── Generando documentación del proyecto ──'));
-                        fi.println(chalk.dim('  El orquestador necesita conocer la estructura del proyecto primero.\n'));
-                        const prepEngine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                        await prepEngine.runExplorer('Document the complete project structure, services, dependencies, and entry points. Create/update .agent/context/architecture.md');
-                        fi.println(chalk.green('  ✓ Documentación del proyecto generada.\n'));
+                await withEngine(async (engine) => {
+                    const dir = await resolveProjectDir(process.cwd());
+                    const config = await loadProjectConfig(dir);
+                    if (args[0] === 'orch' || args[0] === 'orchestrator') {
+                        // Ensure documentation exists before orchestrator runs
+                        const contextDir = path.join(dir, '.agent', 'context');
+                        const archPath = path.join(contextDir, 'architecture.md');
+                        if (!(await fileExists(archPath))) {
+                            fi.println(chalk.yellow('\n  ── Generando documentación del proyecto ──'));
+                            fi.println(chalk.dim('  El orquestador necesita conocer la estructura del proyecto primero.\n'));
+                            await engine.runExplorer('Document the complete project structure, services, dependencies, and entry points. Create/update .agent/context/architecture.md');
+                            fi.println(chalk.green('  ✓ Documentación del proyecto generada.\n'));
+                        }
+                        const task = args.slice(1).join(' ');
+                        const result = await engine.runOrchestrator(task);
+                        fi.println(chalk.green(`  Task ID: ${result.taskId}`));
                     }
-                    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 if (args[0] === 'exp' || args[0] === 'explorer') {
-                    const task = args.slice(1).join(' ');
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                    await engine.runExplorer(task);
-                }
-                else {
-                    const task = args.join(' ');
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                    await engine.runFullCycle(task);
-                }
+                    else if (args[0] === 'impl' || args[0] === 'implementor') {
+                        const taskId = args[1];
+                        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 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 if (args[0] === 'exp' || args[0] === 'explorer') {
+                        const task = args.slice(1).join(' ');
+                        await engine.runExplorer(task);
+                    }
+                    else {
+                        const task = args.join(' ');
+                        await engine.runFullCycle(task);
+                    }
+                });
                 break;
             }
             case 'explorer':
             case 'exp': {
-                const dir = await resolveProjectDir(process.cwd());
-                const config = await loadProjectConfig(dir);
-                const task = args.join(' ');
-                const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                await engine.runExplorer(task);
+                await withEngine(async (engine) => {
+                    const task = args.join(' ');
+                    await engine.runExplorer(task);
+                });
                 break;
             }
             case 'models':
@@ -1062,7 +1079,6 @@ export async function runRepl(resumeSession) {
                 await saveAuth(authStore);
                 fi.println(chalk.dim('  Logged out. Credentials cleared.'));
                 fi.teardown();
-                rl.close();
                 throw new ExitError();
             }
             case 'auth-status':
@@ -1086,7 +1102,6 @@ export async function runRepl(resumeSession) {
             case 'quit':
                 fi.println(chalk.dim('  Bye!'));
                 fi.teardown();
-                rl.close();
                 throw new ExitError();
             default:
                 fi.println(chalk.red(`  Unknown command: /${cmd}`));
@@ -1121,17 +1136,17 @@ export async function runRepl(resumeSession) {
                 }
                 else {
                     // Before running the orchestrator, ensure project documentation exists
-                    const contextDir = path.join(dir, '.agent', 'context');
-                    const archPath = path.join(contextDir, 'architecture.md');
-                    if (!(await fileExists(archPath))) {
-                        fi.println(chalk.yellow('\n  ── Generando documentación del proyecto ──'));
-                        fi.println(chalk.dim('  El orquestador necesita conocer la estructura del proyecto primero.\n'));
-                        const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                        await engine.runExplorer('Document the complete project structure, services, dependencies, and entry points. Create/update .agent/context/architecture.md');
-                        fi.println(chalk.green('  ✓ Documentación del proyecto generada.\n'));
-                    }
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                    await engine.runFullCycle(trimmed);
+                    await withEngine(async (engine) => {
+                        const contextDir = path.join(dir, '.agent', 'context');
+                        const archPath = path.join(contextDir, 'architecture.md');
+                        if (!(await fileExists(archPath))) {
+                            fi.println(chalk.yellow('\n  ── Generando documentación del proyecto ──'));
+                            fi.println(chalk.dim('  El orquestador necesita conocer la estructura del proyecto primero.\n'));
+                            await engine.runExplorer('Document the complete project structure, services, dependencies, and entry points. Create/update .agent/context/architecture.md');
+                            fi.println(chalk.green('  ✓ Documentación del proyecto generada.\n'));
+                        }
+                        await engine.runFullCycle(trimmed);
+                    });
                     session.messages.push({ role: 'agent', content: `[task cycle completed for: ${trimmed}]`, ts: new Date().toISOString() });
                     await saveSession(session);
                 }
@@ -1247,7 +1262,7 @@ export async function runRole(role, arg, model) {
     if (!init)
         process.exit(1);
     const { coordinatorCmd } = init;
-    const rl = init.rl;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const engine = new AgentEngine(config, dir, coordinatorCmd, rl);
     try {
         switch (role.toLowerCase()) {
@@ -1293,5 +1308,4 @@ export async function runRole(role, arg, model) {
         console.log(chalk.red(`  Error: ${err.message}`));
         process.exit(1);
     }
-    rl.close();
 }

package/dist/core/engine.js

@@ -69,7 +69,7 @@ function rebuildCmd(cliName, model, flags) {
 }
 async function ask(prompt, rl, fi) {
     if (fi) {
-        fi.println(chalk.cyan(`  ${prompt}`));
+        fi.println(chalk.cyan(prompt));
         const answer = await fi.readLine();
         // Echo user response right-aligned (chat style, per line)
         const userLines = answer.trim().split('\n').filter(l => l.trim());
@@ -329,17 +329,25 @@ export class AgentEngine {
         if (!this.fi)
             return noop;
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const dotFrames = ['·  ', '·· ', '···'];
         let i = 0;
+        let ti = 0;
         const t0 = Date.now();
         const fi = this.fi;
+        let streaming = false;
         fi.startActivity(`${frames[0]}  ${label}  0s`);
+        fi.setActivityLines([`  ${dotFrames[0]}  esperando respuesta...`]);
         const iv = setInterval(() => {
             const s = Math.floor((Date.now() - t0) / 1000);
+            ti++;
             fi.updateActivityHeader(`${frames[i++ % frames.length]}  ${label}  ${s}s`);
-        }, 100);
+            if (!streaming) {
+                fi.setActivityLines([`  ${dotFrames[ti % dotFrames.length]}  esperando respuesta...`]);
+            }
+        }, 300);
         return {
             stop() { clearInterval(iv); fi.stopActivity(); },
-            push(line) { fi.pushActivity(line); },
+            push(_chunk) { streaming = true; },
         };
     }
     /** Extract readable text lines from a qwen/CLI streaming chunk. */
@@ -409,7 +417,7 @@ INSTRUCCIONES:
                 const model = this.coordinatorCmd.match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'coder-model';
                 const sp = this._startSpinner(`coordinador  ${model}`);
                 try {
-                    const result = await callQwenAPI(prompt, model, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                    const result = await callQwenAPI(prompt, model, (c) => sp.push(c));
                     sp.stop();
                     return result;
                 }
@@ -632,21 +640,10 @@ INSTRUCCIONES:
                 // Fall through: callQwenAPIFromCreds will use the API key config
             }
             const sp = this._startSpinner(`${cliName}  ${model}`);
-            let lineBuf = '';
-            const onChunk = (delta) => {
-                lineBuf += delta;
-                const lines = lineBuf.split('\n');
-                lineBuf = lines.pop() || '';
-                for (const l of lines) {
-                    if (l.trim())
-                        sp.push(l.trim());
-                }
-            };
+            const onChunk = (delta) => sp.push(delta);
             try {
                 log.info(`${cliName}: calling Qwen API with own credentials (${model})`);
                 const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, onChunk);
-                if (lineBuf.trim())
-                    sp.push(lineBuf.trim());
                 sp.stop();
                 return result;
             }
@@ -703,20 +700,9 @@ INSTRUCCIONES:
             const fb = this.config.fallback_global;
             log.warn(`Using global fallback: ${fb.cli} (${fb.model})`);
             const sp = this._startSpinner(`${fb.cli}  ${fb.model}  (fallback)`);
-            let lineBuf = '';
-            const onChunk = (delta) => {
-                lineBuf += delta;
-                const lines = lineBuf.split('\n');
-                lineBuf = lines.pop() || '';
-                for (const l of lines) {
-                    if (l.trim())
-                        sp.push(l.trim());
-                }
-            };
+            const onChunk = (delta) => sp.push(delta);
             try {
                 const globalResult = await callQwenAPI(rolePrompt, fb.model, onChunk);
-                if (lineBuf.trim())
-                    sp.push(lineBuf.trim());
                 sp.stop();
                 trackTokens(globalResult, fb.cli, fb.model);
                 return globalResult;
@@ -1648,6 +1634,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;

package/dist/ui/input.d.ts

@@ -1,41 +1,39 @@
+/**
+ * Inline prompt, styled like Gemini/Qwen CLI.
+ * Draws at the current cursor line; when output arrives we erase the area
+ * (line-by-line, \x1b[2K) and redraw below. No absolute positioning.
+ */
 export declare class FixedInput {
-    private buf;
     private history;
-    private histIdx;
     private origLog;
-    private _pasting;
-    private _pasteAccum;
-    private _drawPending;
     private _activityHeader;
     private _activityLines;
-    private get rows();
+    private _inputBuffer;
+    private _cursorPos;
+    private _pasting;
+    private _pasteAccum;
+    private _resolveInput?;
+    private _inputActive;
+    private _areaRows;
+    private _cursorRow;
+    private _onResize?;
     get cols(): number;
-    private get _reservedRows();
-    private get scrollBottom();
-    private _contentRows;
     setup(): void;
     teardown(): void;
-    redrawBox(): void;
     suspend(): () => void;
-    /** Enter activity mode: show the 5-line log box instead of the input box. */
     startActivity(header: string): void;
-    /** Update the header line (spinner frame + elapsed time) without clearing lines. */
     updateActivityHeader(header: string): void;
-    /**
-     * Append a line to the activity log (keeps last ACTIVITY_LINES lines).
-     * Strips ANSI codes and skips blank or pure-JSON lines.
-     */
     pushActivity(rawLine: string): void;
-    /** Leave activity mode and restore the normal input box. */
+    /** Replace all content lines at once (for streaming preview). */
+    setActivityLines(lines: string[]): void;
     stopActivity(): void;
-    readLine(): Promise<string>;
     println(text: string): void;
     printSeparator(): void;
-    private _scheduleDraw;
-    private _setScrollRegion;
-    private _clearReserved;
-    private _drawBox;
-    private _drawActivityBox;
-    private _drawInputBox;
-    private _wrapText;
+    redrawBox(): void;
+    readLine(): Promise<string>;
+    private _commitPaste;
+    /** Build a string that erases the currently-drawn area and leaves the cursor at col 0 of the top row. */
+    private _buildClear;
+    private _clearArea;
+    private _redraw;
 }

package/dist/ui/input.js

@@ -1,347 +1,409 @@
 import chalk from 'chalk';
-// ─── Midas brand colors ──────────────────────────────────────────────────────
-const T = (s) => chalk.rgb(0, 185, 180)(s); // teal  — borders
-const B = (s) => chalk.rgb(30, 110, 185)(s); // blue  — prompt arrow
-const PREFIX = T('│') + B(' > ');
-const PREFIX_CONT = T('│') + B('   '); // continuation lines
-const PREFIX_COLS = 4; // visual width of "│ > " and "│   "
-// Maximum content rows the input box can grow to (Shift+Enter / word-wrap).
-const MAX_CONTENT_ROWS = 4;
-const ACTIVITY_LINES = 5;
-// Reserved rows at the bottom:
-//   Idle:   7  = 1 status row + up to 4 content + 2 borders
-//   Active: 10 = 7 (activity box) + 3 (input box: 1 content + 2 borders)
-// The scroll region is updated whenever activity mode toggles.
-const IDLE_RESERVED = MAX_CONTENT_ROWS + 3; // 7
-const ACTIVE_RESERVED = ACTIVITY_LINES + 2 + 3; // 10 = activity(7) + input(3)
-// ─── FixedInput ──────────────────────────────────────────────────────────────
+const DIM = chalk.dim;
+const B = (s) => chalk.rgb(30, 110, 185)(s);
+const PROMPT = B('> ');
+const PROMPT_W = 2;
+const INDENT = '  ';
+const PLACEHOLDER = 'Type your message…  (Shift+Enter / \\ para nueva línea)';
+/**
+ * Inline prompt, styled like Gemini/Qwen CLI.
+ * Draws at the current cursor line; when output arrives we erase the area
+ * (line-by-line, \x1b[2K) and redraw below. No absolute positioning.
+ */
 export class FixedInput {
-    buf = '';
     history = [];
-    histIdx = -1;
     origLog;
-    _pasting = false;
-    _pasteAccum = '';
-    _drawPending = false;
-    // ── Activity box state (null = input mode, string = activity mode) ──────────
     _activityHeader = null;
     _activityLines = [];
-    get rows() { return process.stdout.rows || 24; }
+    _inputBuffer = [];
+    _cursorPos = 0;
+    _pasting = false;
+    _pasteAccum = '';
+    _resolveInput;
+    _inputActive = false;
+    // Geometry after the last draw.
+    _areaRows = 0; // total rows the area occupies
+    _cursorRow = 0; // row (0-indexed from top of area) where terminal cursor sits
+    _onResize;
     get cols() { return process.stdout.columns || 80; }
-    get _reservedRows() { return this._activityHeader !== null ? ACTIVE_RESERVED : IDLE_RESERVED; }
-    get scrollBottom() { return this.rows - this._reservedRows; }
-    _contentRows() {
-        // During activity mode only 1 content row fits below the activity box
-        if (this._activityHeader !== null)
-            return 1;
-        const w = this.cols - PREFIX_COLS - 2;
-        if (w <= 0)
-            return 1;
-        if (!this.buf)
-            return 1;
-        let n = 0;
-        for (const seg of this.buf.split('\n'))
-            n += Math.max(1, Math.ceil((seg.length || 1) / w));
-        return Math.min(n, MAX_CONTENT_ROWS);
-    }
-    // ── Lifecycle ──────────────────────────────────────────────────────────────
     setup() {
         this.origLog = console.log;
         console.log = (...args) => {
-            const text = args.map(a => (typeof a === 'string' ? a : String(a))).join(' ');
+            const text = args.map(a => typeof a === 'string' ? a : String(a)).join(' ');
             this.println(text);
         };
-        this._setScrollRegion();
-        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
-        this._clearReserved();
-        this._drawBox();
         process.stdout.write('\x1b[?2004h');
-        process.stdout.on('resize', () => {
-            this._setScrollRegion();
-            this._clearReserved();
-            this._drawBox();
-        });
+        this._onResize = () => this._redraw();
+        process.stdout.on('resize', this._onResize);
     }
     teardown() {
-        this._activityHeader = null;
-        this._activityLines = [];
         console.log = this.origLog;
         process.stdout.write('\x1b[?2004l');
-        process.stdout.write('\x1b[r');
-        process.stdout.write('\x1b[?25h');
-        process.stdout.write(`\x1b[${this.rows};1H\n`);
+        if (this._onResize)
+            process.stdout.off('resize', this._onResize);
     }
-    redrawBox() { this._drawBox(); }
     suspend() {
+        this._clearArea();
         console.log = this.origLog;
         process.stdout.write('\x1b[?2004l');
-        process.stdout.write('\x1b[r');
-        this._clearReserved();
-        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
         return () => {
             console.log = (...args) => {
-                const text = args.map(a => (typeof a === 'string' ? a : String(a))).join(' ');
+                const text = args.map(a => typeof a === 'string' ? a : String(a)).join(' ');
                 this.println(text);
             };
-            this._setScrollRegion();
-            this._clearReserved();
-            this._drawBox();
             process.stdout.write('\x1b[?2004h');
+            this._redraw();
         };
     }
-    // ── Activity box API ───────────────────────────────────────────────────────
-    /** Enter activity mode: show the 5-line log box instead of the input box. */
     startActivity(header) {
         this._activityHeader = header;
         this._activityLines = [];
-        this._setScrollRegion();
-        this._drawBox();
+        this._redraw();
     }
-    /** Update the header line (spinner frame + elapsed time) without clearing lines. */
     updateActivityHeader(header) {
         this._activityHeader = header;
-        this._drawBox();
+        this._redraw();
     }
-    /**
-     * Append a line to the activity log (keeps last ACTIVITY_LINES lines).
-     * Strips ANSI codes and skips blank or pure-JSON lines.
-     */
     pushActivity(rawLine) {
         if (this._activityHeader === null)
             return;
-        // Strip ANSI escape sequences
-        const clean = rawLine
-            .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
-            .replace(/[^\x20-\x7e\u00a0-\uffff]/g, '')
-            .trim();
+        const clean = rawLine.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').trim();
         if (!clean)
             return;
         this._activityLines.push(clean);
-        if (this._activityLines.length > ACTIVITY_LINES)
+        if (this._activityLines.length > 5)
             this._activityLines.shift();
-        this._scheduleDraw();
+        this._redraw();
+    }
+    /** Replace all content lines at once (for streaming preview). */
+    setActivityLines(lines) {
+        if (this._activityHeader === null)
+            return;
+        this._activityLines = lines.map(l => l.slice(0, this.cols - 4));
+        this._redraw();
     }
-    /** Leave activity mode and restore the normal input box. */
     stopActivity() {
-        // Explicitly clear the full ACTIVE reserved zone before shrinking
-        // the scroll region — otherwise activity box rows bleed into scroll history.
-        const activeSB = this.rows - ACTIVE_RESERVED;
-        for (let r = activeSB + 1; r <= this.rows; r++)
-            process.stdout.write(`\x1b[${r};1H\x1b[2K`);
         this._activityHeader = null;
         this._activityLines = [];
-        this._setScrollRegion();
-        this._drawBox();
+        this._redraw();
+    }
+    println(text) {
+        this._clearArea();
+        process.stdout.write(text + '\n');
+        this._redraw();
+    }
+    printSeparator() {
+        this._clearArea();
+        process.stdout.write(DIM('─'.repeat(this.cols - 1)) + '\n');
+        this._redraw();
+    }
+    redrawBox() {
+        this._redraw();
     }
-    // ── Input ──────────────────────────────────────────────────────────────────
     readLine() {
-        this.buf = '';
-        this.histIdx = -1;
-        this._drawBox();
-        return new Promise((resolve) => {
+        this._inputBuffer = [];
+        this._cursorPos = 0;
+        this._inputActive = true;
+        this._redraw();
+        if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
-            process.stdin.resume();
-            const done = (line) => {
+        process.stdin.resume();
+        return new Promise((resolve) => {
+            this._resolveInput = resolve;
+            const finish = (value) => {
+                this._inputActive = false;
+                this._clearArea();
                 process.stdin.removeListener('data', onData);
                 if (process.stdin.isTTY)
                     process.stdin.setRawMode(false);
-                this.buf = '';
-                this._drawBox();
-                resolve(line);
+                process.stdin.pause();
+                const r = this._resolveInput;
+                this._resolveInput = undefined;
+                r?.(value);
             };
             const onData = (data) => {
-                const hex = data.toString('hex');
                 const key = data.toString();
-                // ── Bracketed paste: start ────────────────────────────────────
-                if (key.includes('\x1b[200~')) {
+                const hex = data.toString('hex');
+                // Bracketed paste start (may include end marker in same chunk).
+                if (!this._pasting && key.includes('\x1b[200~')) {
                     this._pasting = true;
                     this._pasteAccum = '';
-                    const after = key.slice(key.indexOf('\x1b[200~') + 6);
-                    if (after)
-                        this._pasteAccum += after;
+                    const afterStart = key.slice(key.indexOf('\x1b[200~') + 6);
+                    const endIdx = afterStart.indexOf('\x1b[201~');
+                    if (endIdx !== -1) {
+                        this._pasteAccum += afterStart.slice(0, endIdx);
+                        this._commitPaste();
+                    }
+                    else {
+                        this._pasteAccum += afterStart;
+                    }
                     return;
                 }
-                // ── Bracketed paste: accumulate ───────────────────────────────
                 if (this._pasting) {
-                    if (key.includes('\x1b[201~')) {
-                        const before = key.slice(0, key.indexOf('\x1b[201~'));
-                        this._pasteAccum += before;
-                        this.buf += this._pasteAccum;
-                        this._pasting = false;
-                        this._pasteAccum = '';
-                        this._scheduleDraw();
+                    const endIdx = key.indexOf('\x1b[201~');
+                    if (endIdx !== -1) {
+                        this._pasteAccum += key.slice(0, endIdx);
+                        this._commitPaste();
                     }
                     else {
                         this._pasteAccum += key;
                     }
                     return;
                 }
-                // ── Shift+Enter → newline ────────────────────────────────────
-                if (hex === '5c0d' ||
-                    key === '\x0a' ||
-                    hex === '1b5b31333b327e' ||
-                    hex === '1b5b31333b3275' ||
-                    hex === '1b4f4d') {
-                    this.buf += '\n';
-                    this._scheduleDraw();
-                    // ── Enter → submit ───────────────────────────────────────────
-                }
-                else if (key === '\r') {
-                    const line = this.buf;
+                // Enter — submit
+                if (key === '\r') {
+                    const line = this._inputBuffer.join('');
                     if (line.trim()) {
                         this.history.unshift(line);
                         if (this.history.length > 200)
                             this.history.pop();
                     }
-                    done(line);
+                    finish(line);
+                    return;
+                }
+                // Ctrl+J (LF) — insert newline
+                if (key === '\n') {
+                    this._inputBuffer.splice(this._cursorPos, 0, '\n');
+                    this._cursorPos++;
+                    this._redraw();
+                    return;
+                }
+                // Backspace
+                if (key === '\x7f' || key === '\x08') {
+                    if (this._cursorPos > 0) {
+                        this._inputBuffer.splice(this._cursorPos - 1, 1);
+                        this._cursorPos--;
+                        this._redraw();
+                    }
+                    return;
                 }
-                else if (key === '\x7f' || key === '\x08') {
-                    if (this.buf.length > 0) {
-                        this.buf = this.buf.slice(0, -1);
-                        this._scheduleDraw();
+                // Delete
+                if (hex === '1b5b337e') {
+                    if (this._cursorPos < this._inputBuffer.length) {
+                        this._inputBuffer.splice(this._cursorPos, 1);
+                        this._redraw();
                     }
+                    return;
                 }
-                else if (key === '\x03') {
+                // Ctrl+C
+                if (key === '\x03') {
+                    this._clearArea();
+                    if (process.stdin.isTTY)
+                        process.stdin.setRawMode(false);
+                    process.stdin.pause();
                     this.teardown();
                     process.exit(0);
                 }
-                else if (key === '\x04') {
-                    done('/exit');
+                // Ctrl+D
+                if (key === '\x04') {
+                    finish('/exit');
+                    return;
+                }
+                // Ctrl+U — clear line
+                if (key === '\x15') {
+                    this._inputBuffer = [];
+                    this._cursorPos = 0;
+                    this._redraw();
+                    return;
+                }
+                // Ctrl+W / Alt+Backspace — delete prev word
+                if (key === '\x17' || hex === '1b7f') {
+                    const before = this._inputBuffer.slice(0, this._cursorPos).join('').trimEnd();
+                    const lastSpace = before.lastIndexOf(' ');
+                    const newPos = lastSpace === -1 ? 0 : lastSpace + 1;
+                    this._inputBuffer = [
+                        ...this._inputBuffer.slice(0, newPos),
+                        ...this._inputBuffer.slice(this._cursorPos),
+                    ];
+                    this._cursorPos = newPos;
+                    this._redraw();
+                    return;
                 }
-                else if (key === '\x15') {
-                    this.buf = '';
-                    this._scheduleDraw();
+                // Ctrl+A / Home
+                if (key === '\x01' || hex === '1b5b48' || hex === '1b4f48') {
+                    this._cursorPos = 0;
+                    this._redraw();
+                    return;
+                }
+                // Ctrl+E / End
+                if (key === '\x05' || hex === '1b5b46' || hex === '1b4f46') {
+                    this._cursorPos = this._inputBuffer.length;
+                    this._redraw();
+                    return;
                 }
-                else if (hex === '1b5b41') { // Arrow ↑
-                    if (this.histIdx + 1 < this.history.length) {
-                        this.histIdx++;
-                        this.buf = this.history[this.histIdx];
-                        this._scheduleDraw();
+                // Arrow Left
+                if (hex === '1b5b44') {
+                    if (this._cursorPos > 0) {
+                        this._cursorPos--;
+                        this._redraw();
                     }
+                    return;
                 }
-                else if (hex === '1b5b42') { // Arrow ↓
-                    if (this.histIdx > 0) {
-                        this.histIdx--;
-                        this.buf = this.history[this.histIdx];
+                // Arrow Right
+                if (hex === '1b5b43') {
+                    if (this._cursorPos < this._inputBuffer.length) {
+                        this._cursorPos++;
+                        this._redraw();
                     }
-                    else {
-                        this.histIdx = -1;
-                        this.buf = '';
+                    return;
+                }
+                // Arrow Up — last history
+                if (hex === '1b5b41') {
+                    if (this.history.length > 0) {
+                        this._inputBuffer = this.history[0].split('');
+                        this._cursorPos = this._inputBuffer.length;
+                        this._redraw();
                     }
-                    this._scheduleDraw();
+                    return;
                 }
-                else if (key.length >= 1 && key.charCodeAt(0) >= 32 && !key.startsWith('\x1b')) {
-                    this.buf += key;
-                    this._scheduleDraw();
+                // Arrow Down — clear
+                if (hex === '1b5b42') {
+                    if (this._inputBuffer.length > 0) {
+                        this._inputBuffer = [];
+                        this._cursorPos = 0;
+                        this._redraw();
+                    }
+                    return;
+                }
+                // Shift/Alt+Enter — insert newline (various terminals)
+                if (hex === '1b0d' || hex === '1b0a' ||
+                    hex === '1b5b31333b327e' || hex === '1b5b31333b3275' ||
+                    hex === '1b4f4d') {
+                    this._inputBuffer.splice(this._cursorPos, 0, '\n');
+                    this._cursorPos++;
+                    this._redraw();
+                    return;
+                }
+                // Regular typed characters.
+                // Shift+Enter fallback: gnome-terminal sends '\' + LF (or sometimes just '\').
+                // Collapse a '\' — with an optional trailing LF/CR — into a single newline.
+                // Literal '\' still works through paste (Ctrl+Shift+V) since that path is
+                // handled by the bracketed-paste branch.
+                if (key.length >= 1 && !key.startsWith('\x1b')) {
+                    const raw = [...key];
+                    const chars = [];
+                    for (let i = 0; i < raw.length; i++) {
+                        const c = raw[i];
+                        if (c === '\\') {
+                            chars.push('\n');
+                            if (raw[i + 1] === '\n' || raw[i + 1] === '\r')
+                                i++;
+                            continue;
+                        }
+                        if (c === '\n' || c.charCodeAt(0) >= 32)
+                            chars.push(c);
+                    }
+                    if (chars.length) {
+                        this._inputBuffer.splice(this._cursorPos, 0, ...chars);
+                        this._cursorPos += chars.length;
+                        this._redraw();
+                    }
                 }
             };
             process.stdin.on('data', onData);
         });
     }
-    // ── Output helpers ─────────────────────────────────────────────────────────
-    println(text) {
-        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
-        process.stdout.write(text + '\n');
-        this._drawBox();
+    _commitPaste() {
+        const text = this._pasteAccum.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        const chars = [...text];
+        this._inputBuffer.splice(this._cursorPos, 0, ...chars);
+        this._cursorPos += chars.length;
+        this._pasting = false;
+        this._pasteAccum = '';
+        this._redraw();
     }
-    printSeparator() {
-        this.println(chalk.rgb(0, 120, 116)('─'.repeat(this.cols - 1)));
-    }
-    // ── Private drawing ────────────────────────────────────────────────────────
-    _scheduleDraw() {
-        if (this._drawPending)
-            return;
-        this._drawPending = true;
-        setImmediate(() => { this._drawPending = false; this._drawBox(); });
-    }
-    _setScrollRegion() {
-        const sb = this.scrollBottom;
-        if (sb >= 1)
-            process.stdout.write(`\x1b[1;${sb}r`);
-    }
-    _clearReserved() {
-        for (let r = this.scrollBottom + 1; r <= this.rows; r++)
-            process.stdout.write(`\x1b[${r};1H\x1b[2K`);
-    }
-    _drawBox() {
-        process.stdout.write('\x1b[?25l');
-        this._clearReserved();
-        if (this._activityHeader !== null) {
-            this._drawActivityBox();
+    /** Build a string that erases the currently-drawn area and leaves the cursor at col 0 of the top row. */
+    _buildClear() {
+        if (this._areaRows === 0)
+            return '';
+        let s = '\r';
+        // Move up to first row of area.
+        if (this._cursorRow > 0)
+            s += `\x1b[${this._cursorRow}A`;
+        // Clear each row (line-by-line — most portable).
+        for (let i = 0; i < this._areaRows; i++) {
+            s += '\x1b[2K';
+            if (i < this._areaRows - 1)
+                s += '\x1b[1B';
         }
-        this._drawInputBox();
-        process.stdout.write('\x1b[?25h');
+        // Back to first row, col 0.
+        if (this._areaRows > 1)
+            s += `\x1b[${this._areaRows - 1}A`;
+        s += '\r';
+        return s;
     }
-    // ── Activity box (shown while a subagent is running) ───────────────────────
-    _drawActivityBox() {
-        const cols = this.cols;
-        const inner = cols - 4; // │ + space + content + space + │
-        const topRow = this.scrollBottom + 1;
-        const header = (this._activityHeader || '').slice(0, cols - 4);
-        const dashFill = Math.max(0, cols - 3 - header.length);
-        // Top border with header text
-        process.stdout.write(`\x1b[${topRow};1H`);
-        process.stdout.write(T('╭─') + chalk.bold.white(header) + T('─'.repeat(dashFill)) + T('╮'));
-        // Content rows (last ACTIVITY_LINES lines, or blank)
-        for (let i = 0; i < ACTIVITY_LINES; i++) {
-            const row = topRow + 1 + i;
-            const line = (this._activityLines[i] ?? '').slice(0, inner);
-            const pad = inner - line.length;
-            process.stdout.write(`\x1b[${row};1H`);
-            process.stdout.write(T('│') + ' ' + chalk.rgb(180, 210, 210)(line) + ' '.repeat(pad) + ' ' + T('│'));
-        }
-        // Bottom border
-        process.stdout.write(`\x1b[${topRow + ACTIVITY_LINES + 1};1H`);
-        process.stdout.write(T('╰') + T('─'.repeat(cols - 2)) + T('╯'));
+    _clearArea() {
+        const s = this._buildClear();
+        if (s)
+            process.stdout.write(s);
+        this._areaRows = 0;
+        this._cursorRow = 0;
     }
-    // ── Normal input box ───────────────────────────────────────────────────────
-    _drawInputBox() {
+    _redraw() {
+        const clear = this._buildClear();
+        if (!this._inputActive && this._activityHeader === null) {
+            if (clear)
+                process.stdout.write(clear);
+            this._areaRows = 0;
+            this._cursorRow = 0;
+            return;
+        }
         const cols = this.cols;
-        const cRows = this._contentRows();
-        const cWidth = cols - PREFIX_COLS - 2;
-        const topBorder = this.rows - cRows - 1;
-        // ── Top border ───────────────────────────────────────────────
-        process.stdout.write(`\x1b[${topBorder};1H`);
-        process.stdout.write(T('╭') + T('─'.repeat(cols - 2)));
-        process.stdout.write(`\x1b[${cols}G` + T('╮'));
-        // ── Content rows ─────────────────────────────────────────────
-        const wrapped = this._wrapText(this.buf, cWidth);
-        const showStart = Math.max(0, wrapped.length - cRows);
-        const visible = wrapped.slice(showStart);
-        for (let i = 0; i < cRows; i++) {
-            const row = topBorder + 1 + i;
-            let line = visible[i] ?? '';
-            if (i === 0 && showStart > 0)
-                line = '… ' + line.slice(0, Math.max(0, cWidth - 2));
-            else
-                line = line.slice(0, cWidth);
-            const pfx = (i === 0) ? PREFIX : PREFIX_CONT;
-            process.stdout.write(`\x1b[${row};1H`);
-            process.stdout.write(pfx + line);
-            process.stdout.write(`\x1b[${cols}G` + T('│'));
+        let body = '';
+        let row = 0;
+        let cursorRow = 0;
+        let cursorCol = 0;
+        // Activity box
+        if (this._activityHeader !== null) {
+            const header = (this._activityHeader || '').slice(0, cols - 4);
+            const topPad = Math.max(0, cols - 3 - header.length);
+            body += DIM('┌') + chalk.bold.white(header) + DIM('─'.repeat(topPad) + '┐') + '\n';
+            row++;
+            for (let i = 0; i < 5; i++) {
+                const line = (this._activityLines[i] ?? '').slice(0, cols - 4);
+                const pad = Math.max(0, cols - 4 - line.length);
+                body += DIM('│') + ' ' + chalk.rgb(180, 210, 210)(line) + ' '.repeat(pad) + ' ' + DIM('│') + '\n';
+                row++;
+            }
+            body += DIM('└') + DIM('─'.repeat(cols - 2)) + DIM('┘') + '\n';
+            row++;
         }
-        // ── Bottom border ────────────────────────────────────────────
-        process.stdout.write(`\x1b[${this.rows};1H`);
-        process.stdout.write(T('╰') + T('─'.repeat(cols - 2)));
-        process.stdout.write(`\x1b[${cols}G` + T('╯'));
-        // ── Position cursor ──────────────────────────────────────────
-        const lastLine = visible[visible.length - 1] ?? '';
-        const cursorRow = topBorder + cRows;
-        const cursorCol = PREFIX_COLS + 1 + lastLine.length;
-        process.stdout.write(`\x1b[${cursorRow};${cursorCol}H`);
-    }
-    _wrapText(text, maxWidth) {
-        if (!text || maxWidth <= 0)
-            return [''];
-        const result = [];
-        for (const seg of text.split('\n')) {
-            if (seg.length === 0) {
-                result.push('');
-                continue;
+        let trailing = '';
+        let lastRow = row;
+        if (this._inputActive) {
+            const text = this._inputBuffer.join('');
+            const beforeCursor = this._inputBuffer.slice(0, this._cursorPos).join('');
+            const cursorLineIdx = beforeCursor.split('\n').length - 1;
+            const cursorColInLine = (beforeCursor.split('\n').pop() ?? '').length;
+            const logicalLines = text.length === 0 ? [''] : text.split('\n');
+            const displayLines = logicalLines.map((l, i) => (i === 0 ? PROMPT : INDENT) + (text === '' ? DIM(PLACEHOLDER) : l.slice(0, Math.max(0, cols - 3))));
+            for (let i = 0; i < displayLines.length; i++) {
+                const isLast = i === displayLines.length - 1;
+                body += displayLines[i] + (isLast ? '' : '\n');
+                if (i === cursorLineIdx) {
+                    cursorRow = row;
+                    cursorCol = PROMPT_W + Math.min(cursorColInLine, Math.max(0, cols - 3));
+                }
+                if (!isLast)
+                    row++;
             }
-            for (let i = 0; i < seg.length; i += maxWidth)
-                result.push(seg.slice(i, i + maxWidth));
+            lastRow = row;
+            // After writing the body, terminal cursor is at end of last drawn line. Reposition to (cursorRow, cursorCol).
+            trailing = '\r';
+            const upBy = lastRow - cursorRow;
+            if (upBy > 0)
+                trailing += `\x1b[${upBy}A`;
+            if (cursorCol > 0)
+                trailing += `\x1b[${cursorCol}C`;
+            this._areaRows = lastRow + 1;
+            this._cursorRow = cursorRow;
+        }
+        else {
+            // Activity-only — leave cursor on the blank line just below the box.
+            this._areaRows = row;
+            this._cursorRow = row;
         }
-        return result;
+        // Single atomic write: clear + body + reposition.
+        process.stdout.write(clear + body + trailing);
     }
 }

package/package.json

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