primocode 10.5.0 → 10.6.0

package/lib/agents-md.js

@@ -0,0 +1,140 @@
+/**
+ * agents-md.js — a memória da conversa mora NA PASTA, num AGENTS.md.
+ *
+ *   "Eu preciso de um AGENTS.md com a memória da conversa em cada pasta."
+ *   (11/10/2026)
+ *
+ * O resumo da conversa (lib/memoria-conversa.js) já existia, mas vivia só na
+ * memória do processo: fechar o terminal apagava o "de onde parei". Agora,
+ * a cada resposta, ele é escrito no AGENTS.md da pasta em que se está — e a
+ * próxima sessão aberta ali lê e continua.
+ *
+ * ── POR QUE AGENTS.md, E POR QUE SÓ UM BLOCO DELE ────────────────────────
+ * AGENTS.md é o arquivo que Codex, Cursor e Claude Code já leem; a memória
+ * escrita aqui serve a qualquer agente que abrir a pasta. Mas o repo da
+ * pessoa pode JÁ TER um AGENTS.md, escrito por ela. Então o PrimoCode só
+ * escreve entre as duas marcas abaixo e nunca toca no resto: se o arquivo não
+ * existe, nasce com o bloco; se existe sem bloco, o bloco vai no fim; se tem
+ * bloco, só o miolo dele muda.
+ *
+ * ── CURTO DE PROPÓSITO ───────────────────────────────────────────────────
+ * O bloco entra no contexto de todo pedido naquela pasta. Teto de 2.400
+ * letras: o resumo já é podado por quem resume (250 palavras), e o teto
+ * aqui é a trava para o dia em que não for.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ARQUIVO = 'AGENTS.md';
+const INICIO = '<!-- primocode:memoria -->';
+const FIM = '<!-- /primocode:memoria -->';
+const TETO = 2400;
+
+function escaparRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+const RE_BLOCO = new RegExp(`${escaparRe(INICIO)}[\\s\\S]*?${escaparRe(FIM)}`);
+
+/** O miolo do bloco (sem cabeçalho nem marcas), ou ''. */
+function extrair(texto) {
+    const m = String(texto || '').match(RE_BLOCO);
+    if (!m) return '';
+    return m[0].slice(INICIO.length, -FIM.length)
+        .replace(/^\s*## Memória do PrimoCode\s*\n/, '')
+        .replace(/^\s*>.*\n/, '')
+        .trim();
+}
+
+/** O texto da PESSOA: o arquivo sem o bloco da memória. */
+function semBloco(texto) {
+    const resto = String(texto || '').replace(RE_BLOCO, '').replace(/\n{3,}/g, '\n\n').trim();
+    // Só o título que o próprio PrimoCode pôs ao criar o arquivo: não é
+    // instrução de ninguém, e não pode tapar o CLAUDE.md do repo.
+    return /^#[^\n]*$/.test(resto) ? '' : resto;
+}
+
+/**
+ * Corta no fim de uma linha, nunca no meio: o resumo vem em tópicos, e meio
+ * tópico é pior que tópico nenhum.
+ */
+function encurtar(corpo, teto = TETO) {
+    const t = String(corpo || '').trim();
+    if (t.length <= teto) return t;
+    const linhas = t.split('\n');
+    let saida = '';
+    for (const l of linhas) {
+        if ((saida + l).length + 1 > teto - 12) break;
+        saida += (saida ? '\n' : '') + l;
+    }
+    return (saida || t.slice(0, teto - 12)) + '\n(… cortado)';
+}
+
+function quandoLocal(d = new Date()) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+function bloco(corpo, quando) {
+    return [
+        INICIO,
+        '## Memória do PrimoCode',
+        `> Escrita pelo PrimoCode a cada resposta (${quando}). Ele lê isto ao abrir esta pasta e continua daqui. Fora deste bloco ele nunca mexe.`,
+        '',
+        encurtar(corpo),
+        FIM,
+    ].join('\n');
+}
+
+/**
+ * O arquivo novo, a partir do que existe. Puro: é aqui que mora a promessa
+ * de não estragar o que a pessoa escreveu, e o teste mede sem disco.
+ */
+function aplicar(existente, corpo, { titulo = 'Projeto', quando = quandoLocal() } = {}) {
+    const novo = bloco(corpo, quando);
+    if (existente == null || !String(existente).trim()) return `# ${titulo}\n\n${novo}\n`;
+    const texto = String(existente);
+    // Função no replace: um "$&" dentro do resumo não pode virar padrão.
+    if (RE_BLOCO.test(texto)) return texto.replace(RE_BLOCO, () => novo);
+    return `${texto.replace(/\s+$/, '')}\n\n${novo}\n`;
+}
+
+/**
+ * Pasta onde vale escrever. A home e a raiz do disco não: um AGENTS.md
+ * solto em ~ seria lido por todo agente de todo projeto. A raiz de trabalho
+ * (~/primocode) também não — é o corredor, não um projeto, e o dono já
+ * reclamou dos arquivos soltos ali.
+ */
+function podeGravar(dir, { raiz } = {}) {
+    if (!dir) return false;
+    const alvo = path.resolve(dir);
+    if (alvo === path.resolve(os.homedir())) return false;
+    if (alvo === path.parse(alvo).root) return false;
+    if (raiz && alvo === path.resolve(raiz)) return false;
+    try { return fs.statSync(alvo).isDirectory(); } catch { return false; }
+}
+
+/** A memória gravada nesta pasta, ou ''. */
+function ler(dir) {
+    if (!dir) return '';
+    try { return extrair(fs.readFileSync(path.join(dir, ARQUIVO), 'utf-8')); } catch { return ''; }
+}
+
+/**
+ * Grava (ou atualiza) o bloco. Devolve true quando escreveu. Não reescreve
+ * se o miolo não mudou: o arquivo é do repo da pessoa, e mexer na data à toa
+ * suja o `git status` dela a cada resposta.
+ */
+function gravar(dir, corpo, opts = {}) {
+    const limpo = String(corpo || '').trim();
+    if (!limpo || !podeGravar(dir, opts)) return false;
+    const arq = path.join(dir, ARQUIVO);
+    let existente = null;
+    try { existente = fs.readFileSync(arq, 'utf-8'); } catch { existente = null; }
+    if (existente != null && extrair(existente) === encurtar(limpo)) return false;
+    const novo = aplicar(existente, limpo, { titulo: opts.titulo || path.basename(path.resolve(dir)), quando: opts.quando });
+    try { fs.writeFileSync(arq, novo, 'utf-8'); return true; } catch { return false; }
+}
+
+module.exports = { ARQUIVO, INICIO, FIM, TETO, extrair, semBloco, encurtar, aplicar, podeGravar, ler, gravar };

package/lib/auditoria.js

@@ -0,0 +1,122 @@
+/**
+ * auditoria.js — anota ANTES de agir (o "decide, registra, age" do OpenBot).
+ *
+ * O registro.js faz o balanço do pedido na tela, e some quando a tela fecha.
+ * Este é o livro que fica: ~/.primocode/registro/acoes-AAAA-MM-DD.jsonl, uma
+ * linha por decisão, escrita ANTES de a ferramenta rodar — então o que foi
+ * recusado (perigo, permissão, freio) e o que travou no meio também aparece.
+ * Depois vem uma segunda linha com o resultado, ligada pelo `id`.
+ *
+ * Nunca guarda conteúdo de arquivo nem ambiente: argumento longo vira
+ * "<N caracteres>", chave com cara de segredo vira "***". Um arquivo por dia,
+ * com teto de tamanho, e os de mais de RETER_DIAS dias são apagados.
+ * Falhar aqui nunca derruba o agente — mas também nunca some calado: passou
+ * do teto, abre o arquivo seguinte do dia (acoes-AAAA-MM-DD.2.jsonl); não deu
+ * para gravar, `problema()` devolve o porquê, uma vez, e o act.js mostra na
+ * tela. Antes, o livro cheio parava de gravar em silêncio, e quem enchesse o
+ * dia de propósito cegava o resto dele (review do #95, item 3).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_BYTES = 5 * 1024 * 1024;
+const RETER_DIAS = 14;
+const LONGOS = /^(content|new_string|old_string|edits|texto|text|body|html|script)$/i;
+const SEGREDO_CHAVE = /(token|senha|password|secret|api[_-]?key|auth|cookie|credencial)/i;
+
+let seq = 0;
+let limpou = false;
+let problemaNovo = null;
+const problemasMostrados = new Set();
+
+const pasta = () => path.join(os.homedir(), '.primocode', 'registro');
+function arquivoDoDia(d = new Date(), parte = 1) {
+    const p = (n) => String(n).padStart(2, '0');
+    const sufixo = parte > 1 ? `.${parte}` : '';
+    return path.join(pasta(), `acoes-${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}${sufixo}.jsonl`);
+}
+
+/** O arquivo do dia que ainda cabe: o primeiro abaixo do teto. */
+function arquivoComEspaco(d = new Date()) {
+    for (let parte = 1; ; parte++) {
+        const arq = arquivoDoDia(d, parte);
+        let tamanho = 0;
+        try { tamanho = fs.statSync(arq).size; } catch { return arq; }
+        if (tamanho <= MAX_BYTES) return arq;
+    }
+}
+
+function semSegredo(texto) {
+    return String(texto)
+        .replace(/\b(sk|ghp|gho|ghs|xox[abp]|pk|rk)[-_][A-Za-z0-9_-]{8,}/g, '***')
+        .replace(/((?:token|senha|password|secret|api[_-]?key)\s*[=:]\s*)\S+/gi, '$1***')
+        .replace(/(authorization:\s*bearer\s+)\S+/gi, '$1***');
+}
+
+/** O resumo dos argumentos: curto, sem conteúdo e sem segredo. */
+function resumirArgs(args) {
+    const out = {};
+    for (const [k, v] of Object.entries(args || {})) {
+        if (SEGREDO_CHAVE.test(k)) out[k] = '***';
+        else if (LONGOS.test(k)) out[k] = `<${JSON.stringify(v == null ? '' : v).length} caracteres>`;
+        else if (typeof v === 'string') out[k] = semSegredo(v.length > 160 ? v.slice(0, 160) + '…' : v);
+        else if (v && typeof v === 'object') out[k] = semSegredo(JSON.stringify(v).slice(0, 160));
+        else out[k] = v;
+    }
+    return out;
+}
+
+function limparVelhos() {
+    if (limpou) return;
+    limpou = true;
+    const limite = Date.now() - RETER_DIAS * 86400000;
+    for (const nome of fs.readdirSync(pasta())) {
+        const m = /^acoes-(\d{4}-\d{2}-\d{2})(?:\.\d+)?\.jsonl$/.exec(nome);
+        if (m && Date.parse(m[1]) < limite) fs.unlinkSync(path.join(pasta(), nome));
+    }
+}
+
+function escrever(linha) {
+    try {
+        fs.mkdirSync(pasta(), { recursive: true });
+        limparVelhos();
+        fs.appendFileSync(arquivoComEspaco(), JSON.stringify(linha) + '\n');
+        return true;
+    } catch (e) {
+        // O livro nunca derruba o agente, mas a falha aparece (problema()).
+        const motivo = `o livro de ações não está gravando (${(e && e.code) || (e && e.message) || e})`;
+        if (!problemasMostrados.has(motivo)) problemaNovo = motivo;
+        return false;
+    }
+}
+
+/** A falha de gravação ainda não mostrada, uma vez; depois, null. */
+function problema() {
+    const p = problemaNovo;
+    problemaNovo = null;
+    if (p) problemasMostrados.add(p);
+    return p;
+}
+
+/** A linha de ANTES. Devolve o id para ligar o resultado. */
+function antes({ agente, ferramenta, args, decisao, motivo }) {
+    const id = `${process.pid}-${Date.now().toString(36)}-${++seq}`;
+    const linha = { id, quando: new Date().toISOString(), agente, ferramenta, args: resumirArgs(args), decisao };
+    if (motivo) linha.motivo = semSegredo(String(motivo).slice(0, 200));
+    escrever(linha);
+    return id;
+}
+
+/** A linha de DEPOIS: deu certo ou não, e o erro curto. */
+function depois(id, result) {
+    const ok = !(result && result.ok === false);
+    const linha = { id, quando: new Date().toISOString(), resultado: ok ? 'ok' : 'falhou' };
+    if (!ok && result.error) linha.erro = semSegredo(String(result.error).slice(0, 200));
+    escrever(linha);
+}
+
+module.exports = { antes, depois, problema, resumirArgs, arquivoDoDia, arquivoComEspaco, MAX_BYTES, RETER_DIAS };

package/lib/browser.js

@@ -1164,6 +1164,12 @@ async function abaEscondida(url, op = {}) {
         await s.send('Page.enable');
         await s.send('Runtime.enable');
         await s.send('Log.enable');
+        // A leitura em cascata pede isto: o Chrome segue redirect e o
+        // JavaScript da página pede a rede sozinho. A mesma trava da busca
+        // simples (hostBloqueado) vale para cada pedido, não só para a URL
+        // inicial. Sem isto, uma página pública abre e o passo 2 alcança a
+        // rede local (review do #96).
+        if (op.bloquearPrivado) await travarRedeLocal(s);
         // A aba nova nasce ATRÁS do about:blank inicial, e aba de fundo é
         // onde o Chrome economiza: para o vídeo, estrangula os timers. Trazer
         // para a frente é o que faz a página se comportar como na tela da pessoa.
@@ -1232,6 +1238,47 @@ async function abrirEscondido(url) {
     return { fechar: aba.fechar, erros: aba.erros };
 }
 
+/* Rede local, link-local e arquivo: a mesma lista da busca simples. Exigir
+   aqui, e não só em referencia.js, porque o Chrome é quem abre a URL. */
+function destinoDeRedeLocal(url) {
+    let u;
+    try { u = new URL(url); } catch { return true; }
+    if (u.protocol === 'file:') return true;
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return false;
+    return require('./referencia').hostBloqueado(u.hostname);
+}
+
+async function travarRedeLocal(s) {
+    const anterior = s.onEvent;
+    s.onEvent = (metodo, p) => {
+        if (metodo === 'Fetch.requestPaused') {
+            const bloquear = destinoDeRedeLocal(p.request && p.request.url);
+            const chamada = bloquear ? 'Fetch.failRequest' : 'Fetch.continueRequest';
+            const params = bloquear
+                ? { requestId: p.requestId, errorReason: 'BlockedByClient' }
+                : { requestId: p.requestId };
+            s.send(chamada, params).catch(() => {});
+        }
+        if (anterior) anterior(metodo, p);
+    };
+    await s.send('Fetch.enable', { patterns: [{ urlPattern: '*', requestStage: 'Request' }] });
+}
+
+/* O HTML que a página tem DEPOIS de rodar o JavaScript: o passo 2 da leitura
+   em cascata (lib/leitura.js), pra página que a busca simples devolve vazia. */
+async function htmlEscondido(url, op = {}) {
+    if (destinoDeRedeLocal(url)) return null;
+    const aba = await abaEscondida(url, { prazoLoad: op.prazo || 12000, assentar: op.assentar || 1500, bloquearPrivado: true });
+    try {
+        const r = await aba.sessao.send('Runtime.evaluate', {
+            expression: 'document.documentElement.outerHTML', returnByValue: true,
+        }).catch(() => null);
+        return (r && r.result && r.result.value) || null;
+    } finally {
+        await aba.fechar();
+    }
+}
+
 /* O revisor é ferramenta de uma tarefa, não um processo que fica. Deixá-lo de
    pé come memória até a pessoa desligar o computador, e ele não é o navegador
    dela — ninguém sentiria falta nem saberia que existe para fechar. */
@@ -1296,5 +1343,5 @@ module.exports = {
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
-    inspecionarEscondido, rodarEscondido, abrirEscondido, abaEscondida, fecharRevisor, subirRevisor, aquecerRevisor,
+    inspecionarEscondido, rodarEscondido, abrirEscondido, abaEscondida, htmlEscondido, fecharRevisor, subirRevisor, aquecerRevisor,
 };

package/lib/catalogo.js

@@ -31,9 +31,9 @@ const GRUPOS = [
             { tool: 'list_dir',   escreve: false, faz: 'mostra a árvore de pastas',
               args: 'path (opcional, padrão "."). depth (opcional, número, padrão 2).' },
             { tool: 'glob',       escreve: false, faz: 'acha arquivo pelo nome (**/*.js)',
-              args: 'pattern: padrão de nome, ex "**/*.js" ou "src/**/*.{ts,tsx}".' },
+              args: 'pattern: padrão de nome, ex "**/*.js" ou "src/**/*.{ts,tsx}". Numa pasta que o usuário citou: padrão absoluto ("/caminho/**/*.js"), sem trocar a de trabalho.' },
             { tool: 'grep',       escreve: false, faz: 'acha texto dentro dos arquivos',
-              args: 'pattern: expressão regular. glob (opcional): restringe aos arquivos que casam. ignoreCase (opcional, bool). contexto (opcional, número): linhas ao redor do achado.' },
+              args: 'pattern: expressão regular. glob (opcional): restringe aos arquivos que casam. ignoreCase (opcional, bool). contexto (opcional, número): linhas ao redor do achado. Numa pasta que o usuário citou: glob absoluto ("/caminho/**"), sem trocar a de trabalho.' },
         ],
     },
     {
@@ -93,8 +93,8 @@ const GRUPOS = [
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
-                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
-                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (a ANIMAÇÃO 3D de verdade, o vídeo GRAVADO em 3D, no visual de blocos/voxel de render de cinema: bonecos de blocos e o mascote laranja (quem é IA) num set de ladrilhos com uma parede de telas, luz roxa de recorte, o fundo desfocado de lente e a legenda branca no meio — cada parte é UMA fala {falante, texto, emocao?, destaque?}, sem tipo; a boca segue a voz, gestos, e a câmera corta entre aberto, ombro e close de baixo; é a escolha para animação 3D, personagem, boneco, avatar, mascote, podcast, entrevista ou alguém FALANDO em 3D — um narrador só também serve (sem falante). As telas do fundo mostram o ASSUNTO: paineis:["título curto", …] (até 12) — vazio, saem dos destaques e das palavras fortes. Com dois falantes (falante em cada parte) eles conversam; personagens:{"nome":{tipo:robo|pessoa, pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba, rotulo}} — nome de IA vira robô sozinho; emocao feliz|serio|surpreso|pensativo|animado|curioso e destaque:"texto curto" (o cartão na tela) em cada parte; cenario telas (o roxo da referência, padrão)|neon|oceano|terra; cor do mascote: personagens:{"claude":{cor:"#d97757"}}; visual:"liso" só se pedirem o boneco liso antigo). '
+                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega — a COISA que a frase nomeia, 2 a 4 palavras, não a frase inteira; rota:"tipografia" em número/citação, "produto" quando a frase fala do produto; ancora:"palavra" — o clipe troca 0,2 s depois dela) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (a ANIMAÇÃO 3D de verdade, o vídeo GRAVADO em 3D no visual de blocos/voxel de render de cinema — é a escolha para animação 3D, personagem, bicho, boneco, avatar, mascote, podcast, entrevista ou alguém FALANDO em 3D; cada parte é UMA fala {falante, texto, emocao?, destaque?, acao?, cenario?}, sem tipo). NADA É FIXO, monte o que a pessoa pediu: cena:"texto livre do lugar" (praia, cidade, floresta, parque, fazenda, neve, deserto, espaço, fundo do mar, escritório, sala, cozinha, escola, palco… + hora: "à noite", "ao pôr do sol") ou cena:{lugar, hora, elementos:["palmeira","barraca","violão",…]} — elemento fora do catálogo vira ícone 3D em blocos; parte.cenario muda o lugar a partir daquela fala. Até 4 falantes; personagens:{"nome":{tipo:pessoa|robo|animal|coisa, especie (animal: cachorro|gato|cavalo|vaca|porco|ovelha|raposa|lobo|urso|panda|coelho|leao|tigre|elefante|girafa|tartaruga|galinha|pato|passaro|papagaio|coruja|pinguim|peixe|tubarao|golfinho|dinossauro|sapo|macaco), icone (coisa: "pizza", "café", "polvo" — qualquer objeto/bicho que fala), pessoa: pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba; robo: cor}} — sem tipo, o nome decide (nome de bicho vira bicho, de IA vira o mascote laranja, de objeto vira coisa); figurantes:["cachorro","pessoa"] (quem está na cena sem falar); BICHO NÃO FALA: a fala de um bicho sai da narração e ele fica na cena — só fala se a pessoa pedir ("cachorro falante") ou personagens.x.fala:true; a voz de cada falante sai do GÊNERO do nome (personagens.x.genero:f|m manda), uma voz por personagem do começo ao fim; bigode:true e cabeca:"cubo" (o rosto de pixel antigo) em personagens; sem lugar no pedido, o set é a cobertura à noite (janela da cidade, cartões de interface na frente). acao em cada parte: acenar|apontar|pular|dancar|comemorar|pensar|andar|correr. emocao feliz|serio|surpreso|pensativo|animado|curioso; destaque:"texto curto"; paineis:["título",…] só no set de telas (o padrão quando o pedido não diz lugar); visual:"liso" só se pedirem o boneco liso antigo). '
                 + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
