agent-mp 0.4.1 → 0.4.3

package/dist/commands/repl.js

@@ -716,12 +716,10 @@ function cmdHelp(fi) {
         { key: '/setup explorer', value: 'Reconfigure explorer only' },
         { key: '/config-multi', value: 'Reconfigure all agents at once' },
         { key: '/status', value: 'Show current configuration and tasks' },
-        { key: '/explorer <task>', value: 'Run explorer agent on a task/question' },
         { key: '/run <task>', value: 'Full cycle: orchestrator → implementor → reviewer' },
         { key: '/run orch <task>', value: 'Run only orchestrator' },
         { key: '/run impl <id>', value: 'Run only implementor' },
         { key: '/run rev <id>', value: 'Run only reviewer' },
-        { key: '/run explorer <task>', value: 'Run only explorer' },
         { key: '/models', value: 'List models for all installed CLIs' },
         { key: '/models <cli>', value: 'List models for a specific CLI' },
         { key: '/login', value: 'Login (Qwen OAuth or CLI auth)' },
@@ -1037,12 +1035,6 @@ export async function runRepl(resumeSession) {
                     const progress = await readJson(path.join(taskDir, 'progress.json'));
                     await engine.runReviewer(taskId, plan, progress);
                 }
-                else if (args[0] === 'explorer' || args[0] === 'exp') {
-                    const task = args.slice(1).join(' ') || undefined;
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                    const result = await engine.runExplorer(task);
-                    fi.println(result);
-                }
                 else {
                     const task = args.join(' ');
                     const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
@@ -1050,20 +1042,6 @@ export async function runRepl(resumeSession) {
                 }
                 break;
             }
-            case 'explorer': {
-                const task = args.join(' ') || undefined;
-                try {
-                    const dir = process.cwd();
-                    const config = await loadProjectConfig(dir);
-                    const engine = new AgentEngine(config, dir, gCoordinatorCmd, rl, fi, handleCmd);
-                    const result = await engine.runExplorer(task);
-                    fi.println(result);
-                }
-                catch (err) {
-                    fi.println(chalk.red(`  Explorer error: ${err.message}`));
-                }
-                break;
-            }
             case 'models':
             case 'model':
                 await withRl((rl) => cmdModels(args[0], fi, rl));
@@ -1225,12 +1203,6 @@ export async function runRole(role, arg, model) {
                 await engine.runReviewer(arg, plan, progress);
                 break;
             }
-            case 'explorer':
-            case 'exp': {
-                const result = await engine.runExplorer(arg || undefined);
-                console.log(result);
-                break;
-            }
             case 'coordinator':
             case 'coord': {
                 console.log(chalk.yellow('  Coordinator mode requires interactive REPL.'));
@@ -1238,7 +1210,7 @@ export async function runRole(role, arg, model) {
                 process.exit(1);
             }
             default:
-                console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer, explorer`));
+                console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer`));
                 process.exit(1);
         }
     }

package/dist/core/engine.d.ts

@@ -16,8 +16,10 @@ export declare class AgentEngine {
     private totalTokens;
     private phaseTokens;
     constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string, rl?: readline.Interface, fi?: FixedInput, slashHandler?: SlashHandler);
-    /** Start an animated spinner on the status row. Returns a stop function. */
+    /** Start the activity box for a subagent call. Returns { stop, push }. */
     private _startSpinner;
