agent-rev 0.3.6 → 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,6 +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 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
@@ -38,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,6 +219,55 @@ export class AgentEngine {
         this.fi = fi;
         this.slashHandler = slashHandler;
     }
+    /** Start the activity box for a subagent call. Returns { stop, push }. */
+    _startSpinner(label) {
+        const noop = { stop() { }, push(_) { } };
+        if (!this.fi)
+            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.updateActivityHeader(`${frames[i++ % frames.length]}  ${label}  ${s}s`);
+        }, 100);
+        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.
      * El coordinador (CLI activo, ej: Qwen) conversa con el usuario
@@ -253,11 +302,15 @@ INSTRUCCIONES:
             if (this.coordinatorCmd.startsWith('qwen')) {
                 // Use Qwen API directly — avoids the qwen CLI's own OAuth flow
                 // which causes mid-session auth popups and breaks display.
+                const model = this.coordinatorCmd.match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'coder-model';
+                const sp = this._startSpinner(`coordinador  ${model}`);
                 try {
-                    const model = this.coordinatorCmd.match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'coder-model';
-                    return await callQwenAPI(prompt, model);
+                    const result = await callQwenAPI(prompt, model, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                    sp.stop();
+                    return result;
                 }
                 catch (err) {
+                    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'));
@@ -269,7 +322,9 @@ INSTRUCCIONES:
                 }
             }
             else {
+                const sp = this._startSpinner(`coordinador`);
                 res = await runCli(this.coordinatorCmd, prompt, 600000, envOverride);
+                sp.stop();
             }
             // Extract readable text — search for JSON array even if there's prefix text
             let responseText = res.output.trim();
@@ -366,15 +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 sp = this._startSpinner(`${cliName}  ${model}`);
             try {
                 const result = await runCli(currentCmd, rolePrompt);
                 if (result.exitCode !== 0) {
+                    sp.stop();
                     const detail = result.output.trim().slice(0, 500);
                     throw new Error(`${cliName} exited with code ${result.exitCode}${detail ? `\n${detail}` : ''}`);
                 }
+                sp.stop();
                 return result.output;
             }
             catch (err) {
+                sp.stop();
                 log.warn(`${cliName} failed, detecting flags from --help: ${err.message}`);
                 const detected = detectCliFlags(cliName);
                 if (Object.keys(detected).length === 0) {
@@ -426,8 +485,10 @@ INSTRUCCIONES:
                     // Config file might not exist yet
                 }
                 // Retry with new command
+                const sp2 = this._startSpinner(`${cliName}  ${model}  (retry)`);
                 try {
                     const result = await runCli(newCmd, rolePrompt);
+                    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}` : ''}`);
@@ -436,6 +497,7 @@ INSTRUCCIONES:
                     return result.output;
                 }
                 catch (retryErr) {
+                    sp2.stop();
                     log.warn(`Repaired ${cliName} also failed: ${retryErr.message}`);
                     return null;
                 }
@@ -452,11 +514,15 @@ INSTRUCCIONES:
                 log.warn(`${cliName} has no credentials — run: ${cliName} --login`);
                 return null;
             }
