primocode 9.8.0-beta.5 → 9.8.0-beta.7

package/lib/pre-leitura.js

@@ -0,0 +1,118 @@
+/**
+ * pre-leitura.js — os arquivos que o agente ia ler, já lidos.
+ *
+ *   "Toda vez a IA lê as pastas novamente, só pra ler vão 30 chamadas de API."
+ *   (dono, 24/09/2026)
+ *
+ * O caro não é o disco — ler index.html leva 1ms. O caro é a IDA AO MODELO: o
+ * servidor grátis conta pedidos por dia, e cada "deixa eu ler o style.css"
+ * numa resposta própria é um pedido. Medido com um modelo de mentira que
+ * segue uma política fixa (lê o que ainda não viu, um arquivo por resposta,
+ * e confere o index.html antes de editar), num "muda a cor do botão" em
+ * projeto de 10 arquivos: 9 pedidos ao modelo antes, 2 depois. Com todos os
+ * arquivos grandes demais para entrar aqui, a ordem de juntar leituras e a
+ * releitura sem mudança (lib/act.js, RELEITURA) ainda levam de 9 para 4.
+ *
+ * O mapa do projeto já dava os NOMES. Isto põe o CONTEÚDO dos poucos arquivos
+ * que quase todo pedido de página lê — o citado no pedido primeiro, depois
+ * index.html, o css e o js principais, package.json, README — dentro de um
+ * orçamento. Pequeno pelo servidor grátis (o teto é de ~6 mil tokens por
+ * MINUTO, e isto vai em toda rodada); folgado com um provedor próprio.
+ *
+ * Fica de fora o que não se lê como texto ou não vale o espaço: binário,
+ * minificado, lockfile, arquivo grande, e o que já entra por outro caminho
+ * (memory.md, PRIMO.md/AGENTS.md/CLAUDE.md). Arquivo que não cabe inteiro no
+ * que sobrou do orçamento NÃO entra cortado: meio arquivo marcado como
+ * "conteúdo atual" faria o modelo editar às cegas a metade que não viu.
+ *
+ * Puro, menos a leitura do disco — o teste mede a escolha sem rede.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ORCAMENTO_SERVIDOR = 6 * 1024;
+const ORCAMENTO_LOCAL = 40 * 1024;
+const MAIOR_ARQUIVO = 20 * 1024;
+
+const TEXTO = /\.(html?|css|scss|m?jsx?|tsx?|vue|svelte|json|md|txt|py|toml|ya?ml)$/i;
+const LOCKFILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb',
+    'composer.lock', 'Cargo.lock', 'poetry.lock', 'Gemfile.lock']);
+// Já entram no contexto por outro caminho (buildMemoryContext / mencoes.js).
+const JA_ENTRAM = new Set(['memory.md', 'PRIMO.md', 'AGENTS.md', 'CLAUDE.md']);
+
+/** O orçamento de agora: folgado só com provedor próprio (/api). */
+function orcamento() {
+    try { return require('./local/provedor.js').atual() ? ORCAMENTO_LOCAL : ORCAMENTO_SERVIDOR; }
+    catch { return ORCAMENTO_SERVIDOR; }
+}
+
+/** Quanto o arquivo importa: menor é mais importante; null = não entra. */
+function prioridade(rel, pedido) {
+    const nome = path.basename(rel);
+    if (JA_ENTRAM.has(nome) || LOCKFILES.has(nome) || /\.min\./i.test(nome) || !TEXTO.test(nome)) return null;
+    const fundo = rel.split(/[\\/]/).length - 1;
+    const texto = String(pedido || '').toLowerCase();
+    // Citado no pedido ("muda o style.css") é o que ele vai ler com certeza.
+    if (texto && (texto.includes(rel.toLowerCase()) || texto.includes(nome.toLowerCase()))) return 0;
+    if (fundo > 1) return null;
+    if (/^index\.html?$/i.test(nome)) return 1 + fundo;
+    if (/\.(css|scss)$/i.test(nome)) return 3 + fundo;
+    if (/\.(m?jsx?|tsx?|vue|svelte)$/i.test(nome) && !/\.(test|spec|config)\./i.test(nome)) return 5 + fundo;
+    if (nome === 'package.json' && fundo === 0) return 7;
+    if (/^readme\.md$/i.test(nome) && fundo === 0) return 8;
+    return null;
+}
+
+/**
+ * Escolhe e lê. Devolve [{ rel, conteudo }] na ordem de importância.
+ * @param {string} dir        a pasta do projeto
+ * @param {string[]} arquivos caminhos relativos (o mesmo que o mapa listou)
+ * @param {string} pedido     o texto do pedido — o citado nele vem primeiro
+ * @param {number} limite     bytes no total
+ */
+function escolher(dir, arquivos, pedido, limite = orcamento()) {
+    const candidatos = (arquivos || [])
+        .map((rel) => ({ rel, p: prioridade(rel, pedido) }))
+        .filter((x) => x.p !== null)
+        .sort((a, b) => a.p - b.p || a.rel.localeCompare(b.rel));
+    const lidos = [];
+    let soma = 0;
+    for (const { rel } of candidatos) {
+        const abs = path.join(dir, rel);
+        let st;
+        try { st = fs.statSync(abs); } catch { continue; }
+        if (!st.isFile() || st.size === 0 || st.size > MAIOR_ARQUIVO || soma + st.size > limite) continue;
+        let buf;
+        try { buf = fs.readFileSync(abs); } catch { continue; }
+        if (buf.includes(0)) continue;   // binário com nome de texto
+        const conteudo = buf.toString('utf-8');
+        // Uma linha de milhares de caracteres é minificado sem ".min" no nome.
+        if (conteudo.split('\n').some((l) => l.length > 2000)) continue;
+        lidos.push({ rel, conteudo });
+        soma += st.size;
+    }
+    return lidos;
+}
+
+/** O bloco que vai no contexto, ou '' quando não há nada que valha. */
+function bloco(lidos) {
+    if (!lidos || !lidos.length) return '';
+    const partes = lidos.map(({ rel, conteudo }) =>
+        `[conteúdo atual de ${rel} — não precisa ler de novo]\n${conteudo.replace(/\s+$/, '')}\n[fim de ${rel}]`);
+    return 'Estes arquivos estão aqui como estavam no COMEÇO deste pedido — use o que está abaixo em vez de '
+        + 'chamar read_file neles. Depois que você editar um deles, o texto abaixo fica velho: aí, sim, leia.\n\n'
+        + partes.join('\n\n');
+}
+
+/* A ordem de juntar. Vai junto do mapa porque é ali que o modelo decide o que
+   ler. Cada resposta dele é uma ida ao servidor; cinco leituras em cinco
+   respostas custam cinco pedidos, e as mesmas cinco numa resposta só custam
+   um. */
+const JUNTAR_LEITURAS = 'Precisa ler, listar ou buscar mais de uma coisa? Peça TUDO na MESMA resposta, '
+    + 'com várias chamadas de ferramenta juntas — nunca uma leitura por resposta. Cada resposta sua é '
+    + 'uma ida ao servidor, e o plano conta idas.';
+
+module.exports = { escolher, bloco, prioridade, orcamento, JUNTAR_LEITURAS,
+    ORCAMENTO_SERVIDOR, ORCAMENTO_LOCAL, MAIOR_ARQUIVO };

