primocode 1.0.1 → 4.1.0

package/lib/act.js

@@ -1,495 +1,500 @@
-// Modo Conecta Primo AI — faz tudo sozinho: código, arquivos, terminal, navegador
-
-'use strict';
-
-const path = require('path');
-const { c, actionHeader, toolLine, Spinner } = require('./ui');
-const tools = require('./tools');
-const api = require('./api');
-
-const MAX_ITERATIONS = 15;
-
-function fmtArgs(name, args) {
-    if (!args) return '';
-    switch (name) {
-        case 'read_file':          return args.path || '';
-        case 'write_file':         return `${args.path || ''} · ${(args.content || '').length} chars`;
-        case 'list_dir':           return args.path || '.';
-        case 'run_shell':          return args.command || '';
-        case 'run_in_new_terminal':return `${args.command || ''}${args.cwd ? ' @ ' + args.cwd : ''}`;
-        case 'open_in_browser':    return args.target || '';
-        case 'browser_open':       return args.url || '';
-        case 'browser_navigate':   return args.url || '';
-        case 'browser_click':      return args.selector || args.text || (args.x != null ? `${args.x},${args.y}` : '');
-        case 'browser_type':       return `${args.selector ? args.selector + ' · ' : ''}${(args.text || '').length} chars`;
-        case 'browser_key':        return args.key || '';
-        case 'browser_wait_for':   return args.selector || '';
-        case 'browser_wait':       return `${args.ms || 1000}ms`;
-        case 'browser_screenshot': return args.path || '(auto)';
-        case 'browser_eval':       return (args.js || '').slice(0, 60);
-        case 'browser_scroll':     return `dy=${args.dy || 400}`;
-        case 'browser_url':        return '';
-        case 'finish':             return args.summary || '';
-        default: return JSON.stringify(args).slice(0, 80);
-    }
-}
-
-// Nomes simples das ações
-const NICE = {
-    read_file: 'Read', write_file: 'Write', list_dir: 'List',
-    run_shell: 'Bash', run_in_new_terminal: 'Terminal', open_in_browser: 'Open',
-    browser_open: 'Browser', browser_navigate: 'Navigate', browser_click: 'Click',
-    browser_clickText: 'ClickText', browser_type: 'Type', browser_key: 'Key',
-    browser_wait_for: 'Wait', browser_wait: 'Wait', browser_screenshot: 'Screenshot',
-    browser_eval: 'Eval', browser_scroll: 'Scroll', browser_url: 'URL', finish: 'Finish',
-};
-
-function makeLogger() {
-    return {
-        event(kind, arg, result) {
-            if (kind === 'run_shell') return;
-            if (kind === 'run_shell_done') {
-                if (result) {
-                    const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed ? ' timeout' : ''}`);
-                    process.stdout.write('\n' + s + '\n');
-                }
-                return;
-            }
-            const prefix = c.muted('  ⎿ ');
-            if (kind === 'write_file' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
-                return;
-            }
-            if (kind === 'read_file' && result && result.ok) {
-                console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
-                return;
-            }
-            if (kind === 'list_dir' && result && result.ok) {
-                const lines = result.tree.split('\n').slice(0, 8);
-                for (const l of lines) console.log(prefix + c.muted(l));
-                const total = result.tree.split('\n').length;
-                if (total > 8) console.log(prefix + c.muted(`… +${total - 8}`));
-                return;
-            }
-            if (kind === 'open_in_browser' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.opener || 'browser'}`));
-                return;
-            }
-            if (kind === 'run_in_new_terminal' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.opener}`));
-                return;
-            }
-            if (kind === 'finish') {
-                console.log(prefix + c.muted(arg || 'ok'));
-                return;
-            }
-            if (result && result.ok === false) {
-                console.log(prefix + c.err(result.error || 'failed'));
-            }
-        },
-    };
-}
-
-/**
- * Executa uma tarefa em modo Act (agente autônomo com tools).
- * @param {string} userPrompt - texto do usuário
- * @param {object} opts - { server, model, history: [{role,content}, ...] }
- * @returns {Promise<{userMessage, assistantMessage}>}  para o caller atualizar seu histórico
- */
-async function runAct(userPrompt, opts) {
-    const { server, model, history: chatHistory = [] } = opts;
-
-    // Injeta contexto do CWD e inclui histórico curto de conversa
-    const cwd = process.cwd();
-    const cwdBase = path.basename(cwd);
-    const enriched = `[contexto: diretório atual = ${cwd} (basename: '${cwdBase}')]\n\n${userPrompt}`;
-
-    // Estado do loop
-    // Começamos com as mensagens do chat (para memória) + o novo user prompt.
-    let messages = [];
-    if (Array.isArray(chatHistory) && chatHistory.length) {
-        // Só passamos user/assistant sem tool_calls (o histórico de tool calls foi episódico).
-        for (const m of chatHistory) {
-            if (m && (m.role === 'user' || m.role === 'assistant') && m.content) {
-                messages.push({ role: m.role, content: m.content });
-            }
-        }
-    }
-
-    let promptForCall = enriched;
-    let toolResults = null;
-    let finished = false;
-    const log = makeLogger();
-    const recentCalls = [];
-    let finalAssistantText = '';
-    let sp = null;
-    let planCache = '';    // cache do plano do Planner entre turnos
-    let planShown = false; // evita mostrar plano múltiplas vezes
-    const filesWritten = new Set(); // arquivos criados/modificados pelo Construtor 1 (para refino)
-    const deferredOpens = [];       // open_in_browser adiados até depois do refino
-
-    for (let iter = 1; iter <= MAX_ITERATIONS && !finished; iter++) {
-        let assistantContent = '';
-        let assistantMessage = null;
-        let toolCalls = [];
-        let serverErr = null;
-        let hasToolCalls = false;
-        let streamingStarted = false;
-        let printedUpTo = 0;         // quantos chars de assistantContent já foram impressos
-        let suppressRest = false;    // uma vez detectado marker, para de imprimir
-        let retryNeeded = false;     // server pedidu retry (ex: finish rejeitado)
-        let rejectedNote = null;     // motivo da rejeição, injetado como tool_result no próximo turno
-        let subagentsPayload = null; // resultado de spawn_parallel (injetado como tool_result)
-        let subagentsToolCallId = null;
-        let subagentsTotal = 0;
-        let subagentsDone = 0;
-
-        // Spinner enquanto aguarda primeiro byte
-        sp = new Spinner('Pensando').start();
-
-        try {
-            await api.requestStream(server, '/api/act/stream', {
-                prompt: promptForCall,
-                history: messages,
-                tool_results: toolResults,
-                model,
-                plan_cache: planCache,
-            }, (evt) => {
-                if (evt.phase === 'inspiring') {
-                    if (sp) sp.stop();
-                    sp = new Spinner('Buscando referências').start();
-                }
-                if (evt.inspiration_urls && Array.isArray(evt.inspiration_urls) && evt.inspiration_urls.length > 0) {
-                    if (sp) { sp.stop(); sp = null; }
-                    console.log('\n' + c.muted('◆ Inspirando-se em:'));
-                    for (const u of evt.inspiration_urls) console.log(c.muted('  · ') + c.accent(u));
-                }
-                if (evt.phase === 'planning' && !planShown) {
-                    if (sp) sp.stop();
-                    sp = new Spinner('Pensando').start();
-                }
-                if (evt.plan) {
-                    planCache = evt.plan;
-                    if (sp) { sp.stop(); sp = null; }
-                    planShown = true;
-                    sp = new Spinner('Executando').start();
-                }
-                if (evt.subagents_spawning) {
-                    subagentsTotal = evt.subagents_spawning;
-                    if (sp) sp.stop();
-                    console.log('\n' + c.muted(`◆ Spawn de ${subagentsTotal} subagentes em paralelo`));
-                    sp = new Spinner(`Subagentes 0/${subagentsTotal}`).start();
-                }
-                if (evt.subagent_done) {
-                    subagentsDone++;
-                    const d = evt.subagent_done;
-                    if (sp) { sp.stop(); sp = null; }
-                    const status = d.ok ? c.ok('✓') : c.err('✗');
-                    console.log(`  ${status} ${c.muted(d.title)} ${c.muted('· ' + (d.bytes || 0) + ' bytes')}`);
-                    if (subagentsDone < subagentsTotal) sp = new Spinner(`Subagentes ${subagentsDone}/${subagentsTotal}`).start();
-                }
-                if (evt.subagents_result) {
-                    subagentsPayload = evt.subagents_result;
-                    subagentsToolCallId = evt.tool_call_id;
-                    if (sp) { sp.stop(); sp = null; }
-                }
-                if (evt.erro) { serverErr = evt.erro; return; }
-                if (evt.delta) {
-                    if (!streamingStarted) {
-                        sp.stop();
-                        process.stdout.write('\n');
-                        streamingStarted = true;
-                    }
-                    assistantContent += evt.delta;
-
-                    if (suppressRest) return;
-
-                    // Se aparece começo de marker suspeito, marca e para de imprimir daqui em diante.
-                    // Também "rebobina" cortando o que já foi acumulado até antes do marker
-                    // (não conseguimos apagar do terminal, mas o texto final ficará limpo).
-                    const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
-                    const m = assistantContent.match(leakRe);
-                    if (m && m.index !== undefined) {
-                        const safeEnd = m.index;
-                        if (safeEnd > printedUpTo) {
-                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
-                            printedUpTo = safeEnd;
-                        }
-                        suppressRest = true;
-                        return;
-                    }
-
-                    // Imprime até len-2 para dar margem se um marker começar a formar
-                    const target = Math.max(printedUpTo, assistantContent.length - 2);
-                    if (target > printedUpTo) {
-                        process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
-                        printedUpTo = target;
-                    }
-                }
-                if (evt.tool_call) toolCalls.push(evt.tool_call);
-                if (evt.assistant_message) assistantMessage = evt.assistant_message;
-                if (evt.tool_rejected) rejectedNote = evt.tool_rejected;
-                if (evt.retry_needed) retryNeeded = true;
-                if (evt.done) hasToolCalls = !!evt.has_tool_calls;
-                if (evt.instability) { serverErr = 'servidor com rate-limit; tente novamente em alguns minutos'; return; }
-            });
-        } catch (e) {
-            if (sp) sp.stop();
-            console.log(c.err(`\nerro: ${e.message}`));
-            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${e.message}]` } };
-        }
-
-        if (sp && !streamingStarted) sp.stop();
-
-        // Flush do buffer de 2 chars retido para evitar corte de markers
-        if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
-            process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
-            printedUpTo = assistantContent.length;
-        }
-
-        if (serverErr) {
-            console.log(c.err(`\nerro: ${serverErr}`));
-            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${serverErr}]` } };
-        }
-
-        if (streamingStarted) process.stdout.write('\n');
-
-        // Atualiza messages internas do loop (com tool_calls, para o modelo saber o que pediu)
-        if (assistantMessage) messages.push(assistantMessage);
-        else messages.push({ role: 'assistant', content: assistantContent });
-
-        // No primeiro turno, inserimos o user antes do assistant (foi só passado como prompt)
-        if (iter === 1) {
-            const last = messages.pop();
-            messages.push({ role: 'user', content: enriched });
-            messages.push(last);
-        }
-
-        promptForCall = null;
-
-        if (assistantContent) {
-            let cleaned = assistantContent
-                .replace(/<\|[\s\S]*$/g, '')
-                .replace(/【[\s\S]*$/g, '')
-                .replace(/\n\s*\{\s*"(name|type|summary|arguments|command|path)"[\s\S]*$/, '')
-                .replace(/^\s*\{\s*"(name|type|summary|arguments)"[\s\S]*$/, '')
-                // Corta chamadas de função vazadas em texto
-                .replace(/\b(finish|write_file|read_file|list_dir|run_shell|run_in_new_terminal|open_in_browser|browser_\w+)\s*\([\s\S]*$/g, '')
-                .trim();
-            if (cleaned) finalAssistantText = cleaned;
-        }
-
-        // Subagentes rodaram — injeta resultado como tool_result e segue loop
-        if (subagentsPayload && subagentsToolCallId) {
-            toolResults = [{ tool_call_id: subagentsToolCallId, result: JSON.stringify(subagentsPayload) }];
-            promptForCall = null;
-            continue;
-        }
-
-        // Server pediu retry (ex: finish sem trabalho no primeiro turno)
-        if (retryNeeded && rejectedNote) {
-            // Injeta pseudo tool_result educativo pro próximo turno
-            const rejectedId = assistantMessage?.tool_calls?.[0]?.id;
-            if (rejectedId) {
-                toolResults = [{ tool_call_id: rejectedId, result: JSON.stringify({ ok: false, error: rejectedNote.reason }) }];
-            }
-            // Novo prompt reforçando a ordem
-            promptForCall = `[sistema] Seu último ${rejectedNote.name}() foi rejeitado: ${rejectedNote.reason}\n\nExecute o pedido original agora, usando as ferramentas corretas antes de qualquer finish.`;
-            continue;
-        }
-
-        if (!hasToolCalls || toolCalls.length === 0) {
-            finished = true;
-            break;
-        }
-
-        // Executa cada tool
-        const results = [];
-        for (const tc of toolCalls) {
-            const name = tc.name;
-            const args = tc.arguments || {};
-            const nice = NICE[name] || name;
-            const detail = fmtArgs(name, args);
-            console.log('\n' + toolLine(nice, detail));
-
-            let res;
-            // Interceptação: se o Construtor 1 quer abrir arquivo E há refino planejado,
-            // adia a abertura pra DEPOIS do refino (não mostra ao usuário versão bugada).
-            // Só adiamos se já houver pelo menos 1 arquivo escrito (senão não faz sentido refinar).
-            const shouldDeferOpen = (name === 'open_in_browser' && args.target && filesWritten.size > 0);
-            if (shouldDeferOpen) {
-                deferredOpens.push(args.target);
-                res = { ok: true, text_for_model: JSON.stringify({ ok: true, deferred: true, note: 'abertura adiada para depois do refino' }) };
-                console.log(c.muted('  ⎿ adiado até depois do refino'));
-            } else {
-                try {
-                    res = await tools.executeTool(name, args, log);
-                } catch (e) {
-                    res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) };
-                    console.log(c.err(`  exception: ${e.message}`));
-                }
-            }
-            results.push({ tool_call_id: tc.id, result: res.text_for_model });
-
-            // Rastreia arquivos escritos para depois passar ao Construtor 2 (refino)
-            if (name === 'write_file' && args.path) {
-                try { filesWritten.add(String(args.path)); } catch { /* noop */ }
-            }
-
-            if (res.finish) finished = true;
-
-            const sig = name + '|' + JSON.stringify(args);
-            recentCalls.push(sig);
-            if (recentCalls.length > 4) recentCalls.shift();
-            if (recentCalls.filter(s => s === sig).length >= 3) {
-                console.log('\n' + c.warn('loop detectado — encerrando.'));
-                finished = true;
-                break;
-            }
-        }
-
-        toolResults = results;
-        if (finished) break;
-    }
-
-    if (!finished) console.log('\n' + c.warn(`limite de ${MAX_ITERATIONS} iterações atingido.`));
-
-    // ═══ FASE C — Refino (Construtor 2) ═══
-    // Só refina se o Construtor 1 realmente criou/modificou arquivos.
-    // Não refina para saudações/perguntas conceituais.
-    if (filesWritten.size > 0) {
-        const refineFiles = Array.from(filesWritten).slice(0, 8); // cap defensivo
-        console.log('\n' + c.muted('◆ Refinando (Construtor 2)'));
-        let refineSp = new Spinner('Melhorando').start();
-        let refineIter = 0;
-        let refineDone = false;
-        let refineToolResults = null;
-        const REFINE_MAX = 6;
-        // Histórico ISOLADO do refino — nunca inclui o histórico do executor
-        // (isso quebra o Groq porque as tool_calls antigas não têm tool_results correspondentes).
-        const refineMessages = [];
-
-        while (!refineDone && refineIter < REFINE_MAX) {
-            refineIter++;
-            let assistantMessage = null;
-            let toolCalls = [];
-            let serverErr = null;
-            let hasToolCalls = false;
-            let streamingStarted = false;
-            let printedUpTo = 0;
-            let suppressRest = false;
-            let assistantContent = '';
-
-            try {
-                await api.requestStream(server, '/api/act/stream', {
-                    refine: true,
-                    refine_files: refineFiles,
-                    refine_original_prompt: userPrompt,
-                    refine_history: refineMessages,
-                    tool_results: refineToolResults,
-                    model,
-                }, (evt) => {
-                    if (evt.erro) { serverErr = evt.erro; return; }
-                    if (evt.delta) {
-                        if (!streamingStarted) {
-                            if (refineSp) { refineSp.stop(); refineSp = null; }
-                            process.stdout.write('\n');
-                            streamingStarted = true;
-                        }
-                        assistantContent += evt.delta;
-                        if (suppressRest) return;
-                        const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
-                        const mm = assistantContent.match(leakRe);
-                        if (mm && mm.index !== undefined) {
-                            const safeEnd = mm.index;
-                            if (safeEnd > printedUpTo) {
-                                process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
-                                printedUpTo = safeEnd;
-                            }
-                            suppressRest = true;
-                            return;
-                        }
-                        const target = Math.max(printedUpTo, assistantContent.length - 2);
-                        if (target > printedUpTo) {
-                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
-                            printedUpTo = target;
-                        }
-                    }
-                    if (evt.tool_call) toolCalls.push(evt.tool_call);
-                    if (evt.assistant_message) assistantMessage = evt.assistant_message;
-                    if (evt.done) hasToolCalls = !!evt.has_tool_calls;
-                    if (evt.instability) { serverErr = 'refino indisponível (rate-limit)'; return; }
-                    if (evt.refine_skipped) { refineDone = true; return; }
-                });
-            } catch (e) {
-                if (refineSp) refineSp.stop();
-                console.log(c.warn(`\n(refino pulado: ${e.message})`));
-                break;
-            }
-
-            if (refineSp && !streamingStarted) refineSp.stop();
-            if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
-                process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
-            }
-            if (streamingStarted) process.stdout.write('\n');
-
-            if (serverErr) { console.log(c.warn(`\n(refino falhou: ${serverErr})`)); break; }
-
-            // Guarda o assistant_message NO HISTÓRICO ISOLADO do refino (não no messages global)
-            if (assistantMessage) refineMessages.push(assistantMessage);
-            if (!hasToolCalls || toolCalls.length === 0) { refineDone = true; break; }
-
-            const results = [];
-            for (const tc of toolCalls) {
-                const name = tc.name;
-                const args = tc.arguments || {};
-                const nice = NICE[name] || name;
-                const detail = fmtArgs(name, args);
-                console.log('\n' + toolLine(nice, detail));
-                let res;
-                try { res = await tools.executeTool(name, args, log); }
-                catch (e) { res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) }; console.log(c.err(`  exception: ${e.message}`)); }
-                results.push({ tool_call_id: tc.id, result: res.text_for_model });
-                // O refino também precisa adicionar tool result no histórico isolado
-                refineMessages.push({ role: 'tool', tool_call_id: tc.id, content: res.text_for_model });
-                if (res.finish) refineDone = true;
-            }
-            refineToolResults = null; // já injetamos no refineMessages, não duplicar
-
-            // Prepara spinner do próximo turno de refino se ainda não terminou
-            if (!refineDone) refineSp = new Spinner('Melhorando').start();
-        }
-        if (refineSp) refineSp.stop();
-
-        // Executa aberturas adiadas agora que o refino terminou
-        if (deferredOpens.length > 0) {
-            for (const target of deferredOpens) {
-                console.log('\n' + toolLine('Open', target));
-                try {
-                    const res = await tools.executeTool('open_in_browser', { target }, log);
-                    if (!res.ok && res.text_for_model) {
-                        console.log(c.muted('  ⎿ ' + (res.error || 'ok')));
-                    }
-                } catch (e) {
-                    console.log(c.err(`  ⎿ falha: ${e.message}`));
-                }
-            }
-        }
-    } else if (deferredOpens.length > 0) {
-        // Não houve refino mas há aberturas adiadas — executa direto (fallback)
-        for (const target of deferredOpens) {
-            console.log('\n' + toolLine('Open', target));
-            try { await tools.executeTool('open_in_browser', { target }, log); }
-            catch (e) { console.log(c.err(`  ⎿ falha: ${e.message}`)); }
-        }
-    }
-
-    // Retorna a mensagem final para o caller anexar ao histórico do chat
-    // Consolidamos toda a atividade + texto final para o usuário poder referenciar depois
-    return {
-        userMessage: { role: 'user', content: userPrompt },
-        assistantMessage: { role: 'assistant', content: finalAssistantText || '[ação concluída]' },
-    };
-}
-
-module.exports = { runAct };
+// Modo Primo Code — faz tudo sozinho: código, arquivos, terminal, navegador
+// REGRA FUNDAMENTAL: NUNCA entregue código no CMD/terminal.
+// SEMPRE use write_file para criar arquivos.
+// Se for executável (HTML, etc.), use open_in_browser para abrir.
+// Se for Python/JS, use run_in_new_terminal para executar.
+
+
+'use strict';
+
+const path = require('path');
+const { c, actionHeader, toolLine, Spinner } = require('./ui');
+const tools = require('./tools');
+const api = require('./api');
+
+const MAX_ITERATIONS = 15;
+
+function fmtArgs(name, args) {
+    if (!args) return '';
+    switch (name) {
+        case 'read_file':          return args.path || '';
+        case 'write_file':         return `${args.path || ''} · ${(args.content || '').length} chars`;
+        case 'list_dir':           return args.path || '.';
+        case 'run_shell':          return args.command || '';
+        case 'run_in_new_terminal':return `${args.command || ''}${args.cwd ? ' @ ' + args.cwd : ''}`;
+        case 'open_in_browser':    return args.target || '';
+        case 'browser_open':       return args.url || '';
+        case 'browser_navigate':   return args.url || '';
+        case 'browser_click':      return args.selector || args.text || (args.x != null ? `${args.x},${args.y}` : '');
+        case 'browser_type':       return `${args.selector ? args.selector + ' · ' : ''}${(args.text || '').length} chars`;
+        case 'browser_key':        return args.key || '';
+        case 'browser_wait_for':   return args.selector || '';
+        case 'browser_wait':       return `${args.ms || 1000}ms`;
+        case 'browser_screenshot': return args.path || '(auto)';
+        case 'browser_eval':       return (args.js || '').slice(0, 60);
+        case 'browser_scroll':     return `dy=${args.dy || 400}`;
+        case 'browser_url':        return '';
+        case 'finish':             return args.summary || '';
+        default: return JSON.stringify(args).slice(0, 80);
+    }
+}
+
+// Nomes simples das ações
+const NICE = {
+    read_file: 'Read', write_file: 'Write', list_dir: 'List',
+    run_shell: 'Bash', run_in_new_terminal: 'Terminal', open_in_browser: 'Open',
+    browser_open: 'Browser', browser_navigate: 'Navigate', browser_click: 'Click',
+    browser_clickText: 'ClickText', browser_type: 'Type', browser_key: 'Key',
+    browser_wait_for: 'Wait', browser_wait: 'Wait', browser_screenshot: 'Screenshot',
+    browser_eval: 'Eval', browser_scroll: 'Scroll', browser_url: 'URL', finish: 'Finish',
+};
+
+function makeLogger() {
+    return {
+        event(kind, arg, result) {
+            if (kind === 'run_shell') return;
+            if (kind === 'run_shell_done') {
+                if (result) {
+                    const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed ? ' timeout' : ''}`);
+                    process.stdout.write('\n' + s + '\n');
+                }
+                return;
+            }
+            const prefix = c.muted('  ⎿ ');
+            if (kind === 'write_file' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
+                return;
+            }
+            if (kind === 'read_file' && result && result.ok) {
+                console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
+                return;
+            }
+            if (kind === 'list_dir' && result && result.ok) {
+                const lines = result.tree.split('\n').slice(0, 8);
+                for (const l of lines) console.log(prefix + c.muted(l));
+                const total = result.tree.split('\n').length;
+                if (total > 8) console.log(prefix + c.muted(`… +${total - 8}`));
+                return;
+            }
+            if (kind === 'open_in_browser' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.opener || 'browser'}`));
+                return;
+            }
+            if (kind === 'run_in_new_terminal' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.opener}`));
+                return;
+            }
+            if (kind === 'finish') {
+                console.log(prefix + c.muted(arg || 'ok'));
+                return;
+            }
+            if (result && result.ok === false) {
+                console.log(prefix + c.err(result.error || 'failed'));
+            }
+        },
+    };
+}
+
+/**
+ * Executa uma tarefa em modo Act (agente autônomo com tools).
+ * @param {string} userPrompt - texto do usuário
+ * @param {object} opts - { server, model, history: [{role,content}, ...] }
+ * @returns {Promise<{userMessage, assistantMessage}>}  para o caller atualizar seu histórico
+ */
+async function runAct(userPrompt, opts) {
+    const { server, model, history: chatHistory = [] } = opts;
+
+    // Injeta contexto do CWD e inclui histórico curto de conversa
+    const cwd = process.cwd();
+    const cwdBase = path.basename(cwd);
+    const enriched = `[contexto: diretório atual = ${cwd} (basename: '${cwdBase}')]\n\n${userPrompt}`;
+
+    // Estado do loop
+    // Começamos com as mensagens do chat (para memória) + o novo user prompt.
+    let messages = [];
+    if (Array.isArray(chatHistory) && chatHistory.length) {
+        // Só passamos user/assistant sem tool_calls (o histórico de tool calls foi episódico).
+        for (const m of chatHistory) {
+            if (m && (m.role === 'user' || m.role === 'assistant') && m.content) {
+                messages.push({ role: m.role, content: m.content });
+            }
+        }
+    }
+
+    let promptForCall = enriched;
+    let toolResults = null;
+    let finished = false;
+    const log = makeLogger();
+    const recentCalls = [];
+    let finalAssistantText = '';
+    let sp = null;
+    let planCache = '';    // cache do plano do Planner entre turnos
+    let planShown = false; // evita mostrar plano múltiplas vezes
+    const filesWritten = new Set(); // arquivos criados/modificados pelo Construtor 1 (para refino)
+    const deferredOpens = [];       // open_in_browser adiados até depois do refino
+
+    for (let iter = 1; iter <= MAX_ITERATIONS && !finished; iter++) {
+        let assistantContent = '';
+        let assistantMessage = null;
+        let toolCalls = [];
+        let serverErr = null;
+        let hasToolCalls = false;
+        let streamingStarted = false;
+        let printedUpTo = 0;         // quantos chars de assistantContent já foram impressos
+        let suppressRest = false;    // uma vez detectado marker, para de imprimir
+        let retryNeeded = false;     // server pedidu retry (ex: finish rejeitado)
+        let rejectedNote = null;     // motivo da rejeição, injetado como tool_result no próximo turno
+        let subagentsPayload = null; // resultado de spawn_parallel (injetado como tool_result)
+        let subagentsToolCallId = null;
+        let subagentsTotal = 0;
+        let subagentsDone = 0;
+
+        // Spinner enquanto aguarda primeiro byte
+        sp = new Spinner('Pensando').start();
+
+        try {
+            await api.requestStream(server, '/api/act/stream', {
+                prompt: promptForCall,
+                history: messages,
+                tool_results: toolResults,
+                model,
+                plan_cache: planCache,
+            }, (evt) => {
+                if (evt.phase === 'inspiring') {
+                    if (sp) sp.stop();
+                    sp = new Spinner('Buscando referências').start();
+                }
+                if (evt.inspiration_urls && Array.isArray(evt.inspiration_urls) && evt.inspiration_urls.length > 0) {
+                    if (sp) { sp.stop(); sp = null; }
+                    console.log('\n' + c.muted('◆ Inspirando-se em:'));
+                    for (const u of evt.inspiration_urls) console.log(c.muted('  · ') + c.accent(u));
+                }
+                if (evt.phase === 'planning' && !planShown) {
+                    if (sp) sp.stop();
+                    sp = new Spinner('Pensando').start();
+                }
+                if (evt.plan) {
+                    planCache = evt.plan;
+                    if (sp) { sp.stop(); sp = null; }
+                    planShown = true;
+                    sp = new Spinner('Executando').start();
+                }
+                if (evt.subagents_spawning) {
+                    subagentsTotal = evt.subagents_spawning;
+                    if (sp) sp.stop();
+                    console.log('\n' + c.muted(`◆ Spawn de ${subagentsTotal} subagentes em paralelo`));
+                    sp = new Spinner(`Subagentes 0/${subagentsTotal}`).start();
+                }
+                if (evt.subagent_done) {
+                    subagentsDone++;
+                    const d = evt.subagent_done;
+                    if (sp) { sp.stop(); sp = null; }
+                    const status = d.ok ? c.ok('✓') : c.err('✗');
+                    console.log(`  ${status} ${c.muted(d.title)} ${c.muted('· ' + (d.bytes || 0) + ' bytes')}`);
+                    if (subagentsDone < subagentsTotal) sp = new Spinner(`Subagentes ${subagentsDone}/${subagentsTotal}`).start();
+                }
+                if (evt.subagents_result) {
+                    subagentsPayload = evt.subagents_result;
+                    subagentsToolCallId = evt.tool_call_id;
+                    if (sp) { sp.stop(); sp = null; }
+                }
+                if (evt.erro) { serverErr = evt.erro; return; }
+                if (evt.delta) {
+                    if (!streamingStarted) {
+                        sp.stop();
+                        process.stdout.write('\n');
+                        streamingStarted = true;
+                    }
+                    assistantContent += evt.delta;
+
+                    if (suppressRest) return;
+
+                    // Se aparece começo de marker suspeito, marca e para de imprimir daqui em diante.
+                    // Também "rebobina" cortando o que já foi acumulado até antes do marker
+                    // (não conseguimos apagar do terminal, mas o texto final ficará limpo).
+                    const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
+                    const m = assistantContent.match(leakRe);
+                    if (m && m.index !== undefined) {
+                        const safeEnd = m.index;
+                        if (safeEnd > printedUpTo) {
+                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
+                            printedUpTo = safeEnd;
+                        }
+                        suppressRest = true;
+                        return;
+                    }
+
+                    // Imprime até len-2 para dar margem se um marker começar a formar
+                    const target = Math.max(printedUpTo, assistantContent.length - 2);
+                    if (target > printedUpTo) {
+                        process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
+                        printedUpTo = target;
+                    }
+                }
+                if (evt.tool_call) toolCalls.push(evt.tool_call);
+                if (evt.assistant_message) assistantMessage = evt.assistant_message;
+                if (evt.tool_rejected) rejectedNote = evt.tool_rejected;
+                if (evt.retry_needed) retryNeeded = true;
+                if (evt.done) hasToolCalls = !!evt.has_tool_calls;
+                if (evt.instability) { serverErr = 'servidor com rate-limit; tente novamente em alguns minutos'; return; }
+            });
+        } catch (e) {
+            if (sp) sp.stop();
+            console.log(c.err(`\nerro: ${e.message}`));
+            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${e.message}]` } };
+        }
+
+        if (sp && !streamingStarted) sp.stop();
+
+        // Flush do buffer de 2 chars retido para evitar corte de markers
+        if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
+            process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
+            printedUpTo = assistantContent.length;
+        }
+
+        if (serverErr) {
+            console.log(c.err(`\nerro: ${serverErr}`));
+            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${serverErr}]` } };
+        }
+
+        if (streamingStarted) process.stdout.write('\n');
+
+        // Atualiza messages internas do loop (com tool_calls, para o modelo saber o que pediu)
+        if (assistantMessage) messages.push(assistantMessage);
+        else messages.push({ role: 'assistant', content: assistantContent });
+
+        // No primeiro turno, inserimos o user antes do assistant (foi só passado como prompt)
+        if (iter === 1) {
+            const last = messages.pop();
+            messages.push({ role: 'user', content: enriched });
+            messages.push(last);
+        }
+
+        promptForCall = null;
+
+        if (assistantContent) {
+            let cleaned = assistantContent
+                .replace(/<\|[\s\S]*$/g, '')
+                .replace(/【[\s\S]*$/g, '')
+                .replace(/\n\s*\{\s*"(name|type|summary|arguments|command|path)"[\s\S]*$/, '')
+                .replace(/^\s*\{\s*"(name|type|summary|arguments)"[\s\S]*$/, '')
+                // Corta chamadas de função vazadas em texto
+                .replace(/\b(finish|write_file|read_file|list_dir|run_shell|run_in_new_terminal|open_in_browser|browser_\w+)\s*\([\s\S]*$/g, '')
+                .trim();
+            if (cleaned) finalAssistantText = cleaned;
+        }
+
+        // Subagentes rodaram — injeta resultado como tool_result e segue loop
+        if (subagentsPayload && subagentsToolCallId) {
+            toolResults = [{ tool_call_id: subagentsToolCallId, result: JSON.stringify(subagentsPayload) }];
+            promptForCall = null;
+            continue;
+        }
+
+        // Server pediu retry (ex: finish sem trabalho no primeiro turno)
+        if (retryNeeded && rejectedNote) {
+            // Injeta pseudo tool_result educativo pro próximo turno
+            const rejectedId = assistantMessage?.tool_calls?.[0]?.id;
+            if (rejectedId) {
+                toolResults = [{ tool_call_id: rejectedId, result: JSON.stringify({ ok: false, error: rejectedNote.reason }) }];
+            }
+            // Novo prompt reforçando a ordem
+            promptForCall = `[sistema] Seu último ${rejectedNote.name}() foi rejeitado: ${rejectedNote.reason}\n\nExecute o pedido original agora, usando as ferramentas corretas antes de qualquer finish.`;
+            continue;
+        }
+
+        if (!hasToolCalls || toolCalls.length === 0) {
+            finished = true;
+            break;
+        }
+
+        // Executa cada tool
+        const results = [];
+        for (const tc of toolCalls) {
+            const name = tc.name;
+            const args = tc.arguments || {};
+            const nice = NICE[name] || name;
+            const detail = fmtArgs(name, args);
+            console.log('\n' + toolLine(nice, detail));
+
+            let res;
+            // Interceptação: se o Construtor 1 quer abrir arquivo E há refino planejado,
+            // adia a abertura pra DEPOIS do refino (não mostra ao usuário versão bugada).
+            // Só adiamos se já houver pelo menos 1 arquivo escrito (senão não faz sentido refinar).
+            const shouldDeferOpen = (name === 'open_in_browser' && args.target && filesWritten.size > 0);
+            if (shouldDeferOpen) {
+                deferredOpens.push(args.target);
+                res = { ok: true, text_for_model: JSON.stringify({ ok: true, deferred: true, note: 'abertura adiada para depois do refino' }) };
+                console.log(c.muted('  ⎿ adiado até depois do refino'));
+            } else {
+                try {
+                    res = await tools.executeTool(name, args, log);
+                } catch (e) {
+                    res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) };
+                    console.log(c.err(`  exception: ${e.message}`));
+                }
+            }
+            results.push({ tool_call_id: tc.id, result: res.text_for_model });
+
+            // Rastreia arquivos escritos para depois passar ao Construtor 2 (refino)
+            if (name === 'write_file' && args.path) {
+                try { filesWritten.add(String(args.path)); } catch { /* noop */ }
+            }
+
+            if (res.finish) finished = true;
+
+            const sig = name + '|' + JSON.stringify(args);
+            recentCalls.push(sig);
+            if (recentCalls.length > 4) recentCalls.shift();
+            if (recentCalls.filter(s => s === sig).length >= 3) {
+                console.log('\n' + c.warn('loop detectado — encerrando.'));
+                finished = true;
+                break;
+            }
+        }
+
+        toolResults = results;
+        if (finished) break;
+    }
+
+    if (!finished) console.log('\n' + c.warn(`limite de ${MAX_ITERATIONS} iterações atingido.`));
+
+    // ═══ FASE C — Refino (Construtor 2) ═══
+    // Só refina se o Construtor 1 realmente criou/modificou arquivos.
+    // Não refina para saudações/perguntas conceituais.
+    if (filesWritten.size > 0) {
+        const refineFiles = Array.from(filesWritten).slice(0, 8); // cap defensivo
+        console.log('\n' + c.muted('◆ Refinando (Construtor 2)'));
+        let refineSp = new Spinner('Melhorando').start();
+        let refineIter = 0;
+        let refineDone = false;
+        let refineToolResults = null;
+        const REFINE_MAX = 6;
+        // Histórico ISOLADO do refino — nunca inclui o histórico do executor
+        // (isso quebra o Groq porque as tool_calls antigas não têm tool_results correspondentes).
+        const refineMessages = [];
+
+        while (!refineDone && refineIter < REFINE_MAX) {
+            refineIter++;
+            let assistantMessage = null;
+            let toolCalls = [];
+            let serverErr = null;
+            let hasToolCalls = false;
+            let streamingStarted = false;
+            let printedUpTo = 0;
+            let suppressRest = false;
+            let assistantContent = '';
+
+            try {
+                await api.requestStream(server, '/api/act/stream', {
+                    refine: true,
+                    refine_files: refineFiles,
+                    refine_original_prompt: userPrompt,
+                    refine_history: refineMessages,
+                    tool_results: refineToolResults,
+                    model,
+                }, (evt) => {
+                    if (evt.erro) { serverErr = evt.erro; return; }
+                    if (evt.delta) {
+                        if (!streamingStarted) {
+                            if (refineSp) { refineSp.stop(); refineSp = null; }
+                            process.stdout.write('\n');
+                            streamingStarted = true;
+                        }
+                        assistantContent += evt.delta;
+                        if (suppressRest) return;
+                        const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
+                        const mm = assistantContent.match(leakRe);
+                        if (mm && mm.index !== undefined) {
+                            const safeEnd = mm.index;
+                            if (safeEnd > printedUpTo) {
+                                process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
+                                printedUpTo = safeEnd;
+                            }
+                            suppressRest = true;
+                            return;
+                        }
+                        const target = Math.max(printedUpTo, assistantContent.length - 2);
+                        if (target > printedUpTo) {
+                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
+                            printedUpTo = target;
+                        }
+                    }
+                    if (evt.tool_call) toolCalls.push(evt.tool_call);
+                    if (evt.assistant_message) assistantMessage = evt.assistant_message;
+                    if (evt.done) hasToolCalls = !!evt.has_tool_calls;
+                    if (evt.instability) { serverErr = 'refino indisponível (rate-limit)'; return; }
+                    if (evt.refine_skipped) { refineDone = true; return; }
+                });
+            } catch (e) {
+                if (refineSp) refineSp.stop();
+                console.log(c.warn(`\n(refino pulado: ${e.message})`));
+                break;
+            }
+
+            if (refineSp && !streamingStarted) refineSp.stop();
+            if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
+                process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
+            }
+            if (streamingStarted) process.stdout.write('\n');
+
+            if (serverErr) { console.log(c.warn(`\n(refino falhou: ${serverErr})`)); break; }
+
+            // Guarda o assistant_message NO HISTÓRICO ISOLADO do refino (não no messages global)
+            if (assistantMessage) refineMessages.push(assistantMessage);
+            if (!hasToolCalls || toolCalls.length === 0) { refineDone = true; break; }
+
+            const results = [];
+            for (const tc of toolCalls) {
+                const name = tc.name;
+                const args = tc.arguments || {};
+                const nice = NICE[name] || name;
+                const detail = fmtArgs(name, args);
+                console.log('\n' + toolLine(nice, detail));
+                let res;
+                try { res = await tools.executeTool(name, args, log); }
+                catch (e) { res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) }; console.log(c.err(`  exception: ${e.message}`)); }
+                results.push({ tool_call_id: tc.id, result: res.text_for_model });
+                // O refino também precisa adicionar tool result no histórico isolado
+                refineMessages.push({ role: 'tool', tool_call_id: tc.id, content: res.text_for_model });
+                if (res.finish) refineDone = true;
+            }
+            refineToolResults = null; // já injetamos no refineMessages, não duplicar
+
+            // Prepara spinner do próximo turno de refino se ainda não terminou
+            if (!refineDone) refineSp = new Spinner('Melhorando').start();
+        }
+        if (refineSp) refineSp.stop();
+
+        // Executa aberturas adiadas agora que o refino terminou
+        if (deferredOpens.length > 0) {
+            for (const target of deferredOpens) {
+                console.log('\n' + toolLine('Open', target));
+                try {
+                    const res = await tools.executeTool('open_in_browser', { target }, log);
+                    if (!res.ok && res.text_for_model) {
+                        console.log(c.muted('  ⎿ ' + (res.error || 'ok')));
+                    }
+                } catch (e) {
+                    console.log(c.err(`  ⎿ falha: ${e.message}`));
+                }
+            }
+        }
+    } else if (deferredOpens.length > 0) {
+        // Não houve refino mas há aberturas adiadas — executa direto (fallback)
+        for (const target of deferredOpens) {
+            console.log('\n' + toolLine('Open', target));
+            try { await tools.executeTool('open_in_browser', { target }, log); }
+            catch (e) { console.log(c.err(`  ⎿ falha: ${e.message}`)); }
+        }
+    }
+
+    // Retorna a mensagem final para o caller anexar ao histórico do chat
+    // Consolidamos toda a atividade + texto final para o usuário poder referenciar depois
+    return {
+        userMessage: { role: 'user', content: userPrompt },
+        assistantMessage: { role: 'assistant', content: finalAssistantText || '[ação concluída]' },
+    };
+}
+
+module.exports = { runAct };