+            const sp = this._startSpinner(`${cliName}  ${model}`);
             try {
                 log.info(`${cliName}: calling Qwen API with own credentials (${model})`);
-                return await callQwenAPIFromCreds(rolePrompt, model, credsPath);
+                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                sp.stop();
+                return result;
             }
             catch (err) {
+                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`));
@@ -768,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) {
@@ -782,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 = '';
@@ -809,16 +937,16 @@ INSTRUCCIONES:
 7. Al terminar lista todos los archivos creados/actualizados.
 
 REGLAS:
-- NO modifiques archivos de aplicacion (solo .agent/context/)
+- Escribe UNICAMENTE los archivos indicados: ${archPath} y ${contextDir}/<servicio>/architecture.md
+- NO crees archivos adicionales ni con otros nombres
+- NO modifiques archivos de aplicacion
 - NO ejecutes comandos que cambien estado (npm install, migraciones, etc.)
 - Si un directorio esta en node_modules, dist, .git: ignoralo`;
         const res = await this.runWithFallback('explorer', prompt, 'Exploracion');
         const text = extractCliText(res);
-        // Always save a timestamped explorer report
+        // Overwrite the single last-run report (no timestamp accumulation)
         try {
-            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-            await writeFile(path.join(contextDir, `explorer-${ts}.md`), `# Explorer Report\n\nTask: ${effectiveTask}\nDate: ${new Date().toISOString()}\n\n${text}\n`);
-            log.ok(`Saved to .agent/context/explorer-${ts}.md`);
+            await writeFile(path.join(contextDir, 'explorer-last.md'), `# Explorer Report\n\nTask: ${effectiveTask}\nDate: ${new Date().toISOString()}\n\n${text}\n`);
         }
         catch { /* don't fail if save fails */ }
         return text;
@@ -832,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 {
@@ -852,12 +982,19 @@ INSTRUCCIONES:
 2. Para cada uno: lee package.json/requirements.txt, explora src/, identifica entry point, rutas/endpoints, puerto.
 3. Identifica dependencias entre servicios.
 4. Crea/actualiza ${archPath} con tabla resumen y detalle por servicio.
-5. Crea/actualiza ${contextDir}/<servicio>/architecture.md para cada servicio.`);
+5. Crea/actualiza ${contextDir}/<servicio>/architecture.md para cada servicio.
+
+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 sp = this._startSpinner(`agent-explorer  ${role.model}`);
         try {
-            result = await callQwenAPI(prompt, role.model);
+            result = await callQwenAPI(prompt, role.model, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+            sp.stop();
         }
         catch (err) {
+            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'));
@@ -866,9 +1003,7 @@ INSTRUCCIONES:
             throw err;
         }
         try {
-            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-            await writeFile(path.join(contextDir, `explorer-${ts}.md`), `# Explorer Report\n\nTask: ${effectiveTask}\n\n${result}\n`);
-            log.ok(`Saved to .agent/context/explorer-${ts}.md`);
+            await writeFile(path.join(contextDir, 'explorer-last.md'), `# Explorer Report\n\nTask: ${effectiveTask}\nDate: ${new Date().toISOString()}\n\n${result}\n`);
         }
         catch { /* ignore */ }
         return result;

package/dist/ui/input.d.ts

@@ -3,22 +3,39 @@ export declare class FixedInput {
     private history;
     private histIdx;
     private origLog;
+    private _pasting;
+    private _pasteAccum;
+    private _drawPending;
+    private _activityHeader;
+    private _activityLines;
     private get rows();
     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. */
+    stopActivity(): void;
     readLine(): Promise<string>;
     println(text: string): void;
     printSeparator(): void;
-    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
+    private _scheduleDraw;
     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,27 +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).
+// Maximum content rows the input box can grow to (Shift+Enter / word-wrap).
 const MAX_CONTENT_ROWS = 4;
-const RESERVED_ROWS = MAX_CONTENT_ROWS + 2; // 6
+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;
+    _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;
@@ -47,6 +55,7 @@ export class FixedInput {
         process.stdout.write(`\x1b[${this.scrollBottom};1H`);
         this._clearReserved();
         this._drawBox();
+        process.stdout.write('\x1b[?2004h');
         process.stdout.on('resize', () => {
             this._setScrollRegion();
             this._clearReserved();
@@ -54,14 +63,18 @@ export class FixedInput {
         });
     }
     teardown() {
+        this._activityHeader = null;
+        this._activityLines = [];
         console.log = this.origLog;
-        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(); }
     suspend() {
         console.log = this.origLog;
+        process.stdout.write('\x1b[?2004l');
         process.stdout.write('\x1b[r');
         this._clearReserved();
         process.stdout.write(`\x1b[${this.scrollBottom};1H`);
@@ -73,8 +86,48 @@ export class FixedInput {
             this._setScrollRegion();
             this._clearReserved();
             this._drawBox();
+            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 = '';
@@ -94,17 +147,39 @@ export class FixedInput {
             const onData = (data) => {
                 const hex = data.toString('hex');
                 const key = data.toString();
-                // ── 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
-                ) {
+                // ── Bracketed paste: start ────────────────────────────────────
+                if (key.includes('\x1b[200~')) {
+                    this._pasting = true;
+                    this._pasteAccum = '';
+                    const after = key.slice(key.indexOf('\x1b[200~') + 6);
+                    if (after)
+                        this._pasteAccum += after;
+                    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();
+                    }
+                    else {
+                        this._pasteAccum += key;
+                    }
+                    return;
+                }
+                // ── Shift+Enter → newline ────────────────────────────────────
+                if (hex === '5c0d' ||
+                    key === '\x0a' ||
+                    hex === '1b5b31333b327e' ||
+                    hex === '1b5b31333b3275' ||
+                    hex === '1b4f4d') {
                     this.buf += '\n';
-                    this._drawBox();
-                    // ── Enter → submit ────────────────────────────────────────────
+                    this._scheduleDraw();
+                    // ── Enter → submit ───────────────────────────────────────────
                 }
                 else if (key === '\r') {
                     const line = this.buf;
@@ -115,28 +190,28 @@ 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._drawBox();
+                        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._drawBox();
+                    this._scheduleDraw();
                 }
                 else if (hex === '1b5b41') { // Arrow ↑
                     if (this.histIdx + 1 < this.history.length) {
                         this.histIdx++;
                         this.buf = this.history[this.histIdx];
-                        this._drawBox();
+                        this._scheduleDraw();
                     }
                 }
                 else if (hex === '1b5b42') { // Arrow ↓
@@ -148,11 +223,11 @@ export class FixedInput {
                         this.histIdx = -1;
                         this.buf = '';
                     }
-                    this._drawBox();
+                    this._scheduleDraw();
                 }
                 else if (key.length >= 1 && key.charCodeAt(0) >= 32 && !key.startsWith('\x1b')) {
                     this.buf += key;
-                    this._drawBox();
+                    this._scheduleDraw();
                 }
             };
             process.stdin.on('data', onData);
@@ -168,30 +243,58 @@ export class FixedInput {
         this.println(chalk.rgb(0, 120, 116)('─'.repeat(this.cols - 1)));
     }
     // ── Private drawing ────────────────────────────────────────────────────────
-    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
+    _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`);
     }
-    /** 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();
         // ── Top border ───────────────────────────────────────────────
         process.stdout.write(`\x1b[${topBorder};1H`);
         process.stdout.write(T('╭') + T('─'.repeat(cols - 2)));
@@ -203,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
@@ -217,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 +1,44 @@
-{"name":"agent-rev","version":"0.3.6","description":"agent-rev agent","type":"module","main":"./dist/index.js","files":["dist/"],"bin":{"agent-rev":"dist/index.js"},"scripts":{"build":"tsc"},"keywords":["ai","agent","cli"],"license":"MIT","dependencies":{"@anthropic-ai/sdk":"^0.39.0","@google/generative-ai":"^0.24.0","chalk":"^5.4.1","commander":"^13.1.0","open":"^11.0.0","openai":"^4.91.0"},"engines":{"node":">=18.0.0"}}
+{
+  "name": "agent-rev",
+  "version": "0.4.3",
+  "description": "Deterministic multi-agent CLI orchestrator \u2014 plan, code, review",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "agent-mp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.tmp && mv dist/index.tmp dist/index.js && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "orchestrator",
+    "multi-agent",
+    "cli",
+    "coding"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@google/generative-ai": "^0.24.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "open": "^11.0.0",
+    "openai": "^4.91.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "@types/open": "^6.1.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}