package/lib/repeticao.js

@@ -173,9 +173,11 @@ function ver(registro, nome, args) {
     }
 
     registro.vistos.set(chave, vezes);
-    if (vezes === 1) return { repetida: false, vezes, aviso: null };
+    // `chave` volta para quem chamou guardar o resultado da leitura pela
+    // mesma época em que ela foi vista (lib/act.js, RELEITURA).
+    if (vezes === 1) return { repetida: false, vezes, aviso: null, chave };
 
-    return { repetida: true, vezes, aviso: aviso(nome, vezes, parecidaCom) };
+    return { repetida: true, vezes, aviso: aviso(nome, vezes, parecidaCom), chave };
 }
 
 /** O recado, apertando a cada volta. */

package/lib/skills.js

@@ -345,9 +345,14 @@ const semAcento = (v) => String(v || '').toLowerCase()
 function pontuar(skill, texto) {
     const t = semAcento(texto);
     let pontos = 0;
+    // "página, pagina" no gatilho é UMA palavra escrita de dois jeitos: sem
+    // acento as duas são iguais e contavam dois pontos, e a skill que listava
+    // as duas grafias ganhava das outras só por isso.
+    const vistas = new Set();
     for (const palavra of skill.quando) {
         const p = semAcento(palavra).trim();
-        if (!p) continue;
+        if (!p || vistas.has(p)) continue;
+        vistas.add(p);
         const escapado = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         // A borda e escrita a mao em vez de `\b`: o gatilho pode comecar ou
         // terminar em simbolo ("e-mail"), e ali o `\b` nao vale.

package/lib/tempos.js

@@ -0,0 +1,62 @@
+/**
+ * tempos.js — para onde foi o tempo de um pedido.
+ *
+ *   PRIMOCODE_TEMPOS=1 primo
+ *
+ * No fim de cada pedido sai UMA linha com o que custou cada fase: o plano, a
+ * espera do resumo, o nome da pasta, cada rodada do modelo, as ferramentas e
+ * a conferência da página. Existe porque "está lento" sem número vira chute:
+ * medido em 24/09 com um servidor de mentira que responde na hora, o que o
+ * PrimoCode gastava sozinho num pedido de página era quase todo a conferência
+ * no navegador escondido (2,1 a 4,6s num Chrome recém-aberto), e não o que
+ * parecia: as ferramentas de três rodadas somaram 7 a 23ms, e o planejador
+ * nem é chamado em pedido de uma fase só.
+ *
+ * Desligado, não custa nada: `medir` chama a função e devolve, sem relógio.
+ *
+ * Um pedido por vez (é assim que o CLI trabalha), então o registro é do
+ * módulo. Subagente soma no mesmo pedido, com o nome da fase.
+ */
+'use strict';
+
+let atual = null;
+
+function ligado() { return process.env.PRIMOCODE_TEMPOS === '1'; }
+
+/** Começa o registro de um pedido. Desligado, não faz nada. */
+function comecar() {
+    atual = ligado() ? { inicio: Date.now(), fases: new Map() } : null;
+    return atual;
+}
+
+/** Soma `ms` à fase `nome` (várias rodadas somam na mesma linha, com contagem). */
+function somar(nome, ms) {
+    if (!atual) return;
+    const f = atual.fases.get(nome) || { ms: 0, vezes: 0 };
+    f.ms += ms;
+    f.vezes++;
+    atual.fases.set(nome, f);
+}
+
+/** Mede uma função (síncrona ou async) e soma o tempo à fase. */
+async function medir(nome, fn) {
+    if (!atual) return fn();
+    const t = Date.now();
+    try { return await fn(); } finally { somar(nome, Date.now() - t); }
+}
+
+function fmt(ms) { return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`; }
+
+/** A linha do fim. Encerra o registro. null se estava desligado. */
+function relatorio() {
+    if (!atual) return null;
+    const total = Date.now() - atual.inicio;
+    const partes = [...atual.fases].map(([nome, f]) =>
+        `${nome} ${fmt(f.ms)}${f.vezes > 1 ? ` (${f.vezes}x)` : ''}`);
+    atual = null;
+    return `tempos · ${partes.join(' · ')}${partes.length ? ' · ' : ''}total ${fmt(total)}`;
+}
+
+function ativo() { return !!atual; }
+
+module.exports = { ligado, comecar, somar, medir, relatorio, ativo };

package/lib/ui.js

@@ -60,9 +60,19 @@ const c = {
 // Só glifos de bloco (U+2580–U+259F): largura 1 garantida em qualquer terminal
 // monospace, sem emoji e sem depender de fonte instalada.
 //
-// A família compartilha corpo e pés — o que muda é a linha de cima. É de
-// propósito: são o mesmo bicho de orelhas diferentes, não três desenhos de
-// autores diferentes. Troque com /mascot.
+// Primo, raposa e gato compartilham corpo e pés — são o mesmo bicho de
+// orelhas diferentes. Os que chegaram depois ("mais mascotes", pedido do
+// dono) têm silhueta própria: um robô de corpo de gato não seria um robô.
+//
+// As cores saem SÓ do PALETTE. `full` pinta o bloco cheio, `edge` o contorno;
+// a `mascara` (opcional, uma letra por coluna) marca o que foge da regra —
+// olho (`o`), acento (`a`), corpo (`c`), borda (`b`). É por ela que o olho do
+// robô acende na primária e a barriga do pinguim fica clara, sem inventar cor.
+//
+// Cada um tem nome, bordão (aparece na saudação) e um rostinho por humor, que
+// sai numa linha discreta depois da resposta do agente (/mascot reacoes off
+// desliga). Rosto em ASCII/Unicode de largura 1 — emoji ocupa duas colunas e
+// muda de desenho de um terminal para outro.
 
 const ART_W = 9;    // colunas de cada linha do desenho
 const ART_H = 3;    // linhas — igual ao número de linhas de identidade
@@ -72,28 +82,168 @@ const PES   = '  ▘▘ ▝▝  ';
 
 const MASCOTS = {
     // Padrão: o Primo — cabeça cheia, ombros marcados, dois pezinhos.
-    primo: { topo: ' ▐▛███▜▌ ', full: 'brand',  edge: 'brandDim' },
+    primo: {
+        nome: 'Primo', frase: 'Bora construir junto?',
+        linhas: [' ▐▛███▜▌ ', CORPO, PES], full: 'brand', edge: 'brandDim',
+        rosto: { feliz: '(^‿^)', preocupado: '(°_°)', parado: '(-_-)' },
+    },
     // Raposa — orelhas largas, abertas para fora. Na secundária do sistema.
-    fox:   { topo: ' ▛▀   ▀▜ ', full: 'warn',   edge: 'dim' },
+    fox: {
+        nome: 'Raposa', frase: 'Esperta e rápida no código.',
+        linhas: [' ▛▀   ▀▜ ', CORPO, PES], full: 'warn', edge: 'dim',
+        rosto: { feliz: '(^ᴥ^)', preocupado: '(•ᴥ•;)', parado: '(-ᴥ-)' },
+    },
     // Gato — orelhas curtas e juntas. Primária recuada, para não repetir o Primo.
-    cat:   { topo: ' ▛▘   ▝▜ ', full: 'brandDim', edge: 'dim' },
+    cat: {
+        nome: 'Gato', frase: 'Curioso até achar o bug.',
+        linhas: [' ▛▘   ▝▜ ', CORPO, PES], full: 'brandDim', edge: 'dim',
+        rosto: { feliz: '(=^.^=)', preocupado: '(=°.°=)', parado: '(=-.-=)' },
+    },
+    // Robô — antena, cabeça quadrada e os dois olhos acesos na primária.
+    // Corpo em slate: é metal, e metal é neutro.
+    robo: {
+        nome: 'Bip', frase: 'Bip-bop: pedido entendido.',
+        linhas: [' ▗▄▄█▄▄▖ ', ' ▐█████▌ ', '  █▀▀▀█  '],
+        mascara: ['  ccccc  ', '   o o   ', '         '],
+        full: 'muted', edge: 'dim', olho: 'brand',
+        rosto: { feliz: '[^_^]', preocupado: '[o_O]', parado: '[-_-]' },
+    },
+    // Coruja — os tufos em cima e dois olhões claros. Na secundária: é a
+    // cor do "aviso que não é falha", e a coruja é a que pensa antes.
+    coruja: {
+        nome: 'Sábia', frase: 'Pensa antes, erra menos.',
+        linhas: [' █▄▄▄▄▄█ ', ' ███▄███ ', ' ▝█▀▀▀█▘ '],
+        mascara: [' ccccccc ', '  oo oo  ', '         '],
+        full: 'warn', edge: 'dim', olho: 'white',
+        rosto: { feliz: '(O,O)', preocupado: '(o,O)', parado: '(-,-)' },
+    },
+    // Dragão — chifres para fora, asinhas nos lados e o rabo à direita.
+    // Chifres na secundária, corpo na primária.
+    dragao: {
+        nome: 'Faísca', frase: 'Bota fogo no projeto!',
+        linhas: ['▝▙▗▄▄▄▖▟▘', '▗▟█████▙▖', ' ▝█▀▀▀█▙▖'],
+        mascara: ['aa     aa', 'a  o o  a', '         '],
+        full: 'brand', edge: 'brandDim', olho: 'white', acento: 'warn',
+        rosto: { feliz: '<^w^>', preocupado: '<°w°;>', parado: '<-w->' },
+    },
+    // Fantasma — cúpula, dois olhos vazados e a barra ondulada embaixo.
+    fantasma: {
+        nome: 'Boo', frase: 'Some com os bugs sem fazer barulho.',
+        linhas: [' ▗▟███▙▖ ', ' ██▄█▄██ ', ' ▛▚▟▀▙▞▜ '],
+        mascara: ['         ', '   c c   ', '         '],
+        full: 'white', edge: 'muted',
+        rosto: { feliz: '(^o^)~', preocupado: '(°o°)~', parado: '(-o-)~' },
+    },
+    // Capivara — de perfil: orelhinha, focinho reto, corpo comprido e as
+    // perninhas curtas. A brasileira da turma, na secundária (o mais perto do
+    // marrom que a paleta tem).
+    capivara: {
+        nome: 'Capi', frase: 'Na calma, tudo sai.',
+        linhas: ['  ▗▖     ', '▗█▀█▄▄▄▄▖', '▝▀█▀▀▀█▀ '],
+        mascara: ['  bb     ', '  o cccc', '         '],
+        full: 'warn', edge: 'dim', olho: 'dim',
+        rosto: { feliz: '(•ᴗ•)', preocupado: '(•_•;)', parado: '(-ᴗ-)' },
+    },
+    // Polvo — cabeça redonda, olhos vazados e os braços abertos embaixo.
+    polvo: {
+        nome: 'Polvinho', frase: 'Oito braços, várias tarefas.',
+        linhas: ['  ▟███▙  ', ' ▐█▄█▄█▌ ', '▗▛▐▘█▝▌▜▖'],
+        full: 'brandDim', edge: 'brandDim',
+        rosto: { feliz: '~(^u^)~', preocupado: '~(°u°)~', parado: '~(-u-)~' },
+    },
+    // Pinguim — cabeça escura, bico na secundária, barriga clara e os pés.
+    pinguim: {
+        nome: 'Gelinho', frase: 'Cabeça fria, código limpo.',
+        linhas: ['  ▟▀█▀▙  ', ' ▟█████▙ ', ' ▝▀▘ ▝▀▘ '],
+        mascara: ['    a    ', '   ooo   ', ' aaa aaa '],
+        full: 'dim', edge: 'dim', olho: 'white', acento: 'warn',
+        rosto: { feliz: '<(^v^)>', preocupado: '<(°v°)>', parado: '<(-v-)>' },
+    },
+};
+
+// A ordem da galeria e dos números do /mascot. Os três de sempre primeiro:
+// quem escolheu o gato ontem acha ele no mesmo lugar hoje.
+const MASCOTES = Object.keys(MASCOTS);
+
+// Quem digita em português escreve "raposa", "robô", "dragão".
+const APELIDOS_MASCOTE = {
+    raposa: 'fox', gato: 'cat', robô: 'robo', robot: 'robo', dragão: 'dragao', dragon: 'dragao',
+    owl: 'coruja', ghost: 'fantasma', capybara: 'capivara', capi: 'capivara', octopus: 'polvo',
+    penguin: 'pinguim', bip: 'robo', boo: 'fantasma', sabia: 'coruja', sábia: 'coruja',
+    faisca: 'dragao', faísca: 'dragao', polvinho: 'polvo', gelinho: 'pinguim',
 };
 
+/** Nome, apelido ou número (1-based) → id do mascote. null se não existe. */
+function resolverMascote(pedido) {
+    const t = String(pedido == null ? '' : pedido).trim().toLowerCase();
+    if (!t) return null;
+    if (/^\d+$/.test(t)) return MASCOTES[Number(t) - 1] || null;
+    if (MASCOTS[t]) return t;
+    return APELIDOS_MASCOTE[t] || null;
+}
+
+function mascoteInfo(style) {
+    const id = MASCOTS[style] ? style : 'primo';
+    const m = MASCOTS[id];
+    return { id, nome: m.nome, frase: m.frase, rosto: { ...m.rosto } };
+}
+
 // Bloco cheio na cor viva, contorno na apagada: dá volume ao desenho sem
-// precisar de gradiente nem de cor de fundo.
-function shade(line, full, edge) {
+// precisar de gradiente nem de cor de fundo. A máscara ganha da regra.
+const PAPEL = { c: 'full', b: 'edge', o: 'olho', a: 'acento' };
+function shade(line, m, mascara) {
     let out = '';
-    for (const ch of line) {
-        if (ch === ' ') out += ch;
-        else if (ch === '█' || ch === '▀') out += c[full](ch);
-        else out += c[edge](ch);
-    }
+    const letras = [...(mascara || '')];
+    [...line].forEach((ch, i) => {
+        if (ch === ' ') { out += ch; return; }
+        const papel = PAPEL[letras[i]];
+        const cor = (papel && m[papel]) || ((ch === '█' || ch === '▀') ? m.full : m.edge);
+        out += c[cor](ch);
+    });
     return out;
 }
 
 function mascot(style) {
     const m = MASCOTS[style] || MASCOTS.primo;
-    return [m.topo, CORPO, PES].map((l) => shade(l, m.full, m.edge));
+    return m.linhas.map((l, i) => shade(l, m, m.mascara && m.mascara[i]));
+}
+
+/**
+ * A galeria do /mascot: todos lado a lado, com o número e o nome em cima.
+ * Célula de 13 colunas ("● 10 pinguim" + folga); quantas cabem por fileira
+ * sai da largura do terminal, então 80 colunas dá seis por fileira.
+ */
+function galeriaMascotes(atual, colunas) {
+    const CEL = 13;
+    const cols = Math.max(CEL + 2, Math.min(colunas || process.stdout.columns || 80, 120));
+    const porFileira = Math.max(1, Math.floor((cols - 2) / CEL));
+    const out = [];
+    for (let i = 0; i < MASCOTES.length; i += porFileira) {
+        const grupo = MASCOTES.slice(i, i + porFileira);
+        const rotulo = grupo.map((id, j) => {
+            const txt = `${i + j + 1} ${id}`;
+            return id === atual ? padRight(c.brand('● ' + txt), CEL) : padRight(c.muted('  ' + txt), CEL);
+        }).join('');
+        out.push('  ' + rotulo.replace(/\s+$/, ''));
+        for (let l = 0; l < ART_H; l++) {
+            out.push(('  ' + grupo.map((id) => '  ' + mascot(id)[l] + '  ').join('')).replace(/\s+$/, ''));
+        }
+        out.push('');
+    }
+    return out.join('\n');
+}
+
+/* A reação depois da resposta do agente: o rostinho e uma palavra. Uma linha,
+   cor apagada — é tempero, não aviso. O humor sai do que aconteceu:
+   terminou (feliz), parou sem concluir (preocupado), a pessoa mandou parar
+   (parado). Cor segue função: primária para o que deu certo, secundária para
+   o que pede atenção. */
+const DITO = { feliz: 'pronto!', preocupado: 'não terminei tudo, dá uma olhada', parado: 'parei aqui' };
+function reacao(style, humor) {
+    const m = MASCOTS[style] || MASCOTS.primo;
+    const h = m.rosto[humor] ? humor : 'feliz';
+    const cor = h === 'feliz' ? 'brand' : h === 'preocupado' ? 'warn' : 'muted';
+    return `  ${c[cor](m.rosto[h])} ${c.dim(m.nome + ': ' + DITO[h])}`;
 }
 
 // ── Medição de largura ───────────────────────────────────────────────────
@@ -177,9 +327,13 @@ function welcomeBox(version, contexto, opts = {}) {
     const art = mascot(style);
     const cols = Math.max(32, Math.min(process.stdout.columns || 100, 120));
 
-    const saudacao = userName
+    // O bordão do mascote vem na mesma linha da saudação: é ele quem cumprimenta.
+    // Em terminal estreito o truncate corta o bordão antes do nome.
+    const info = mascoteInfo(style);
+    const saudacao = (userName
         ? `${c.muted('Bem-vindo de volta, ')}${c.bold(c.white(userName))}`
-        : c.muted('Bem-vindo de volta');
+        : c.muted('Bem-vindo de volta'))
+        + c.dim(`  · ${info.nome}: "${info.frase}"`);
 
     // As três linhas de identidade — uma por linha do mascote, na ordem em que
     // se lê: quem é, quem chegou, onde estamos.
@@ -455,4 +609,4 @@ function friendlyError(raw) {
 }
 
 
-module.exports = { c, mascot, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+module.exports = { c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.5",
+  "version": "9.8.0-beta.7",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/ide.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/skills/apresentacao-pptx/SKILL.md

@@ -0,0 +1,52 @@
+---
+nome: Apresentação PowerPoint
+descricao: gerar um .pptx editável (PowerPoint, Keynote, Google Slides) com python-pptx, e conferir slide por slide
+quando: pptx, powerpoint, power point, keynote, google slides, apresentação editável, slides editáveis
+autor: PrimoCode
+---
+Primeiro a pergunta certa: a pessoa precisa EDITAR depois, ou só apresentar?
+Só apresentar → o Estúdio faz slides com mais liberdade visual e entrega em PDF
+(`estudio_projeto` formato "slides"). Precisa abrir no PowerPoint, no Keynote ou
+no Google Slides e mexer → .pptx, com `python-pptx`.
+
+**1. Prepare.** `python3 -m venv .venv && .venv/bin/pip install python-pptx`, e um
+script (`gerar_slides.py`) que dá para rodar de novo a cada ajuste.
+
+**2. Tamanho 16:9 e layout em branco.** O padrão da biblioteca é 4:3.
+```python
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+prs = Presentation()
+prs.slide_width, prs.slide_height = Inches(13.333), Inches(7.5)
+s = prs.slides.add_slide(prs.slide_layouts[6])        # 6 = em branco
+caixa = s.shapes.add_textbox(Inches(0.8), Inches(0.8), Inches(11.7), Inches(1.5))
+p = caixa.text_frame.paragraphs[0]
+p.text = 'O custo dobrou em seis meses'
+p.font.size, p.font.bold = Pt(44), True
+p.font.color.rgb = RGBColor(0x1A, 0x23, 0x32)
+s.notes_slide.notes_text_frame.text = 'O que falar neste slide.'
+prs.save('apresentacao.pptx')
+```
+
+**3. Regras que evitam o slide quebrado**
+- O `python-pptx` NÃO encolhe texto que não cabe: ele vaza da caixa. Escreva
+  curto, uma ideia por slide, e dê à caixa a altura do texto.
+- Corpo com pelo menos 24pt; título entre 36 e 54pt.
+- Fonte que a outra máquina tem (Arial, Calibri, Georgia, Helvetica). O .pptx
+  não leva a fonte junto: a que falta é trocada e o texto muda de tamanho.
+- Margem de 0,6 polegada em volta, e a mesma posição de título em todo slide.
+- Imagem com `s.shapes.add_picture('foto.jpg', x, y, width=...)`: dê só a
+  largura, para ela não esticar.
+- O que a pessoa vai FALAR vai nas notas, não no slide.
+
+O conteúdo segue as regras da skill de slides: título que afirma, uma ideia por
+slide, dado com fonte.
+
+**4. Confira antes de entregar.**
+- Reabra com `Presentation('apresentacao.pptx')` e imprima o número de slides e
+  o título de cada um.
+- Com LibreOffice: `soffice --headless --convert-to pdf apresentacao.pptx`,
+  abra o PDF e OLHE cada página. Texto vazando da caixa, imagem cortada e slide
+  vazio só aparecem assim.
+- Diga à pessoa que o Google Slides abre o .pptx por Arquivo → Importar.