primocode 9.5.0 → 9.7.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.5.0
+# PrimoCode v9.7.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.5.0
+ ▐▛███▜▌   Primo Code v9.7.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -59,6 +59,7 @@ const VERSION = pkg.version;
 const state = {
     config: cfg.loadConfig(),
     history: [],
+    resumindo: null,   // o resumo da última rodada, sendo feito em segundo plano
     mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
     modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
     attachedFiles: [],
@@ -427,20 +428,88 @@ async function confirm(question) {
 
 // ── Projetos ───────────────────────────────────────────────────────────
 
-const STOPWORDS = new Set([
-    'crie', 'cria', 'criar', 'faca', 'faça', 'faz', 'fazer', 'monte', 'montar',
-    'desenvolva', 'desenvolver', 'construa', 'construir', 'gere', 'gerar',
-    'quero', 'queria', 'gostaria', 'preciso', 'me', 'meu', 'minha', 'favor',
-    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'por', 'pra', 'para',
+/* ── O NOME DO PROJETO ───────────────────────────────────────────────────
+ * O nome saía das cinco primeiras palavras depois de "crie um": "agora deixa o
+ * carro mais rápido" virava a pasta `agora-deixa-o-carro-mais`, e "oi primo,
+ * faz um site" virava `oi-primo-faz-um-site`. Agora o começo da frase
+ * (saudação, o nome dele, verbo de pedido, artigo) é pulado, o assunto vai até
+ * a primeira palavra que emenda outra ideia ("com", "que", "usando"…), e
+ * sobram até quatro palavras que dizem O QUE é: "jogo de carro", "site
+ * padaria", "loja roupas". */
+const ABERTURA = new Set([
+    'oi', 'ola', 'ei', 'hey', 'e', 'ai', 'primo', 'bom', 'boa', 'dia', 'tarde', 'noite', 'ok', 'beleza',
+    'entao', 'agora', 'tipo', 'por', 'favor', 'pfv', 'pf', 'voce', 'vc', 'pode', 'poderia', 'consegue',
+    'crie', 'cria', 'criar', 'faca', 'faz', 'fazer', 'monte', 'monta', 'montar', 'desenvolva', 'desenvolver',
+    'construa', 'construir', 'gere', 'gera', 'gerar', 'programe', 'programa', 'escreva', 'escreve',
+    'quero', 'queria', 'gostaria', 'preciso', 'precisamos', 'vamos', 'bora', 'me', 'pra', 'para', 'mim',
+    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'de', 'novo', 'nova', 'outro', 'outra', 'projeto',
+    'simples', 'pequeno', 'pequena', 'rapido', 'bonito', 'bonita',
+    // os verbos de CONTINUAR: sem eles, "agora deixa o carro…" virava nome
+    'deixa', 'deixe', 'continua', 'continue', 'edita', 'edite', 'muda', 'mude', 'melhora', 'melhore',
+    'adiciona', 'adicione', 'coloca', 'coloque', 'poe', 'bota', 'corrige', 'corrija', 'arruma', 'arrume',
+    'ajusta', 'ajuste', 'abre', 'abra', 'termina', 'termine',
 ]);
+const EMENDA = new Set(['com', 'que', 'usando', 'onde', 'mas', 'porque', 'igual', 'como', 'sobre',
+    'em', 'no', 'na', 'nos', 'nas', 'e', 'tipo', 'estilo', 'feito', 'utilizando', 'mais', 'menos']);
+// Palavras que não dizem o que a coisa É — saem de qualquer posição.
+const DE_ENCHER = new Set(['minha', 'meu', 'minhas', 'meus', 'nossa', 'nosso', 'para', 'pra', 'uma', 'um',
+    'simples', 'bonito', 'bonita', 'pequeno', 'pequena', 'legal', 'rapido', 'rapida', 'basico', 'basica',
+    'completo', 'completa', 'novo', 'nova']);
+
+function semAcento(x) { return String(x || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase(); }
 
-// "crie um jogo de carro" -> "jogo de carro"
 function deriveProjectName(text) {
-    const words = String(text).trim().split(/\s+/);
+    const palavras = String(text || '').split(/\s+/)
+        .map((w) => w.replace(/[^\wáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, ''))
+        .filter(Boolean);
     let i = 0;
-    while (i < words.length && STOPWORDS.has(words[i].toLowerCase().replace(/[^\wáéíóúâêôãõç]/gi, ''))) i++;
-    const picked = words.slice(i, i + 5).join(' ').replace(/[^\w\sáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, '').trim();
-    return picked || 'projeto';
+    while (i < palavras.length && ABERTURA.has(semAcento(palavras[i]))) i++;
+    const assunto = [];
+    for (; i < palavras.length && assunto.length < 6; i++) {
+        const w = semAcento(palavras[i]);
+        if (assunto.length && EMENDA.has(w)) break;
+        if (DE_ENCHER.has(w)) continue;
+        assunto.push(palavras[i]);
+    }
+    while (assunto.length && /^(de|do|da|dos|das)$/i.test(semAcento(assunto[assunto.length - 1]))) assunto.pop();
+    const nome = assunto.slice(0, 4).join(' ').trim();
+    return nome || 'projeto';
+}
+
+/* ── "CRIE UM…" DENTRO DE UM PROJETO ────────────────────────────────────
+ * Depois de entrar num projeto, TUDO ia para ele — até "crie um site de
+ * receitas" no meio do jogo de carro. E fora dele, qualquer "continua" virava
+ * projeto novo. A regra agora: dentro de um projeto, só um pedido que CLARAMENTE
+ * abre outra coisa sai dele — verbo de criar + "um/uma/outro/novo", assunto
+ * que não tem nada a ver com o projeto atual, e nenhuma referência a ele
+ * ("isso", "esse", "nele"). Todo o resto ("continua", "muda a cor", "agora
+ * põe fases") fica. */
+const RE_PROJETO_NOVO = /\b(novo projeto|projeto novo|outro projeto|do zero|come[cç]a(r)? (um|uma|outro|outra))\b/;
+const RE_CRIAR_UM = /\b(crie|cria|criar|fa[cç]a|faz|fazer|monte|monta|montar|gere|gera|desenvolva|construa|programe|quero|preciso de)\s+(um|uma|outro|outra|novo|nova)\b/;
+const RE_REFERE_ATUAL = /\b(isso|isto|esse|essa|este|esta|nele|nela|dele|dela|no projeto|nesse|nessa|neste|nesta|continua|continue|edita|edite|muda|mude|melhora|melhore|adiciona|adicione|coloca|coloque|p[oõ]e|corrige|corrija|arruma|arrume|ajusta|ajuste)\b/;
+
+function pedeProjetoNovo(texto) {
+    const t = semAcento(texto);
+    if (RE_PROJETO_NOVO.test(t)) return true;
+    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t)) return false;
+    // Mesmo assunto do projeto atual ("crie uma fase nova pro jogo de carro")
+    // é continuação, não projeto novo.
+    const atual = new Set(cfg.slugify(state.currentProject || '').split('-').filter((x) => x.length > 2));
+    const pedido = cfg.slugify(deriveProjectName(texto)).split('-').filter((x) => x.length > 2);
+    return !pedido.some((x) => atual.has(x));
+}
+
+/* Pedido de mexer no computador da pessoa (abrir app, clicar, digitar,
+   mostrar o cursor). Serve só para mandar a dica das ferramentas desktop_*. */
+const RE_COMPUTADOR = /\b(abr[ae]|abrir|clica|clique|clicar|digita|digite|digitar|mouse|cursor|teclado|meu computador|no (meu )?mac|na (minha )?tela|aplicativo|spotify|safari|finder|whatsapp|mensagens|m[úu]sica|configura[çc][õo]es|ajustes)\b/i;
+function querComputador(texto) { return RE_COMPUTADOR.test(String(texto || '')); }
+
+/* Guarda onde se está, para a próxima sessão continuar aqui. */
+function entrarNoProjeto(dir, origem = 'projeto') {
+    state.workDir = dir;
+    state.currentProject = path.basename(dir);
+    state.workDirOrigem = origem;
+    cfg.lembrarProjeto(dir, origem);
 }
 
 // Pasta em que é seguro deixar um agente criar e editar arquivo. A home e a raiz
@@ -477,7 +546,10 @@ function ehSoEstudio(texto) {
 }
 
 function planWorkDir(userText) {
-    if (['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem)) {
+    const escolhida = ['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem);
+    // Pasta escolhida a dedo (/dir, ou dita no pedido) manda sempre. Projeto
+    // em andamento manda também — a menos que o pedido abra outra coisa.
+    if (escolhida && !(state.workDirOrigem === 'projeto' && pedeProjetoNovo(userText))) {
         return { dir: state.workDir, pending: false, name: state.currentProject };
     }
     // "Quando eu peço um vídeo, não é pra ficar com projeto. Só vai criar
@@ -493,9 +565,7 @@ function planWorkDir(userText) {
 
 function createPendingProject(plan) {
     const dir = cfg.createProjectDir(plan.name);
-    state.workDir = dir;
-    state.currentProject = path.basename(dir);
-    state.workDirOrigem = 'projeto';
+    entrarNoProjeto(dir, 'projeto');
     const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
     console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
     refreshPrompt();
@@ -530,9 +600,7 @@ function talvezTrocarDePasta(userText) {
     if (path.resolve(achado.caminho) === path.resolve(projectDir())) return;  // já está lá
     if (!pastaSegura(achado.caminho)) return;   // home ou raiz: só por /dir explícito
 
-    state.workDir = achado.caminho;
-    state.currentProject = path.basename(achado.caminho);
-    state.workDirOrigem = 'detectada';
+    entrarNoProjeto(achado.caminho, 'detectada');
     console.log(c.ok(`  Trabalhando em ${shortPath(achado.caminho)}`) + c.dim(`  (você falou "${candidato}")`));
     refreshPrompt();
 }
@@ -556,9 +624,7 @@ function prepararPasta(userText) {
     // buildMemoryContext deste turno leria a pasta errada e a memória do projeto
     // não carregaria.
     if (!plan.pending && path.resolve(plan.dir) !== path.resolve(projectDir())) {
-        state.workDir = plan.dir;
-        state.currentProject = plan.name || path.basename(plan.dir);
-        state.workDirOrigem = 'projeto';
+        entrarNoProjeto(plan.dir, 'projeto');
         console.log(c.ok(`  Continuando em ${state.currentProject}`) + c.muted(`  (${shortPath(plan.dir)})`));
         refreshPrompt();
     }
@@ -602,6 +668,20 @@ async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
     return 'nao';
 }
 
+/* ── A PERMISSÃO NO MODO VOZ ─────────────────────────────────────────────
+ * No modo voz ninguém está olhando o terminal: a pergunta "1, 2 ou Enter"
+ * ficava lá embaixo, o agente parava esperando, e para quem só falava ele
+ * simplesmente travava. Abrir o /voice e PEDIR em voz para ele mexer no
+ * computador já é a autorização — é o produto funcionando como o Jarvis. Fica
+ * dito no terminal, a cada ação, o que ele fez; e fechar o PrimoCode esquece. */
+async function autorizarPorVoz(oQueVaiFazer, { primeira } = {}) {
+    if (primeira) {
+        console.log('  ' + c.warn('▸▸') + ' ' + c.muted('Modo voz: o Primo vai usar o mouse e o teclado. Você vê o cursor dele na tela.'));
+    }
+    console.log('  ' + c.brand('●') + ' ' + c.dim(oQueVaiFazer));
+    return 'sessao';
+}
+
 /* ── A TELA DO MARKETPLACE ───────────────────────────────────────────────
  * O desenho e as teclas vivem em lib/marketplace.js, que é função pura. O que
  * mora aqui é o que precisa do terminal: tirar a caixa de digitar da frente,
@@ -801,10 +881,9 @@ async function sendPrompt(userText) {
 
         const plan = prepararPasta(userText);
 
-        // Antes de gastar com a tarefa, dobra no resumo o que já passou. A
-        // conta é pequena: entra "resumo de antes + o que é novo", não a
-        // conversa inteira.
-        await comprimirConversa();
+        // O resumo da rodada anterior é feito em segundo plano logo depois
+        // dela; aqui só se espera ele terminar, para não sair com memória velha.
+        await esperarResumo();
 
         // O pedido passa por uma cabeça antes de virar trabalho: conserta o
         // que está torto, diz qual é o entregável e o que conta como pronto.
@@ -842,7 +921,7 @@ async function sendPrompt(userText) {
                 token: state.config.token,
                 // Só o primeiro passo enxerga a conversa: os seguintes recebem o
                 // que interessa em `jaFeito`, e conversa a mais só ocupa o teto.
-                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history) : [],
+                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()) : [],
                 projectDir: plan.dir,
                 projectName: plan.name || state.currentProject,
                 // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
@@ -852,6 +931,9 @@ async function sendPrompt(userText) {
                 // lembra da resposta é a sessão.
                 autorizar: autorizarControle,
                 controle: state.controle,
+                // Pedido de mexer no computador leva a dica que libera as
+                // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
+                instrucao: i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
             });
 
             r = await rodarPasso();
@@ -877,6 +959,7 @@ async function sendPrompt(userText) {
         if (balanco) console.log(balanco);
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
+        resumirDepois();
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
         // Sobe cifrado, atrás, sem segurar o prompt. Se não houver conta ou
@@ -884,7 +967,7 @@ async function sendPrompt(userText) {
         state.gravador.turno(userText, r.assistantMessage.content,
             { modo: 'primocode', projeto: state.currentProject || null });
     } else {
-        await comprimirConversa();
+        await esperarResumo();
         await runChat(prompt, userText);
     }
 
@@ -986,21 +1069,55 @@ async function dividirTarefa(pedido) {
    resumir. Sem isso o comando responderia "nada a fazer" justamente quando
    ela está vendo a IA se perder — e "não fiz nada" é a pior resposta possível
    para quem acabou de pedir socorro. */
-async function comprimirConversa(forcado = false) {
+async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
     if (!forcado && !memoria.precisaResumir(state.memoria, state.history)) return;
-    const sp = new Spinner('resumindo a conversa').start();
+    // Em segundo plano não há spinner: ele disputaria a tela com o prompt.
+    const sp = silencioso ? { stop() {} } : new Spinner('resumindo a conversa').start();
     try {
-        state.memoria = await memoria.atualizar(state.memoria, state.history, ({ resumo, mensagens }) =>
+        const conversa = state.history;
+        const nova = await memoria.atualizar(state.memoria, conversa, ({ resumo, mensagens }) =>
             api.requestResumo(state.config.server, { resumo, mensagens, token: state.config.token })
                 .then((r) => r.resumo));
+        // /clear ou /chats trocaram a conversa enquanto o resumo era feito:
+        // o resumo é da conversa velha e não pode voltar por cima da nova.
+        if (state.history !== conversa) { sp.stop(); return; }
+        state.memoria = nova;
         sp.stop();
         const e = memoria.economia(state.memoria, state.history);
-        if (e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
+        if (!silencioso && e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
     } catch {
         sp.stop();   // resumo é economia, não requisito: falhou, segue a vida
     }
 }
 
+/* ── O RESUMO DE CADA RODADA ─────────────────────────────────────────────
+ * "Gere um resumo a cada mensagem, pra na próxima ela ler só esse resumo."
+ * O resumo começa assim que a resposta termina, atrás, sem segurar o prompt —
+ * a pessoa lê a resposta enquanto ele é feito. O pedido seguinte espera por
+ * ele (com teto: rede lenta não pode travar a conversa), e aí leva só o
+ * resumo, não a conversa inteira. Ver lib/memoria-conversa.js. */
+function resumirDepois() {
+    const anterior = state.resumindo || Promise.resolve();
+    const atual = anterior.then(() => comprimirConversa(false, { silencioso: true })).catch(() => {});
+    state.resumindo = atual;
+    atual.then(() => { if (state.resumindo === atual) state.resumindo = null; });
+}
+
+async function esperarResumo(tetoMs = 15000) {
+    if (!state.resumindo) return;
+    await Promise.race([state.resumindo, new Promise((ok) => setTimeout(ok, tetoMs))]);
+}
+
+/* A linha que vai junto do resumo: em que projeto se está. É o que faz
+   "continua o jogo" e "muda a cor" caírem no mesmo projeto em vez de inventar
+   outro. */
+function contextoDoProjeto() {
+    if (!state.currentProject) return '';
+    return `Projeto atual: ${state.currentProject} (pasta ${shortPath(projectDir())}). `
+        + 'Pedidos como "continua", "edita", "muda", "melhora" ou "isso" são sobre ELE: '
+        + 'trabalhe nos arquivos que já existem lá, não crie outro projeto.';
+}
+
 // O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
 // na tela depois de o usuário ter mandado parar.
 let chatEmVoo = null;
@@ -1027,7 +1144,7 @@ async function runChat(promptForModel, userTextForMemory) {
         try {
             await api.requestChat(state.config.server, {
                 prompt: promptForModel,
-                history: memoria.paraEnviar(state.memoria, state.history),
+                history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
                 model: state.config.model,
                 token: state.config.token,
                 sinal: chatEmVoo.signal,
@@ -1057,6 +1174,7 @@ async function runChat(promptForModel, userTextForMemory) {
     if (text) {
         state.history.push({ role: 'user', content: userTextForMemory });
         state.history.push({ role: 'assistant', content: text });
+        resumirDepois();
         state.lastResponse = text;
         cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
         state.gravador.turno(userTextForMemory, text, { modo: 'chat' });
@@ -1121,6 +1239,7 @@ async function rodarBash(text) {
         role: 'assistant',
         content: `Saída (código ${r.code ?? 0}):\n${saida.slice(0, 4000) || '(vazia)'}`,
     });
+    resumirDepois();
 }
 
 /* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
@@ -1179,9 +1298,7 @@ async function handleSlash(text) {
                 break;
             }
             const dir = cfg.createProjectDir(rest);
-            state.workDir = dir;
-            state.currentProject = path.basename(dir);
-            state.workDirOrigem = 'projeto';
+            entrarNoProjeto(dir, 'projeto');
             console.log(c.ok(`Projeto: ${state.currentProject}`) + c.muted(`  (${dir})`));
             refreshPrompt();
             break;
@@ -1232,9 +1349,7 @@ async function handleSlash(text) {
                 }
             }
 
-            state.workDir = alvo;
-            state.currentProject = path.basename(alvo);
-            state.workDirOrigem = '/dir';
+            entrarNoProjeto(alvo, '/dir');
             const quantos = (() => { try { return fs.readdirSync(alvo).length; } catch { return 0; } })();
             console.log(c.ok(`  Trabalhando em ${shortPath(alvo)}`) + c.muted(`  (${quantos} ${quantos === 1 ? 'item' : 'itens'})`));
             refreshPrompt();
@@ -1573,17 +1688,21 @@ async function handleSlash(text) {
                    porque resposta boa de ler é ruim de ouvir — o trabalho é o
                    mesmo, o jeito de contar é que muda. */
                 pensar: async (texto) => {
+                    // Mesma memória do terminal: espera o resumo da rodada
+                    // anterior e leva só ele, com o projeto atual.
+                    await esperarResumo();
                     const plan = prepararPasta(texto);
-                    const resultado = await runAct(`${vozModo.COMO_FALAR}\n\nPEDIDO: ${texto}`, {
+                    const resultado = await runAct(texto, {
+                        instrucao: vozModo.COMO_FALAR,
                         server: state.config.server,
                         model: state.config.model,
                         effort: state.config.effort,
                         token: state.config.token,
-                        history: memoria.paraEnviar(state.memoria, state.history),
+                        history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
                         projectDir: plan.dir,
                         projectName: plan.name || state.currentProject,
                         ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
-                        autorizar: autorizarControle,
+                        autorizar: autorizarPorVoz,
                         controle: state.controle,
                     });
                     const resposta = (resultado.assistantMessage && resultado.assistantMessage.content) || '';
@@ -1591,6 +1710,7 @@ async function handleSlash(text) {
                     // continuar digitando não pode começar do zero.
                     state.history.push({ role: 'user', content: texto });
                     state.history.push({ role: 'assistant', content: resposta });
+                    resumirDepois();
                     const balanco = registro.resumo(resultado.registro, { colunas: process.stdout.columns || 80 });
                     if (balanco) console.log(balanco);
                     return resposta;
@@ -1945,6 +2065,14 @@ async function main() {
     state.workDir = cfg.ROOT_DIR;
     state.currentProject = null;
     state.workDirOrigem = 'padrao';
+    // O projeto em que se estava na última sessão (até uma semana atrás): o
+    // "continua o jogo" de amanhã cai nele, e não num projeto novo.
+    const lembrado = cfg.projetoLembrado();
+    if (lembrado && pastaSegura(lembrado.dir)) {
+        state.workDir = lembrado.dir;
+        state.currentProject = path.basename(lembrado.dir);
+        state.workDirOrigem = lembrado.origem === '/dir' ? '/dir' : 'projeto';
+    }
 
     // Modo guardado entre sessões. O padrão é auto: sem ele, um "oi" gasta o
     // mesmo que uma refatoração.

package/lib/act.js

@@ -429,12 +429,48 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     return 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
 }
 
+/* ── O MAPA DO PROJETO ───────────────────────────────────────────────────
+ * "Continua o jogo" num projeto de vinte arquivos: o agente começava às
+ * cegas, gastava uma volta listando a pasta — ou, pior, escrevia um index.html
+ * novo por cima do que existia. Agora ele recebe, junto da memória, a lista dos
+ * arquivos do projeto (até 80, sem node_modules nem build), e sabe de saída
+ * onde está cada coisa. Só em pasta de projeto: a raiz ~/primocode lista
+ * outros projetos, não este. */
+const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
+    '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
+
+function mapaDoProjeto(dir, limite = 80) {
+    const path = require('path');
+    const fs = require('fs');
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    const achados = [];
+    const andar = (atual, fundo) => {
+        if (fundo > 4 || achados.length >= limite) return;
+        let itens = [];
+        try { itens = fs.readdirSync(atual, { withFileTypes: true }); } catch { return; }
+        itens.sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? 1 : -1));
+        for (const it of itens) {
+            if (achados.length >= limite) return;
+            if (PULAR_NO_MAPA.has(it.name) || (it.name.startsWith('.') && it.name !== '.env.example')) continue;
+            const cheio = path.join(atual, it.name);
+            if (it.isDirectory()) andar(cheio, fundo + 1);
+            else if (it.name !== 'memory.md') achados.push(path.relative(dir, cheio));
+        }
+    };
+    andar(dir, 0);
+    if (!achados.length) return '';
+    const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
+    return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
+}
+
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
     if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
+    const mapa = mapaDoProjeto(projectDir);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}`);
     return parts.join('\n\n');
 }
 
@@ -454,6 +490,15 @@ async function runAct(userPrompt, opts) {
            `test/repeticao.js` e `test/continuar.js` teriam de falar com a
            internet para verificar o loop do agente. */
         motor = api,
+        /* Instrução de FORMA que vai junto do pedido mas não É o pedido — a
+           do modo voz ("responda em três frases faladas"). Ela chega ao
+           modelo; a memória e o histórico guardam só o que a pessoa disse.
+           Antes ela ia colada no texto, e a memória do projeto enchia de
+           "[MODO VOZ] A sua resposta vai ser lida em voz alta…". */
+        instrucao = '',
+        /* Quem abre a página para conferir antes do "pronto". Injetável pelo
+           mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
+        medirPagina = (dir) => require('./pipeline.js').medirNoNavegador(dir),
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -463,8 +508,49 @@ async function runAct(userPrompt, opts) {
     let criarPasta = ensureWorkDir || null;
     let pastaAtual = projectDir;      // onde as tools agem AGORA
     let temPasta = !criarPasta;       // já é a pasta definitiva?
+    /* Cria a pasta do projeto pendente, uma vez. Chamado antes de qualquer
+       ferramenta que faz código (ver `criaProjeto` no catálogo) — e ANTES do
+       subagente e do pipeline, que senão escreviam na raiz de ~/primocode. */
+    const garantirPasta = () => {
+        if (!criarPasta) return;
+        const nova = criarPasta();
+        if (nova) pastaAtual = nova;
+        criarPasta = null;
+        temPasta = true;
+    };
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
+    /* ── CONFERIR ANTES DE DIZER "PRONTO" ───────────────────────────────
+     * Mexeu em página (html, css, js) nesta tarefa? Antes de aceitar o
+     * `finish`, o PrimoCode abre a página num navegador invisível e olha: tela
+     * em branco, erro de JavaScript, recurso que não carregou. Achou problema,
+     * a tarefa volta para o agente com o relato — uma vez só, para não virar
+     * laço. É a diferença entre "pronto!" e "pronto, e abre". */
+    let mexeuNaPagina = false;       // mexeu desde a última conferência?
+    let conferencias = 0;            // até duas: entregar, e conferir o conserto
+    let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
+       ainda cabe uma volta); null quando é para entregar. O que ficar
+       quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
+       com ele — nunca "pronto" seco sobre uma página com erro. Vale para os
+       dois jeitos de terminar: a ferramenta finish e a resposta em texto. */
+    const conferirPagina = async () => {
+        if (subagent || !mexeuNaPagina || conferencias >= 2 || PARAR) return null;
+        conferencias++;
+        mexeuNaPagina = false;
+        let medida = null;
+        try {
+            fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
+            medida = await medirPagina(pastaAtual);
+        } catch { medida = null; }
+        if (!medida || !medida.testou) return null;
+        avisoDaPagina = medida.limpo ? ''
+            : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
+        if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
+        return conferencias >= 2 ? null : medida.relato;
+    };
+    const comAviso = (texto) => (avisoDaPagina
+        ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
     /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
@@ -492,6 +578,7 @@ async function runAct(userPrompt, opts) {
     if (!subagent) {
         const comSkills = skills.montar(userPrompt);
         pedido = comSkills.texto;
+        if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
         if (comSkills.skills.length) {
             fala.pensamento(`seguindo: ${comSkills.skills.map((s) => s.titulo).join(', ')}`, profundidade);
         }
@@ -627,7 +714,7 @@ async function runAct(userPrompt, opts) {
 
         emVoo = new AbortController();
         try {
-            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent, sinal: emVoo.signal }, (evt) => {
+            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
@@ -805,6 +892,21 @@ async function runAct(userPrompt, opts) {
                 finalText = '';
                 continue;
             }
+            // Terminou falando, sem chamar finish: confere a página do mesmo jeito.
+            if (finalText) {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({
+                        role: 'user',
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e finalize de novo.',
+                    });
+                    finalText = '';
+                    continue;
+                }
+                finalText = comAviso(finalText);
+            }
             if (!subagent) {
                 if (fluxo) fluxo.fechar();
                 else fala.resposta(finalText);
@@ -843,6 +945,7 @@ async function runAct(userPrompt, opts) {
         // sinal de decomposição ruim, e o excedente roda em série mesmo.
         const spawns = toolCalls.filter((tc) => tc.name === 'spawn_agent');
         const resultadosSpawn = new Map();
+        if (spawns.length && !PARAR) garantirPasta();
         if (spawns.length > 1 && !PARAR) {
             const juntos = spawns.slice(0, 4);
             fala.paralelo(juntos.length, profundidade);
@@ -855,6 +958,18 @@ async function runAct(userPrompt, opts) {
 
         for (const tc of toolCalls) {
             if (PARAR) break;
+            if (tc.name === 'finish') {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e chame finish de novo.',
+                    });
+                    continue;
+                }
+            }
             if (tc.name === 'finish') {
                 // Encerrar com falha pendente é como o agente dizia "pronto!"
                 // sem ter mudado nada. Devolvemos a tarefa para ele.
@@ -869,7 +984,7 @@ async function runAct(userPrompt, opts) {
                     continue;
                 }
                 algoRodou = true;
-                finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
+                finished = comAviso((tc.arguments && tc.arguments.summary) || 'Concluído.');
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
@@ -906,6 +1021,7 @@ async function runAct(userPrompt, opts) {
                esquecer de passar o token ou a pasta. */
             if (tc.name === 'construir_app') {
                 algoRodou = true;
+                garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
@@ -928,12 +1044,7 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
-            if (criarPasta && catalogo.escreveArquivo(tc.name)) {
-                const nova = criarPasta();
-                if (nova) pastaAtual = nova;
-                criarPasta = null;
-                temPasta = true;
-            }
+            if (criarPasta && catalogo.criaProjeto(tc.name, tc.arguments)) garantirPasta();
 
             if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
                 voltasEmFalso++;
@@ -973,6 +1084,10 @@ async function runAct(userPrompt, opts) {
             // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
             // tarefa de trinta ações, a primeira já saiu da tela.
             registro.anotar(livro, tc.name, tc.arguments, result);
+            if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
+                && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
+                mexeuNaPagina = true;
+            }
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
             // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
@@ -1209,9 +1324,13 @@ async function rodarPipeline(args, ctx) {
     const path = require('path');
     const pedido = args.pedido || args.prompt || '';
     const base = projectDir || cfg.ROOT_DIR;
+    /* Dentro de um projeto, o app é montado NA pasta dele. A subpasta com
+       nome derivado do pedido só vale na raiz: era ela que fazia o app nascer
+       num lugar que a conversa nunca mais achava. */
+    const naRaiz = path.resolve(base) === path.resolve(cfg.ROOT_DIR);
     const pasta = args.pasta
         ? path.resolve(base, args.pasta)
-        : pipeline.pastaPara(pedido, base);
+        : (naRaiz ? pipeline.pastaPara(pedido, base) : base);
 
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';