+    /** Extract readable text lines from a qwen/CLI streaming chunk. */
+    private _parseChunk;
     /**
      * FASE 0 — Clarificacion con el programador.
      * El coordinador (CLI activo, ej: Qwen) conversa con el usuario

package/dist/core/engine.js

@@ -219,19 +219,54 @@ export class AgentEngine {
         this.fi = fi;
         this.slashHandler = slashHandler;
     }
-    /** Start an animated spinner on the status row. Returns a stop function. */
+    /** Start the activity box for a subagent call. Returns { stop, push }. */
     _startSpinner(label) {
+        const noop = { stop() { }, push(_) { } };
         if (!this.fi)
-            return () => { };
+            return noop;
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let i = 0;
         const t0 = Date.now();
         const fi = this.fi;
+        fi.startActivity(`${frames[0]}  ${label}  0s`);
         const iv = setInterval(() => {
             const s = Math.floor((Date.now() - t0) / 1000);
-            fi.setStatus(`  ${frames[i++ % frames.length]}  ${label}  ${s}s`);
+            fi.updateActivityHeader(`${frames[i++ % frames.length]}  ${label}  ${s}s`);
         }, 100);
-        return () => { clearInterval(iv); fi.setStatus(null); };
+        return {
+            stop() { clearInterval(iv); fi.stopActivity(); },
+            push(line) { fi.pushActivity(line); },
+        };
+    }
+    /** Extract readable text lines from a qwen/CLI streaming chunk. */
+    _parseChunk(chunk) {
+        const out = [];
+        for (const raw of chunk.split('\n')) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            // Try to extract text from JSON streaming events
+            if (line.startsWith('{')) {
+                try {
+                    const obj = JSON.parse(line);
+                    const text = obj.result ||
+                        obj.data?.content ||
+                        obj.message?.content?.[0]?.text ||
+                        obj.choices?.[0]?.delta?.content ||
+                        obj.choices?.[0]?.message?.content ||
+                        '';
+                    if (text.trim())
+                        out.push(text.trim());
+                    continue;
+                }
+                catch { /* not JSON — fall through */ }
+            }
+            // Skip lines that look like SSE metadata
+            if (line.startsWith('data:') || line.startsWith('event:') || line === '[DONE]')
+                continue;
+            out.push(line);
+        }
+        return out;
     }
     /**
      * FASE 0 — Clarificacion con el programador.
@@ -268,14 +303,14 @@ INSTRUCCIONES:
                 // 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 stopSpin = this._startSpinner(`coordinador  ${model}`);
+                const sp = this._startSpinner(`coordinador  ${model}`);
                 try {
-                    const result = await callQwenAPI(prompt, model);
-                    stopSpin();
+                    const result = await callQwenAPI(prompt, model, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                    sp.stop();
                     return result;
                 }
                 catch (err) {
-                    stopSpin();
+                    sp.stop();
                     if (err.message?.startsWith('QWEN_AUTH_EXPIRED')) {
                         console.log(chalk.red('\n  ✗ Sesión Qwen expirada.'));
                         console.log(chalk.yellow('  Ejecutá: /login  para re-autenticarte.\n'));
@@ -287,9 +322,9 @@ INSTRUCCIONES:
                 }
             }
             else {
-                const stopSpin = this._startSpinner(`coordinador`);
+                const sp = this._startSpinner(`coordinador`);
                 res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
-                stopSpin();
+                sp.stop();
             }
             // Extract readable text — search for JSON array even if there's prefix text
             let responseText = res.output.trim();
@@ -386,19 +421,19 @@ INSTRUCCIONES:
         const rolePrompt = this.buildRolePrompt(roleName, prompt);
         /** Try a cmd, and if it fails, auto-detect flags from --help and retry */
         const tryWithAutoRepair = async (cliName, model, currentCmd) => {
-            const stopSpin = this._startSpinner(`${cliName}  ${model}`);
+            const sp = this._startSpinner(`${cliName}  ${model}`);
             try {
                 const result = await runCli(currentCmd, rolePrompt);
                 if (result.exitCode !== 0) {
-                    stopSpin();
+                    sp.stop();
                     const detail = result.output.trim().slice(0, 500);
                     throw new Error(`${cliName} exited with code ${result.exitCode}${detail ? `\n${detail}` : ''}`);
                 }
-                stopSpin();
+                sp.stop();
                 return result.output;
             }
             catch (err) {
-                stopSpin();
+                sp.stop();
                 log.warn(`${cliName} failed, detecting flags from --help: ${err.message}`);
                 const detected = detectCliFlags(cliName);
                 if (Object.keys(detected).length === 0) {
@@ -450,10 +485,10 @@ INSTRUCCIONES:
                     // Config file might not exist yet
                 }
                 // Retry with new command
-                const stopSpin2 = this._startSpinner(`${cliName}  ${model}  (retry)`);
+                const sp2 = this._startSpinner(`${cliName}  ${model}  (retry)`);
                 try {
                     const result = await runCli(newCmd, rolePrompt);
-                    stopSpin2();
+                    sp2.stop();
                     if (result.exitCode !== 0) {
                         const detail = result.output.trim().slice(0, 500);
                         throw new Error(`${cliName} (repaired) exited with code ${result.exitCode}${detail ? `\n${detail}` : ''}`);
@@ -462,7 +497,7 @@ INSTRUCCIONES:
                     return result.output;
                 }
                 catch (retryErr) {
-                    stopSpin2();
+                    sp2.stop();
                     log.warn(`Repaired ${cliName} also failed: ${retryErr.message}`);
                     return null;
                 }
@@ -479,15 +514,15 @@ INSTRUCCIONES:
                 log.warn(`${cliName} has no credentials — run: ${cliName} --login`);
                 return null;
             }
-            const stopSpin = this._startSpinner(`${cliName}  ${model}`);
+            const sp = this._startSpinner(`${cliName}  ${model}`);
             try {
                 log.info(`${cliName}: calling Qwen API with own credentials (${model})`);
-                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath);
-                stopSpin();
+                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                sp.stop();
                 return result;
             }
             catch (err) {
-                stopSpin();
+                sp.stop();
                 if (err.message?.startsWith('QWEN_AUTH_EXPIRED')) {
                     console.log(chalk.red(`\n  ✗ Sesión expirada para ${cliName}.`));
                     console.log(chalk.yellow(`  Ejecutá: ${cliName} --login\n`));
@@ -953,13 +988,13 @@ REGLAS:
 - Escribe UNICAMENTE los archivos indicados: ${archPath} y ${contextDir}/<servicio>/architecture.md
 - NO crees archivos adicionales ni con otros nombres en ningun directorio`);
         let result;
-        const stopSpin = this._startSpinner(`agent-explorer  ${role.model}`);
+        const sp = this._startSpinner(`agent-explorer  ${role.model}`);
         try {
-            result = await callQwenAPI(prompt, role.model);
-            stopSpin();
+            result = await callQwenAPI(prompt, role.model, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+            sp.stop();
         }
         catch (err) {
-            stopSpin();
+            sp.stop();
             if (err.message?.startsWith('QWEN_AUTH_EXPIRED')) {
                 console.log(chalk.red('\n  ✗ Sesión Qwen expirada.'));
                 console.log(chalk.yellow('  Ejecutá: agent-mp --login  (o agent-explorer --login)\n'));

package/dist/ui/input.d.ts

@@ -6,29 +6,36 @@ export declare class FixedInput {
     private _pasting;
     private _pasteAccum;
     private _drawPending;
-    private _statusText;
+    private _activityHeader;
+    private _activityLines;
     private get rows();
     get cols(): number;
+    private get _reservedRows();
     private get scrollBottom();
     private _contentRows;
     setup(): void;
     teardown(): void;
     redrawBox(): void;
-    /** Show or clear the status / spinner line above the input box. */
-    setStatus(text: string | null): 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. */
+    stopActivity(): void;
     readLine(): Promise<string>;
     println(text: string): void;
     printSeparator(): void;
-    /** Repaint the status row (between scroll region and input box). */
-    private _drawStatusRow;
-    /** Debounced draw: coalesces rapid calls (e.g. during paste) into a single repaint. */
     private _scheduleDraw;
-    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
     private _setScrollRegion;
-    /** Blank every row in the reserved area. */
     private _clearReserved;
     private _drawBox;
-    /** Split text into visual lines: split on \n, then wrap each segment. */
+    private _drawActivityBox;
+    private _drawInputBox;
     private _wrapText;
 }

package/dist/ui/input.js

@@ -5,31 +5,35 @@ 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 box can grow to (Shift+Enter / word-wrap).
-// The reserved area at the bottom is MAX_CONTENT_ROWS + 2 (borders) + 1 (status row).
+// Maximum content rows the input box can grow to (Shift+Enter / word-wrap).
 const MAX_CONTENT_ROWS = 4;
-const RESERVED_ROWS = MAX_CONTENT_ROWS + 3; // 7 = 4 content + 2 borders + 1 status
+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 ──────────────────────────────────────────────────────────────
-// Keeps an input box pinned to the physical bottom of the terminal.
-// The box starts as 3 rows (border + 1 content + border) and grows up to
-// RESERVED_ROWS when the user types multiline text (Shift+Enter) or the
-// text wraps.  The scroll region is set ONCE at setup (and on resize) to
-// [1 .. rows-RESERVED_ROWS] so DECSTBM never fires during normal typing.
 export class FixedInput {
     buf = '';
     history = [];
     histIdx = -1;
     origLog;
-    _pasting = false; // true while inside bracketed paste sequence
-    _pasteAccum = ''; // accumulates paste content between \x1b[200~ and \x1b[201~
-    _drawPending = false; // debounce flag
-    _statusText = ''; // spinner / status line above the input box
+    _pasting = false;
+    _pasteAccum = '';
+    _drawPending = false;
+    // ── Activity box state (null = input mode, string = activity mode) ──────────
+    _activityHeader = null;
+    _activityLines = [];
     get rows() { return process.stdout.rows || 24; }
     get cols() { return process.stdout.columns || 80; }
-    // The scroll region always ends here — everything below is reserved for the box.
-    get scrollBottom() { return this.rows - RESERVED_ROWS; }
-    // How many content rows the current buffer needs (1 .. MAX_CONTENT_ROWS).
+    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;
@@ -51,7 +55,7 @@ export class FixedInput {
         process.stdout.write(`\x1b[${this.scrollBottom};1H`);
         this._clearReserved();
         this._drawBox();
-        process.stdout.write('\x1b[?2004h'); // enable bracketed paste mode
+        process.stdout.write('\x1b[?2004h');
         process.stdout.on('resize', () => {
             this._setScrollRegion();
             this._clearReserved();
@@ -59,21 +63,18 @@ export class FixedInput {
         });
     }
     teardown() {
+        this._activityHeader = null;
+        this._activityLines = [];
         console.log = this.origLog;
-        process.stdout.write('\x1b[?2004l'); // disable bracketed paste mode
-        process.stdout.write('\x1b[r'); // reset scroll region
-        process.stdout.write('\x1b[?25h'); // show cursor
+        process.stdout.write('\x1b[?2004l');
+        process.stdout.write('\x1b[r');
+        process.stdout.write('\x1b[?25h');
         process.stdout.write(`\x1b[${this.rows};1H\n`);
     }
     redrawBox() { this._drawBox(); }
-    /** Show or clear the status / spinner line above the input box. */
-    setStatus(text) {
-        this._statusText = text || '';
-        this._drawBox();
-    }
     suspend() {
         console.log = this.origLog;
-        process.stdout.write('\x1b[?2004l'); // disable bracketed paste while suspended
+        process.stdout.write('\x1b[?2004l');
         process.stdout.write('\x1b[r');
         this._clearReserved();
         process.stdout.write(`\x1b[${this.scrollBottom};1H`);
@@ -85,9 +86,48 @@ export class FixedInput {
             this._setScrollRegion();
             this._clearReserved();
             this._drawBox();
-            process.stdout.write('\x1b[?2004h'); // re-enable bracketed paste mode
+            process.stdout.write('\x1b[?2004h');
         };
     }
+    // ── 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();
+    }
+    /** Update the header line (spinner frame + elapsed time) without clearing lines. */
+    updateActivityHeader(header) {
+        this._activityHeader = header;
+        this._drawBox();
+    }
+    /**
+     * 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();
+        if (!clean)
+            return;
+        this._activityLines.push(clean);
+        if (this._activityLines.length > ACTIVITY_LINES)
+            this._activityLines.shift();
+        this._scheduleDraw();
+    }
+    /** Leave activity mode and restore the normal input box. */
+    stopActivity() {
+        this._activityHeader = null;
+        this._activityLines = [];
+        this._setScrollRegion();
+        this._drawBox();
+    }
     // ── Input ──────────────────────────────────────────────────────────────────
     readLine() {
         this.buf = '';
@@ -111,7 +151,6 @@ export class FixedInput {
                 if (key.includes('\x1b[200~')) {
                     this._pasting = true;
                     this._pasteAccum = '';
-                    // Strip the start marker and handle any content after it in the same chunk
                     const after = key.slice(key.indexOf('\x1b[200~') + 6);
                     if (after)
                         this._pasteAccum += after;
@@ -120,7 +159,6 @@ export class FixedInput {
                 // ── Bracketed paste: accumulate ───────────────────────────────
                 if (this._pasting) {
                     if (key.includes('\x1b[201~')) {
-                        // End marker — append everything before it, then commit
                         const before = key.slice(0, key.indexOf('\x1b[201~'));
                         this._pasteAccum += before;
                         this.buf += this._pasteAccum;
@@ -133,17 +171,15 @@ export class FixedInput {
                     }
                     return;
                 }
-                // ── Shift+Enter → insert newline into buffer ──────────────────
-                // Different terminals send different sequences:
-                if (hex === '5c0d' || // \\\r   (GNOME Terminal, ThinkPad, many Linux)
-                    key === '\x0a' || // LF     (Ctrl+J, some terminals)
-                    hex === '1b5b31333b327e' || // \x1b[13;2~  xterm
-                    hex === '1b5b31333b3275' || // \x1b[13;2u  kitty
-                    hex === '1b4f4d' // \x1bOM       DECNKP
-                ) {
+                // ── Shift+Enter → newline ────────────────────────────────────
+                if (hex === '5c0d' ||
+                    key === '\x0a' ||
+                    hex === '1b5b31333b327e' ||
+                    hex === '1b5b31333b3275' ||
+                    hex === '1b4f4d') {
                     this.buf += '\n';
                     this._scheduleDraw();
-                    // ── Enter → submit ────────────────────────────────────────────
+                    // ── Enter → submit ───────────────────────────────────────────
                 }
                 else if (key === '\r') {
                     const line = this.buf;
@@ -154,20 +190,20 @@ export class FixedInput {
                     }
                     done(line);
                 }
-                else if (key === '\x7f' || key === '\x08') { // Backspace
+                else if (key === '\x7f' || key === '\x08') {
                     if (this.buf.length > 0) {
                         this.buf = this.buf.slice(0, -1);
                         this._scheduleDraw();
                     }
                 }
-                else if (key === '\x03') { // Ctrl+C
+                else if (key === '\x03') {
                     this.teardown();
                     process.exit(0);
                 }
-                else if (key === '\x04') { // Ctrl+D
+                else if (key === '\x04') {
                     done('/exit');
                 }
-                else if (key === '\x15') { // Ctrl+U
+                else if (key === '\x15') {
                     this.buf = '';
                     this._scheduleDraw();
                 }
@@ -207,49 +243,58 @@ export class FixedInput {
         this.println(chalk.rgb(0, 120, 116)('─'.repeat(this.cols - 1)));
     }
     // ── Private drawing ────────────────────────────────────────────────────────
-    /** Repaint the status row (between scroll region and input box). */
-    _drawStatusRow() {
-        const row = this.scrollBottom + 1;
-        process.stdout.write(`\x1b[${row};1H\x1b[2K`);
-        if (this._statusText) {
-            process.stdout.write(chalk.rgb(0, 185, 180)(this._statusText));
-        }
-    }
-    /** Debounced draw: coalesces rapid calls (e.g. during paste) into a single repaint. */
     _scheduleDraw() {
         if (this._drawPending)
             return;
         this._drawPending = true;
-        setImmediate(() => {
-            this._drawPending = false;
-            this._drawBox();
-        });
+        setImmediate(() => { this._drawPending = false; this._drawBox(); });
     }
-    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
     _setScrollRegion() {
         const sb = this.scrollBottom;
         if (sb >= 1)
             process.stdout.write(`\x1b[1;${sb}r`);
     }
-    /** Blank every row in the reserved area. */
     _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();
+        }
+        this._drawInputBox();
+        process.stdout.write('\x1b[?25h');
+    }
+    // ── 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('╯'));
+    }
+    // ── Normal input box ───────────────────────────────────────────────────────
+    _drawInputBox() {
         const cols = this.cols;
         const cRows = this._contentRows();
         const cWidth = cols - PREFIX_COLS - 2;
-        // The box occupies the bottom of the terminal:
-        //   topBorder    = rows - cRows - 1
-        //   content rows = rows - cRows  ...  rows - 1
-        //   bottomBorder = rows
         const topBorder = this.rows - cRows - 1;
-        // Hide cursor while repainting
-        process.stdout.write('\x1b[?25l');
-        // Clear entire reserved area (removes stale content from previous draws)
-        this._clearReserved();
-        this._drawStatusRow();
         // ── Top border ───────────────────────────────────────────────
         process.stdout.write(`\x1b[${topBorder};1H`);
         process.stdout.write(T('╭') + T('─'.repeat(cols - 2)));
@@ -261,7 +306,6 @@ export class FixedInput {
         for (let i = 0; i < cRows; i++) {
             const row = topBorder + 1 + i;
             let line = visible[i] ?? '';
-            // Show overflow indicator when content is clipped above
             if (i === 0 && showStart > 0)
                 line = '… ' + line.slice(0, Math.max(0, cWidth - 2));
             else
@@ -275,18 +319,14 @@ export class FixedInput {
         process.stdout.write(`\x1b[${this.rows};1H`);
         process.stdout.write(T('╰') + T('─'.repeat(cols - 2)));
         process.stdout.write(`\x1b[${cols}G` + T('╯'));
-        // ── Position cursor at end of last visible line ──────────────
+        // ── Position cursor ──────────────────────────────────────────
         const lastLine = visible[visible.length - 1] ?? '';
-        const cursorRow = topBorder + cRows; // last content row
+        const cursorRow = topBorder + cRows;
         const cursorCol = PREFIX_COLS + 1 + lastLine.length;
         process.stdout.write(`\x1b[${cursorRow};${cursorCol}H`);
-        process.stdout.write('\x1b[?25h');
     }
-    /** Split text into visual lines: split on \n, then wrap each segment. */
     _wrapText(text, maxWidth) {
-        if (!text)
-            return [''];
-        if (maxWidth <= 0)
+        if (!text || maxWidth <= 0)
             return [''];
         const result = [];
         for (const seg of text.split('\n')) {

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

@@ -15,7 +15,7 @@ export declare function getQwenAccessToken(): Promise<string | null>;
  * The qwen CLI manages its own token refresh and uses the correct API format.
  * Falls back to direct HTTP call if the qwen CLI is not available.
  */
-export declare function callQwenAPI(prompt: string, model?: string): Promise<string>;
+export declare function callQwenAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
 /**
  * Call Qwen API using credentials from a specific file path (for role binaries).
  * The role binary CLI (e.g. agent-explorer) manages its own qwen auth via the
@@ -23,4 +23,4 @@ export declare function callQwenAPI(prompt: string, model?: string): Promise<str
  * in non-interactive mode without TTY issues.
  * Falls back to direct HTTP if the role binary is not found.
  */
-export declare function callQwenAPIFromCreds(prompt: string, model: string, credsPath: string): Promise<string>;
+export declare function callQwenAPIFromCreds(prompt: string, model: string, credsPath: string, onData?: (chunk: string) => void): Promise<string>;

package/dist/utils/qwen-auth.js

@@ -1,7 +1,25 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as crypto from 'crypto';
-import { spawnSync } from 'child_process';
+import { spawn } from 'child_process';
+/** Async alternative to spawnSync — keeps the event loop free so UI can update. */
+function spawnAsync(bin, args, input, timeout, onData) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        child.stdout?.on('data', (d) => {
+            const s = d.toString();
+            stdout += s;
+            onData?.(s);
+        });
+        child.stderr?.on('data', (d) => { stdout += d.toString(); });
+        const timer = setTimeout(() => { child.kill(); reject(new Error('qwen timeout')); }, timeout);
+        child.on('close', (code) => { clearTimeout(timer); resolve({ stdout, status: code ?? 0 }); });
+        child.on('error', (err) => { clearTimeout(timer); reject(err); });
+        child.stdin?.write(input, 'utf-8');
+        child.stdin?.end();
+    });
+}
 import open from 'open';
 import { AGENT_HOME } from './config.js';
 const QWEN_OAUTH_BASE_URL = 'https://chat.qwen.ai';
@@ -279,17 +297,12 @@ async function callQwenAPIWithToken(token, prompt, model) {
  * The qwen CLI manages its own token refresh and uses the correct API format.
  * Falls back to direct HTTP call if the qwen CLI is not available.
  */
-export async function callQwenAPI(prompt, model = 'coder-model') {
+export async function callQwenAPI(prompt, model = 'coder-model', onData) {
     // Try using the qwen CLI subprocess first — it handles auth/refresh/format automatically
     const qwenBin = process.env.QWEN_BIN || 'qwen';
     try {
-        const result = spawnSync(qwenBin, [], {
-            input: prompt,
-            encoding: 'utf-8',
-            timeout: 300000, // 5 minutes
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        if (result.status === 0 && result.stdout?.trim()) {
+        const result = await spawnAsync(qwenBin, [], prompt, 300000, onData);
+        if (result.status === 0 && result.stdout.trim()) {
             return result.stdout.trim();
         }
         // qwen not available or failed — fall through to direct API
@@ -325,19 +338,14 @@ export async function callQwenAPI(prompt, model = 'coder-model') {
  * in non-interactive mode without TTY issues.
  * Falls back to direct HTTP if the role binary is not found.
  */
-export async function callQwenAPIFromCreds(prompt, model, credsPath) {
+export async function callQwenAPIFromCreds(prompt, model, credsPath, onData) {
     // Derive the role binary name from the creds path (e.g. ~/.agent-explorer/ → agent-explorer)
     const cliName = path.basename(path.dirname(credsPath)).replace(/^\./, '');
-    // Try spawning the role binary with piped stdin (non-interactive mode)
+    // Try spawning the qwen CLI with piped stdin (async — keeps event loop free)
     const qwenBin = process.env.QWEN_BIN || 'qwen';
     try {
-        const result = spawnSync(qwenBin, [], {
-            input: prompt,
-            encoding: 'utf-8',
-            timeout: 300000,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        if (result.status === 0 && result.stdout?.trim()) {
+        const result = await spawnAsync(qwenBin, [], prompt, 300000, onData);
+        if (result.status === 0 && result.stdout.trim()) {
             return result.stdout.trim();
         }
     }

package/package.json

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