@@ -171,6 +171,20 @@ const GRUPOS = [
                 + 'A pauta é para LER e compor com as primitivas — não copie os campos dela para dentro do plano.' },
         ],
     },
+    {
+        /* MCP primeiro, mouse por último: o serviço pela API dele (Notion,
+           GitHub, Slack…) é uma chamada; o mesmo pela tela são vinte cliques. */
+        nome: 'Conectores',
+        resumo: 'MCP: age num serviço ou app pela API dele, sem mouse — procura, conecta e usa',
+        itens: [
+            { tool: 'mcp_procurar', escreve: false, faz: 'acha o servidor MCP de um serviço (lista curada + registro oficial)',
+              args: 'busca: o serviço ou app, ex "notion", "github", "planilha".' },
+            { tool: 'mcp_conectar', escreve: false, faz: 'instala, sobe e valida um servidor MCP — pede autorização antes',
+              args: 'nome: curto, ex "notion" (curado: só o nome basta). comando (opcional) e args (opcional, lista): do "instalar" do mcp_procurar. env (opcional, objeto): as chaves que o servidor pede — sem elas, pergunte ao usuário.' },
+            { tool: 'mcp_usar', escreve: false, faz: 'chama uma ferramenta de um servidor MCP conectado',
+              args: 'servidor: nome do servidor. ferramenta: nome da tool dele. argumentos (opcional, objeto): os args da tool.' },
+        ],
+    },
     {
         nome: 'Computador',
         resumo: 'janelas, botões, mouse e teclado — age em qualquer programa e na área de trabalho',
@@ -214,6 +228,12 @@ const GRUPOS = [
             // ser para os outros casos). Esta tool é a única porta pra lá.
             { tool: 'remember_general', escreve: false, faz: 'grava algo sobre o usuário que vale para todo projeto (memory-geral.md)',
               args: 'fato: o que lembrar, em uma frase.' },
+            // A troca de pasta pede o SIM do usuário, e quem pergunta é o bin:
+            // por isso o loop (lib/act.js) atende, não o tools.execute.
+            { tool: 'mudar_pasta', escreve: false, noLoop: true,
+              faz: 'troca a pasta de trabalho para outra que o usuário citou — só depois do sim dele',
+              args: 'caminho: a pasta (absoluto, ~/…, ou o nome de um projeto). motivo: uma frase do porquê, aparece na pergunta ao usuário. '
+                + 'Para só LER lá não precisa trocar: read_file/list_dir com o caminho absoluto, glob/grep com padrão absoluto.' },
             // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente especialista para uma parte da tarefa', noLoop: true,
               args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): frontend, backend, testes, design, dados, revisor ou ambiente — cada um chega com o briefing da profissão (lib/especialistas.js); sem ele, a tarefa sugere.' },

package/lib/comandos-extra.js

@@ -466,6 +466,8 @@ const ATALHOS = [
     ['Ctrl+C', 'limpa o que foi digitado; com a caixa vazia, sai'],
     ['Ctrl+D', 'sai (com a caixa vazia)'],
     ['Ctrl+L', 'limpa a tela'],
+    ['PgUp · PgDn', 'rola a conversa'],
+    ['arrastar o mouse', 'seleciona texto; Cmd+C (Mac) ou Ctrl+Shift+C copia'],
     ['Ctrl+A · Ctrl+E', 'vai para o começo · o fim da linha'],
     ['Ctrl+U · Ctrl+K', 'apaga antes · depois do cursor'],
     ['Ctrl+W', 'apaga a palavra antes do cursor'],

package/lib/config.js

@@ -13,6 +13,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { nomeCurto } = require('./nome-curto.js');
 
 const HOME = os.homedir();
 const ROOT_DIR = path.join(HOME, 'primocode');
@@ -106,12 +107,27 @@ function slugify(name) {
         .replace(/-+$/, '');   // o corte pode deixar hífen no fim
 }
 
+/* O nome da pasta de um projeto em ~/primocode.
+ *
+ * Curto e legível (lib/nome-curto.js): "landing da padaria do zé com
+ * cardápio" vira `landing-padaria-ze-cardapio`, não a frase inteira. Mas uma
+ * pasta que JÁ existe com o nome comprido de antes continua sendo ela —
+ * renomear sozinho o projeto de alguém é pior que um nome feio. */
+function nomeDaPasta(projectName) {
+    const antigo = slugify(projectName);
+    if (antigo && fs.existsSync(path.join(ROOT_DIR, antigo))) return antigo;
+    // Já veio como nome de pasta (do modelo, do /novo, com o -2 da colisão):
+    // passar de novo pela régua tiraria o "-2" e cairia no projeto do vizinho.
+    if (/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/.test(String(projectName || '')) && antigo.length <= 40) return antigo;
+    return nomeCurto(projectName) || antigo;
+}
+
 function createProjectDir(projectName) {
     ensureStructure();
     /* Nome sem letra nem número ("!!!", só emoji, só japonês) dava slug
        VAZIO — e path.join(ROOT_DIR, '') é a própria raiz: o "projeto" virava
        ~/primocode, com memory.md gravado nela. */
-    const slug = slugify(projectName) || `projeto-${today()}`;
+    const slug = nomeDaPasta(projectName) || `projeto-${today()}`;
     const projectDir = path.join(ROOT_DIR, slug);
     ensureDir(projectDir);
     const memoryPath = path.join(projectDir, 'memory.md');
@@ -123,7 +139,7 @@ function createProjectDir(projectName) {
 
 function getProjectDir(projectName) {
     if (!projectName) return ROOT_DIR;
-    return path.join(ROOT_DIR, slugify(projectName));
+    return path.join(ROOT_DIR, nomeDaPasta(projectName) || slugify(projectName));
 }
 
 function listProjects() {
@@ -348,13 +364,25 @@ function appendHistory(entry) {
  * ativo fica guardado aqui, num arquivo só dele (a config tem lista fechada de
  * campos), e a próxima sessão continua nele. Vale por uma semana: depois
  * disso, abrir o PrimoCode e cair num projeto esquecido seria a surpresa. */
+/* As RECENTES vão junto, no mesmo arquivo: são as pastas em que a pessoa
+   trabalhou, e é por elas que "olha lá no repo do site" acha o site sem a
+   pessoa digitar o caminho (lib/outra-pasta.js). Dez bastam. */
 function lembrarProjeto(dir, origem = 'projeto') {
     try {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
-        fs.writeFileSync(PROJETO_ATIVO_FILE, JSON.stringify({ dir, origem, quando: Date.now() }, null, 2), 'utf-8');
+        const recentes = [dir, ...pastasRecentes().filter((d) => path.resolve(d) !== path.resolve(dir))].slice(0, 10);
+        fs.writeFileSync(PROJETO_ATIVO_FILE, JSON.stringify({ dir, origem, quando: Date.now(), recentes }, null, 2), 'utf-8');
     } catch { /* lembrar é conveniência: falhou, a sessão segue igual */ }
 }
 
+function pastasRecentes() {
+    try {
+        const j = JSON.parse(fs.readFileSync(PROJETO_ATIVO_FILE, 'utf-8'));
+        const lista = Array.isArray(j.recentes) ? j.recentes : (j.dir ? [j.dir] : []);
+        return lista.filter((d) => typeof d === 'string' && d);
+    } catch { return []; }
+}
+
 function projetoLembrado(maxDias = 7) {
     try {
         const j = JSON.parse(fs.readFileSync(PROJETO_ATIVO_FILE, 'utf-8'));
@@ -370,7 +398,7 @@ function esquecerProjeto() {
 
 module.exports = {
     tokensDoAssunto, GENERICAS,
-    lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
+    lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE, pastasRecentes, nomeDaPasta,
     loadConfig, saveConfig, appendHistory, servidor, SERVIDOR,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify, stripAccents,

package/lib/entrada.js

@@ -311,7 +311,7 @@ class Entrada extends EventEmitter {
         this._aoTeclar = (ch, key) => this._tecla(ch, key);
         process.stdin.on('keypress', this._aoTeclar);
 
-        this._aoRedimensionar = () => { if (this.cheia) this._pintar(); else if (this.desenhado) this._redesenhar(); };
+        this._aoRedimensionar = () => { if (this.cheia) { this._quadroAnterior = null; this._pintar(); } else if (this.desenhado) this._redesenhar(); };
         process.stdout.on('resize', this._aoRedimensionar);
 
         /* Todo `console.log` do programa passa a apagar a caixa antes de
@@ -399,7 +399,7 @@ class Entrada extends EventEmitter {
     suspender() { this.suspenso = true; if (this.cheia) this._agendar(); else this._apagar(); }
     retomar() {
         this.suspenso = false;
-        if (this.cheia && this.ativo && !this.fechado) { this.painelTexto = null; return this._pintar(); }
+        if (this.cheia && this.ativo && !this.fechado) { this.painelTexto = null; this._quadroAnterior = null; return this._pintar(); }
         if (this.ativo && !this.fechado) this._desenhar();
     }
 
@@ -412,8 +412,13 @@ class Entrada extends EventEmitter {
     // ── a tela cheia ─────────────────────────────────────────────────────
 
     /* A tela alternativa (a do vim): o que estava no terminal fica guardado e
-       volta inteiro na saída. Com ela, a roda do mouse — senão o terminal
-       transformaria a roda em seta para cima e a seta é o histórico. */
+       volta inteiro na saída.
+
+       SEM capturar o mouse (o modo 1000 do xterm). Capturar dava a roda para rolar a
+       conversa, mas tirava do terminal o clique-e-arrasta: ninguém conseguia
+       selecionar um trecho da resposta para copiar ("na CLI não consigo
+       selecionar texto", 11/10). Selecionar vale mais que a roda: rolar fica
+       no PgUp/PgDn, e o /copiar copia a resposta inteira. */
     _entrarNaTela() {
         if (this._naTela) return;
         this._naTela = true;
@@ -430,10 +435,11 @@ class Entrada extends EventEmitter {
                 set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
             });
         }
-        this.escreverCru('\x1b[?1049h\x1b[?1000h\x1b[?1006h\x1b[2J');
+        this.escreverCru('\x1b[?1049h\x1b[2J');
+        this._quadroAnterior = null;   // a tela foi limpa: o próximo quadro vai inteiro
         if (!this._aoSairDoProcesso) {
             // Um erro que derruba o programa não pode deixar o terminal na
-            // tela alternativa, sem cursor e capturando o mouse.
+            // tela alternativa e sem cursor.
             this._aoSairDoProcesso = () => this._sairDaTela();
             process.on('exit', this._aoSairDoProcesso);
         }
@@ -442,7 +448,9 @@ class Entrada extends EventEmitter {
     _sairDaTela() {
         if (!this._naTela) return;
         this._naTela = false;
-        this.escreverCru('\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?1049l');
+        /* Desliga o mouse mesmo sem ter ligado: uma versão antiga (ou um
+           crash dela) pode ter deixado o terminal capturando o clique. */
+        this.escreverCru('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?25h\x1b[?1049l');
     }
 
     /** Junta as mudanças de um mesmo instante num quadro só. */
@@ -494,9 +502,21 @@ class Entrada extends EventEmitter {
         if (!this.cheia || this.fechado || !this._naTela) return;
         const q = this._quadroCheio();
         this.rolagem = Math.min(this.rolagem, q.rolagemMax);
-        let out = '\x1b[?25l';
-        q.linhas.forEach((l, i) => { out += `\x1b[${i + 1};1H${l}\x1b[0m\x1b[K`; });
-        out += `\x1b[${q.cursor.linha + 1};${q.cursor.coluna + 1}H\x1b[?25h`;
+        /* Só reescreve a linha que MUDOU. Repintar a tela inteira a cada
+           quadro (140 ms enquanto trabalha) apagava a seleção do mouse no
+           meio do arrasto: o terminal desfaz a seleção quando a linha
+           selecionada é reescrita. A conversa parada fica intocada. */
+        const antes = this._quadroAnterior;
+        const mesmoTamanho = antes && antes.linhas.length === q.linhas.length;
+        let corpo = '';
+        q.linhas.forEach((l, i) => {
+            if (mesmoTamanho && antes.linhas[i] === l) return;
+            corpo += `\x1b[${i + 1};1H${l}\x1b[0m\x1b[K`;
+        });
+        const mesmoCursor = antes && antes.cursor.linha === q.cursor.linha && antes.cursor.coluna === q.cursor.coluna;
+        this._quadroAnterior = { linhas: q.linhas, cursor: q.cursor };
+        if (!corpo && mesmoCursor) { this.desenhado = { linhas: q.linhas, cursorLinha: q.cursor.linha }; return; }
+        const out = (corpo ? '\x1b[?25l' + corpo : '') + `\x1b[${q.cursor.linha + 1};${q.cursor.coluna + 1}H` + (corpo ? '\x1b[?25h' : '');
         this._pintando = true;
         this.escreverCru(out);
         this._pintando = false;
@@ -692,7 +712,9 @@ class Entrada extends EventEmitter {
         }
 
         /* A roda do mouse chega como "\x1b[<64;x;yM", e o readline a entrega
-           picada, tecla por tecla. Daqui até o M (ou m), tudo é do mouse. */
+           picada, tecla por tecla. Daqui até o M (ou m), tudo é do mouse.
+           Não ligamos mais a captura, mas um terminal que ficou com ela
+           ligada (de outro programa) não pode digitar lixo na caixa. */
         if (key && key.code === '[<') { this._mouse = ''; return; }
         if (this._mouse != null) {
             if (/^[mM]$/.test(seq)) {

package/lib/estudio/colecao.js

@@ -55,6 +55,27 @@ const PT_EN = {
     surpreso: 'surprised', cerebro: 'brain', 'cérebro': 'brain', olho: 'eye', mao: 'hand', 'mão': 'hand', joinha: 'thumbs up',
     palmas: 'clapping', aplauso: 'clapping', calendario: 'calendar', 'calendário': 'calendar', saco: 'money bag', banco: 'bank',
     cartao: 'credit card', 'cartão': 'credit card', loja: 'shopping', compras: 'shopping cart', voto: 'ballot box', ferramenta: 'hammer',
+    // Comida, objeto e veículo: o que vira personagem ou peça da cena 3D (mundo.js).
+    hamburguer: 'hamburger', 'hambúrguer': 'hamburger', batata: 'potato', 'batata frita': 'french fries', sorvete: 'ice cream', bolo: 'birthday cake',
+    chocolate: 'chocolate bar', maca: 'red apple', 'maçã': 'red apple', uva: 'grapes', morango: 'strawberry', abacaxi: 'pineapple', melancia: 'watermelon',
+    cenoura: 'carrot', ovo: 'egg', queijo: 'cheese wedge', leite: 'glass of milk', cerveja: 'beer mug', vinho: 'wine glass', suco: 'beverage box',
+    refrigerante: 'cup with straw', sanduiche: 'sandwich', 'sanduíche': 'sandwich', sushi: 'sushi', 'cachorro-quente': 'hot dog', pipoca: 'popcorn',
+    rosquinha: 'doughnut', donut: 'doughnut', biscoito: 'cookie', abacate: 'avocado', coco: 'coconut', taco: 'taco', croissant: 'croissant',
+    barraca: 'tent', fogueira: 'fire', palmeira: 'palm tree', violao: 'guitar', 'violão': 'guitar', guitarra: 'guitar', bola: 'soccer ball',
+    bicicleta: 'bicycle', moto: 'motorcycle', aviao: 'airplane', 'avião': 'airplane', trem: 'locomotive', onibus: 'bus', 'ônibus': 'bus',
+    navio: 'ship', helicoptero: 'helicopter', 'helicóptero': 'helicopter', lapis: 'pencil', 'lápis': 'pencil', caneta: 'pen', mochila: 'backpack',
+    chapeu: 'top hat', 'chapéu': 'top hat', oculos: 'glasses', 'óculos': 'glasses', televisao: 'television', 'televisão': 'television', tv: 'television',
+    microfone: 'microphone', fone: 'headphone', 'guarda-chuva': 'umbrella', cogumelo: 'mushroom', semaforo: 'vertical traffic light',
+    'semáforo': 'vertical traffic light', ampulheta: 'hourglass', lua: 'crescent moon', nuvem: 'cloud', arco_iris: 'rainbow', 'arco-íris': 'rainbow',
+    flor: 'blossom', rosa: 'rose', girassol: 'sunflower', 'cacto': 'cactus', vulcao: 'volcano', 'vulcão': 'volcano', castelo: 'castle',
+    fantasma: 'ghost', alien: 'alien', 'alienígena': 'alien', et: 'alien', unicornio: 'unicorn', 'unicórnio': 'unicorn', dragao: 'dragon', 'dragão': 'dragon',
+    // Bichos que o kit/mundo.jsx não monta de blocos: vêm do ícone 3D (a lula fica de fora: é o presidente).
+    polvo: 'octopus', baleia: 'whale', caranguejo: 'crab', borboleta: 'butterfly', abelha: 'honeybee', cobra: 'snake', jacare: 'crocodile',
+    'jacaré': 'crocodile', crocodilo: 'crocodile', formiga: 'ant', aranha: 'spider', camelo: 'camel', zebra: 'zebra', hipopotamo: 'hippopotamus',
+    'hipopótamo': 'hippopotamus', rinoceronte: 'rhinoceros', canguru: 'kangaroo', coala: 'koala', preguica: 'sloth', 'preguiça': 'sloth',
+    joaninha: 'lady beetle', caracol: 'snail', minhoca: 'worm', morcego: 'bat', esquilo: 'chipmunk', rato: 'mouse', hamster: 'hamster',
+    lagosta: 'lobster', camarao: 'shrimp', 'camarão': 'shrimp', flamingo: 'flamingo', pavao: 'peacock', 'pavão': 'peacock', cisne: 'swan',
+    aguia: 'eagle', 'águia': 'eagle', peru: 'turkey', lhama: 'llama', gorila: 'gorilla', orangotango: 'orangutan', bufalo: 'water buffalo',
     engrenagem: 'gear', ciencia: 'test tube', 'ciência': 'test tube', saude: 'hospital', 'saúde': 'hospital', remedio: 'pill', 'remédio': 'pill',
 };
 
@@ -182,4 +203,16 @@ function cardapio() {
     };
 }
 
-module.exports = { procurarIcones3d, procurarAnimacoes, baixar, cardapio, termos, PT_EN };
+/** O ícone 3D que É a coisa (nota de palavra inteira), ou null: "pizza" acha, "joel" não. */
+function melhorIcone3d(termo, piso = 80) {
+    const ts = termos(termo);
+    if (!ts.length) return null;
+    let melhor = null;
+    for (const [nome, , kw = ''] of fluent()) {
+        const n = Math.max(nota(nome, ts), nota(kw, ts) * 0.8);
+        if (n >= piso && (!melhor || n > melhor.n || (n === melhor.n && nome.length < melhor.nome.length))) melhor = { nome, n };
+    }
+    return melhor ? 'fluent3d:' + melhor.nome : null;
+}
+
+module.exports = { melhorIcone3d, procurarIcones3d, procurarAnimacoes, baixar, cardapio, termos, PT_EN };