agent-mp 0.4.0 → 0.4.2

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
@@ -40,6 +42,14 @@ export declare class AgentEngine {
     runReviewer(taskId: string, plan: TaskPlan, progress: TaskProgress): Promise<{
         verdict: string;
     }>;
+    /**
+     * Scan contextDir for stray files (outside the allowed structure) and clean them up:
+     * - Old timestamped explorer-*.md reports → delete (content already in architecture.md)
+     * - Other stray .md files at root level → append content to architecture.md, then delete
+     * Allowed root-level files: architecture.md, explorer-last.md
+     * Allowed subdirectory files: <service>/architecture.md  (not touched here)
+     */
+    private _cleanContextDir;
     runExplorer(task?: string): Promise<string>;
     /** Called when the current binary IS the configured explorer CLI (prevents recursion).
      *  Builds the full exploration prompt and calls Qwen API using own credentials. */

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`));
@@ -799,6 +834,66 @@ INSTRUCCIONES:
         log.verdict(verdict);
         return { verdict };
     }
+    /**
+     * Scan contextDir for stray files (outside the allowed structure) and clean them up:
+     * - Old timestamped explorer-*.md reports → delete (content already in architecture.md)
+     * - Other stray .md files at root level → append content to architecture.md, then delete
+     * Allowed root-level files: architecture.md, explorer-last.md
+     * Allowed subdirectory files: <service>/architecture.md  (not touched here)
+     */
+    async _cleanContextDir(contextDir) {
+        let entries;
+        try {
+            entries = await fs.readdir(contextDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        } // dir doesn't exist yet
+        const archPath = path.join(contextDir, 'architecture.md');
+        const stray = [];
+        for (const e of entries) {
+            if (!e.isFile())
+                continue;
+            if (!e.name.endsWith('.md'))
+                continue;
+            if (e.name === 'architecture.md' || e.name === 'explorer-last.md')
+                continue;
+            stray.push(e.name);
+        }
+        if (stray.length === 0)
+            return;
+        log.info(`Limpiando ${stray.length} archivo(s) fuera de estructura en .agent/context/`);
+        for (const name of stray) {
+            const filePath = path.join(contextDir, name);
+            // Old timestamped explorer reports — just delete (content is redundant)
+            if (/^explorer-\d{4}-\d{2}-/.test(name)) {
+                await fs.unlink(filePath);
+                log.ok(`  Eliminado: ${name}`);
+                continue;
+            }
+            // Other stray files — migrate content to architecture.md, then delete
+            try {
+                const content = (await readFile(filePath)).trim();
+                if (content) {
+                    let arch = '';
+                    try {
+                        arch = await readFile(archPath);
+                    }
+                    catch { /* no arch yet */ }
+                    const label = name.replace(/\.md$/, '');
+                    await writeFile(archPath, `${arch}\n\n---\n## ${label}\n\n${content}\n`);
+                    log.ok(`  Migrado: ${name} → architecture.md`);
+                }
+                else {
+                    log.ok(`  Eliminado (vacío): ${name}`);
+                }
+                await fs.unlink(filePath);
+            }
+            catch (err) {
+                log.warn(`  No se pudo limpiar ${name}: ${err.message}`);
+            }
+        }
+    }
     async runExplorer(task) {
         if (!this.config.roles.explorer) {
             if (!this.config.fallback_global) {
@@ -813,6 +908,8 @@ INSTRUCCIONES:
         const contextDir = path.join(agentDir, 'context');
         await fs.mkdir(contextDir, { recursive: true });
         await fs.mkdir(path.join(agentDir, 'rules'), { recursive: true });
+        // Clean up stray files before running
+        await this._cleanContextDir(contextDir);
         // Read existing architecture doc if any
         const archPath = path.join(contextDir, 'architecture.md');
         let existingArch = '';
@@ -863,6 +960,8 @@ REGLAS:
         const agentDir = path.join(this.projectDir, '.agent');
         const contextDir = path.join(agentDir, 'context');
         await fs.mkdir(contextDir, { recursive: true });
+        // Clean up stray files before running
+        await this._cleanContextDir(contextDir);
         const archPath = path.join(contextDir, 'architecture.md');
         let existingArch = '';
         try {
@@ -889,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,7 +6,8 @@ export declare class FixedInput {
     private _pasting;
     private _pasteAccum;
     private _drawPending;
-    private _statusText;
+    private _activityHeader;
+    private _activityLines;
     private get rows();
     get cols(): number;
     private get scrollBottom();
@@ -14,21 +15,26 @@ export declare class FixedInput {
     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

@@ -6,29 +6,27 @@ 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).
+// RESERVED_ROWS covers the activity box (7 rows) and the input box (max 6 rows + 1 status).
+// Activity box: 1 top border + 5 content lines + 1 bottom border = 7 rows.
+// Input box:    1 status row + up to 4 content + 2 borders        = 7 rows.
 const MAX_CONTENT_ROWS = 4;
-const RESERVED_ROWS = MAX_CONTENT_ROWS + 3; // 7 = 4 content + 2 borders + 1 status
+const ACTIVITY_LINES = 5;
+const RESERVED_ROWS = MAX_CONTENT_ROWS + 3; // 7
 // ─── 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).
     _contentRows() {
         const w = this.cols - PREFIX_COLS - 2;
         if (w <= 0)
@@ -51,7 +49,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 +57,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 +80,46 @@ 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._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._drawBox();
+    }
     // ── Input ──────────────────────────────────────────────────────────────────
     readLine() {
         this.buf = '';
@@ -111,7 +143,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 +151,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 +163,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 +182,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 +235,60 @@ 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();
+            // Cursor stays hidden while agent is working (no input expected)
+            return;
+        }
+        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 +300,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 +313,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.0",
+  "version": "0.4.2",
   "description": "Deterministic multi-agent CLI orchestrator — plan, code, review",
   "type": "module",
   "main": "./dist/index.js",