primocode 10.19.0 → 11.0.0

package/lib/kits.js

@@ -48,6 +48,7 @@ const crypto = require('crypto');
 const { spawn, spawnSync } = require('child_process');
 
 const RAIZ = path.join(__dirname, '..', 'kits');
+const MATERIAIS = require('./estudio/materiais.js');
 const ESTUDIO = path.join(RAIZ, 'estudio');
 const FAMILIAS = ['SaaS e tecnologia', 'Tipografia em movimento', 'Retrô', 'Feito à mão', '3D e abstrato', 'Redes sociais', 'Marca e evento'];
 const REGRAS = ['tipografia.md', 'cor.md', 'movimento.md', 'som.md', 'ritmo.md', 'area-segura.md'];
@@ -135,7 +136,7 @@ function achar(nome, op = {}) {
 
 // ── o menu pra IA ────────────────────────────────────────────────────────
 
-const linhaDoMenu = (k) => `- ${k.slug} · ${k.nome.split(' · ')[0]}${k.origem === 'seu' ? ' (seu)' : ''}: ${(k.quando.length ? k.quando.slice(0, 2) : [k.descricao]).join('; ').replace(/\s+/g, ' ').replace(/"/g, '')}`.slice(0, 92);
+const linhaDoMenu = (k) => `- ${k.slug} · ${k.nome.split(' · ')[0]}${k.origem === 'seu' ? ' (seu)' : ''}${MATERIAIS.migrado(k.slug) ? ' [peças soltas]' : ''}: ${(k.quando.length ? k.quando.slice(0, 2) : [k.descricao]).join('; ').replace(/\s+/g, ' ').replace(/"/g, '')}`.slice(0, 92);
 
 /** "estilo apple", "estilo papel recortado": a palavra depois de "estilo" que é o slug ou o nome de um kit. Só sugere. */
 function kitCitado(texto, todos) {
@@ -508,6 +509,7 @@ async function cmdMenu(op) {
 function cmdVer(slug, parte, qual, op) {
     const k = achar(slug, op);
     if (!k) return naoExiste(slug, op);
+    if (MATERIAIS.migrado(k.slug)) return { ok: true, texto: MATERIAIS.promptDoEstilo(k.slug) };
     return { ok: true, texto: ver(k, PARTES.includes(parte) ? parte : 'elementos', qual) };
 }
 
@@ -524,6 +526,7 @@ async function cmdPlano(a, op) {
     if (!a.kit) return { ok: false, texto: 'Falta --kit <slug>. Veja: primocode kit menu' };
     const k = achar(a.kit, op);
     if (!k) return naoExiste(a.kit, op);
+    if (MATERIAIS.migrado(k.slug)) return { ok: false, texto: `O estilo ${k.slug} é de peças soltas: não tem esqueleto nem plano pronto. Veja: primocode kit pecas ${k.slug}` };
     const nome = String(a.nome || '').trim();
     if (!nome) return { ok: false, texto: 'Falta --nome "<nome do vídeo>": vai no cartão que a pessoa confirma e no arquivo.' };
     const roteiro = lerTextoOuArquivo(a.roteiro, pasta).trim();
@@ -582,6 +585,7 @@ function cmdMontar(a, op) {
     if (!a.kit) return { ok: false, texto: 'Falta --kit <slug>. Veja: primocode kit menu' };
     const k = achar(a.kit, op);
     if (!k) return naoExiste(a.kit, op);
+    if (MATERIAIS.migrado(k.slug)) return { ok: false, texto: `O estilo ${k.slug} é de peças soltas: não tem esqueleto nem plano pronto. Veja: primocode kit pecas ${k.slug}` };
     const produto = String(a.produto || '').trim();
     if (!produto) return { ok: false, texto: 'Falta --produto "<o que o vídeo mostra: app de celular, curso online, garrafa térmica…>": é o que você vai montar em cena (nunca o produto da demo do kit).' };
     const arquivos = [...lista(a.arquivos), ...lista(a.logo), ...lista(a.fotos)];
@@ -938,6 +942,38 @@ function palavras(linha) {
     return out;
 }
 
+// ── peças soltas (lib/estudio/materiais.js): a IA lista, lê e escreve a cena do zero ──
+
+async function cmdPecas(a, op) {
+    const [estilo, sub, alvo] = a._;
+    if (!estilo) return { ok: true, texto: `Estilos com peças soltas: ${MATERIAIS.estilos().join(', ') || 'nenhum'}. Uso: primocode kit pecas <estilo> [ver <peça> | regras | escrever <nome> --arquivo <cena.tsx> | conferir <cena.tsx> | renderizar <nome>]` };
+    if (!MATERIAIS.migrado(estilo)) return { ok: false, texto: `O estilo "${estilo}" ainda não tem peças soltas (migrados: ${MATERIAIS.estilos().join(', ') || 'nenhum'}).` };
+    const pasta = op.projectDir || process.cwd();
+    const lerArq = (f) => fs.readFileSync(path.resolve(pasta, String(f)), 'utf8');
+    try {
+        switch (sub) {
+            case undefined: case 'listar': return MATERIAIS.listar(estilo);
+            case 'ver': return alvo ? MATERIAIS.lerPeca(estilo, alvo) : { ok: false, texto: 'Uso: primocode kit pecas <estilo> ver <peça>' };
+            case 'regras': return MATERIAIS.regras(estilo);
+            case 'escrever': return alvo && a.arquivo ? MATERIAIS.escreverCena(estilo, pasta, alvo, lerArq(a.arquivo)) : { ok: false, texto: 'Uso: primocode kit pecas <estilo> escrever <nome> --arquivo <cena.tsx>' };
+            case 'conferir': { const c = MATERIAIS.conferirCena(estilo, lerArq(alvo || a.arquivo)); return { ok: c.ok, texto: c.ok ? `ok ${JSON.stringify(c.medidas)}` : c.erros.join('\n') }; }
+            case 'renderizar': {
+                const arq = path.join(pasta, 'motion', `${alvo}.tsx`);
+                if (!alvo || !fs.existsSync(arq)) return { ok: false, texto: 'Grave a cena antes: … escrever <nome> --arquivo <cena.tsx>' };
+                const est = garantirEstudio({ home: op.home, aoFalar: op.aoFalar, env: op.env || process.env });
+                if (!est.ok) return { ok: false, texto: est.error };
+                const dir = path.join(pasta, 'motion', `.render-${alvo}`);
+                MATERIAIS.prepararRender(estilo, dir, arq, { duracao: a.quadros ? Number(a.quadros) : undefined });
+                ligarModulos(dir, est.modulos);
+                const saida = path.resolve(pasta, String(a.saida || path.join('motion', `${alvo}.mp4`)));
+                const r = await rodarRender(dir, saida, { escala: Number(a.escala) || 1, aoFalar: op.aoFalar || (() => {}) });
+                return r.ok ? { ok: true, texto: `Vídeo: ${r.video} (${r.segundos}s). Quadros pra conferir: ${(r.quadros || []).join(', ')}`, video: r.video } : { ok: false, texto: `O render falhou: ${r.error}` };
+            }
+            default: return { ok: false, texto: `Subcomando "${sub}" desconhecido. Use listar, ver, regras, escrever, conferir ou renderizar.` };
+        }
+    } catch (e) { return { ok: false, texto: `pecas: ${e.message}` }; }
+}
+
 function opcoes(args) {
     const a = { _: [] };
     for (let i = 0; i < args.length; i++) {
@@ -958,6 +994,8 @@ const AJUDA = `primocode kit — os kits de estilo de motion
                             o esqueleto do vídeo pela receita do kit (motion/plano.json) e o formulário da batida 1
   batida <n|geral> [--camadas '<json>' | --arquivo <json>]
                             sem JSON: o formulário da batida; com: confere, conserta e grava (devolve a próxima)
+  pecas <estilo> [ver <peça>|regras|escrever <nome> --arquivo <tsx>|conferir <tsx>|renderizar <nome>]
+                            estilos de peças soltas: a IA compõe a cena do zero (sem esqueleto pronto)
   plano --kit <slug> --nome "<nome>" --roteiro <md> [--plano <json>] [--fala "<texto>"] [--voz <voz>]
                             o cartão pra pessoa confirmar (roteiro + nome + estilo), com o plano montado
   fazer [--escala 0.5]      depois do sim: narração + render
@@ -975,6 +1013,7 @@ async function main(argv, op = {}) {
             case 'menu': return await cmdMenu(op);
             case 'ver': case 'skill': return a._[0] ? cmdVer(a._[0], a._[1], a._[2], op) : { ok: false, texto: 'Uso: primocode kit ver <slug>' };
             case 'referencia': case 'referencias': return await cmdReferencia(a, op);
+            case 'pecas': case 'materiais': return await cmdPecas(a, op);
             case 'montar': return cmdMontar(a, op);
             case 'batida': return cmdBatida(a, op);
             case 'plano': return await cmdPlano(a, op);
@@ -1040,6 +1079,6 @@ const continuaVideo = (texto) => pareceMotion(texto) || CONTINUA.test(semAcento(
 module.exports = {
     batidasFaltando, continuaVideo,
     RAIZ, FAMILIAS, casa, listar, achar, lerFrontmatter, menuParaIA, cabecaDoPedido, pareceMotion, ver, tiposDe,
-    validarPlano, checar, esticar, limparPlano, palavras, opcoes, entradaDoPlano, galeriaHtml, listaParaPessoa, previewPronto,
+    cmdPecas, validarPlano, checar, esticar, limparPlano, palavras, opcoes, entradaDoPlano, galeriaHtml, listaParaPessoa, previewPronto,
     novoTurno, turnoAtual, main, doShell, garantirEstudio, conferirQuadros,
 };

package/lib/nomes.js

@@ -81,6 +81,9 @@ const COMANDOS = {
     skills: { grupo: 'jeito', antigos: ['marketplace', 'market', 'install-skill', 'installskill'] },
     commands: { grupo: 'jeito', antigos: ['comandos'] },
     schedule: { grupo: 'jeito', antigos: ['agendar', 'agenda'] },
+    'testar-app': { grupo: 'rodar', antigos: [] },
+    pesquisar: { grupo: 'entender', antigos: [] },
+    placar: { grupo: 'entender', antigos: [] },
     secrets: { grupo: 'jeito', antigos: ['segredos'] },
     team: { grupo: 'jeito', antigos: ['time', 'equipe'] },
     // 8. Vídeo e marca
@@ -153,6 +156,9 @@ const QUANDO = {
     config: 'quer ver as preferências',
     keys: 'quer saber as teclas que ajudam',
     skills: 'quer ver ou ligar o que ele sabe fazer (`/skills store` abre a loja, `/skills add` instala)',
+    'testar-app': 'quer que o app web se teste sozinho: abre, clica nos fluxos principais e conserta o que der erro',
+    placar: 'quer ver qual modelo grátis acerta mais em cada tipo de tarefa (`/placar`; `/placar zerar` apaga)',
+    pesquisar: 'quer um relatório com fontes sobre um tema (`/pesquisar <tema>` grava em pesquisas/)',
     schedule: 'quer que um pedido rode sozinho num dia e hora (`/schedule "toda segunda às 9h" <pedido>`; sem nada, lista)',
     secrets: 'quer ver as chaves que o projeto usa ou guardar uma (`/secrets add NOME`)',
     commands: 'quer criar ou ver os comandos dele',

package/lib/placar.js

@@ -0,0 +1,173 @@
+/**
+ * placar.js — o PrimoCode aprende, por pessoa, qual modelo grátis acerta mais em cada tipo de tarefa.
+ *
+ * Tudo local (~/.primocode/placar.json): nada sai da máquina. Cada tarefa vira um TIPO (editar código,
+ * corrigir erro, app novo, design/CSS, pesquisa, escrita, vídeo/motion, documentos/slides). Cada
+ * desfecho vira um ponto pra (tipo, modelo): ganhou ou perdeu. O modelo é escolhido pela média
+ * Beta(1+ganhos, 1+perdas); só vale depois de MIN_AMOSTRAS; e em ~10% das vezes explora outro,
+ * pra o placar não travar no primeiro que acertou.
+ *
+ * Quem fixou modelo (/model) nunca é mexido. O servidor recebe a escolha como DICA (`preferido`)
+ * e só a honra se o modelo estiver na corrente do apelido; sem dica ou sem ele, nada muda.
+ *
+ * Sinais de ganho: testes passaram, diagnóstico limpo depois da edição, sem /undo logo depois,
+ * tarefa concluída. Perda: o contrário (teste falhando no fim, erro de diagnóstico sobrando,
+ * parou sem concluir, /undo).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TIPOS = {
+    'editar-codigo': 'editar código',
+    'corrigir-erro': 'corrigir erro',
+    'app-novo': 'app novo',
+    'design-css': 'design / CSS',
+    'pesquisa': 'pesquisa',
+    'escrita': 'escrita',
+    'video-motion': 'vídeo / motion',
+    'documentos': 'documentos / slides',
+};
+const MIN_AMOSTRAS = 5;
+const EXPLORACAO = 0.10;
+
+// Ordem importa: o mais específico primeiro.
+const REGRAS = [
+    ['video-motion', /\b(v[ií]deo|motion|anima[çc][ãa]o|animar|reel|legenda|edi[çc][ãa]o de v|lettering|trilha|cena)\b/i],
+    ['documentos', /\b(slides?|apresenta[çc][ãa]o|pptx|docx|pdf|planilha|xlsx|documento|proposta|relat[óo]rio em)\b/i],
+    ['corrigir-erro', /\b(bug|erro|quebr\w+|n[ãa]o funciona|falh\w+|corrig\w+|conserta\w*|consert\w+|crash|exception|stack ?trace|travando|n[ãa]o abre)\b/i],
+    ['design-css', /\b(css|design|layout|visual|cor(es)?|fonte|tipografia|responsiv\w+|espa[çc]amento|bonit\w+|tema|dark mode|tailwind|estilo)\b/i],
+    ['app-novo', /\b(cri(e|ar|a) (um|uma|o|a) (app|aplicativo|site|landing|p[áa]gina|jogo|sistema|api)|do zero|novo (app|projeto|site)|landing page|construa|construir)\b/i],
+    ['pesquisa', /\b(pesquis\w+|compar\w+|qual (a )?(melhor|diferen[çc]a)|o que [ée]|como funciona|explique|explica|investig\w+|estude|levantamento)\b/i],
+    ['escrita', /\b(escrev\w+|texto|post|e-?mail|copy|roteiro|artigo|resum\w+|traduz\w*|reescrev\w+|legenda de post)\b/i],
+];
+
+function classificar(texto) {
+    const t = String(texto || '').slice(0, 2000);
+    for (const [tipo, re] of REGRAS) if (re.test(t)) return tipo;
+    return 'editar-codigo';
+}
+
+const idCurto = (m) => String(m || '').replace(/^[a-z0-9]+:/i, '');   // tira o `gemini:`: o servidor conta o id limpo
+
+// ── a matemática ─────────────────────────────────────────────────────
+/** Média da Beta(1+ganhos, 1+perdas): começa em 50% e anda com os dados. */
+function pontuacao(ganhos, perdas) { return (1 + ganhos) / (2 + ganhos + perdas); }
+
+function amostras(c) { return (c && (c.ganhos || 0) + (c.perdas || 0)) || 0; }
+
+/**
+ * Escolhe o modelo do tipo entre os disponíveis. `rand` é injetável (teste).
+ * Volta { modelo, motivo } ou null (sem dica: o servidor decide como sempre).
+ */
+function escolher(dados, tipo, disponiveis, { rand = Math.random, minimo = MIN_AMOSTRAS, exploracao = EXPLORACAO } = {}) {
+    const lista = (disponiveis || []).filter(Boolean);
+    if (!lista.length) return null;
+    const celulas = (dados && dados.tipos && dados.tipos[tipo]) || {};
+    const conta = (m) => celulas[idCurto(m)] || { ganhos: 0, perdas: 0 };
+    const confiaveis = lista.filter((m) => amostras(conta(m)) >= minimo);
+    if (!confiaveis.length) return null;                       // ainda não sabe: não opina
+    if (lista.length > 1 && rand() < exploracao) {
+        const outros = lista.slice().sort((a, b) => amostras(conta(a)) - amostras(conta(b)));
+        const menos = amostras(conta(outros[0]));
+        const empatados = outros.filter((m) => amostras(conta(m)) === menos);
+        return { modelo: empatados[Math.floor(rand() * empatados.length) % empatados.length], motivo: 'explorando' };
+    }
+    let melhor = confiaveis[0];
+    for (const m of confiaveis) if (pontuacao(conta(m).ganhos, conta(m).perdas) > pontuacao(conta(melhor).ganhos, conta(melhor).perdas)) melhor = m;
+    return { modelo: melhor, motivo: 'lider' };
+}
+
+// ── o arquivo ────────────────────────────────────────────────────────
+const arquivo = (home) => path.join(home || process.env.PRIMOCODE_PLACAR_DIR || path.join(os.homedir(), '.primocode'), 'placar.json');   // PRIMOCODE_PLACAR_DIR: o teste não suja o placar de verdade
+
+function ler(home) {
+    try {
+        const j = JSON.parse(fs.readFileSync(arquivo(home), 'utf8'));
+        return j && typeof j === 'object' && j.tipos ? j : { v: 1, tipos: {} };
+    } catch { return { v: 1, tipos: {} }; }
+}
+
+function gravar(dados, home) {
+    try {
+        const f = arquivo(home);
+        fs.mkdirSync(path.dirname(f), { recursive: true });
+        fs.writeFileSync(f, JSON.stringify(dados, null, 2));
+        return true;
+    } catch { return false; }
+}
+
+let ultimo = null;   // o último desfecho gravado: o /undo logo depois vira perda
+
+function registrar(tipo, modelo, venceu, home) {
+    if (!TIPOS[tipo] || !modelo || typeof venceu !== 'boolean') return false;
+    const d = ler(home);
+    const m = idCurto(modelo);
+    const cel = ((d.tipos[tipo] = d.tipos[tipo] || {})[m] = d.tipos[tipo][m] || { ganhos: 0, perdas: 0 });
+    cel[venceu ? 'ganhos' : 'perdas']++;
+    ultimo = { tipo, modelo: m, venceu };
+    return gravar(d, home);
+}
+
+/** O /undo veio logo depois: o que contava como ganho vira perda. */
+function desfez(home) {
+    if (!ultimo || !ultimo.venceu) return false;
+    const d = ler(home);
+    const cel = d.tipos[ultimo.tipo] && d.tipos[ultimo.tipo][ultimo.modelo];
+    if (!cel || cel.ganhos < 1) return false;
+    cel.ganhos--; cel.perdas++;
+    ultimo = { ...ultimo, venceu: false };
+    return gravar(d, home);
+}
+
+function zerar(home) { ultimo = null; return gravar({ v: 1, tipos: {} }, home); }
+
+/** O desfecho de uma tarefa a partir dos sinais. true/false, ou null se não deu pra dizer. */
+function veredito(s = {}, concluiu) {
+    if (!s.modelo) return null;
+    if (s.testes === false || s.diagSujo || concluiu === false) return false;
+    if (s.testes === true || s.diagLimpo || concluiu === true) return true;
+    return null;
+}
+
+/** Fecha uma tarefa: grava o desfecho. Vem do runAct (lib/act.js). */
+function fechar(tipo, sinais, concluiu, home) {
+    const v = veredito(sinais, concluiu);
+    if (v === null) return null;
+    registrar(tipo, sinais.modelo, v, home);
+    return v;
+}
+
+// ── a tela do /placar ────────────────────────────────────────────────
+function tabela(dados) {
+    const linhas = [];
+    for (const [tipo, rotulo] of Object.entries(TIPOS)) {
+        const cel = (dados.tipos && dados.tipos[tipo]) || {};
+        for (const [modelo, c] of Object.entries(cel)) {
+            const n = amostras(c);
+            if (!n) continue;
+            const taxa = Math.round((c.ganhos / n) * 100);
+            linhas.push({ tipo: rotulo, modelo, taxa, n, firme: n >= MIN_AMOSTRAS });
+        }
+    }
+    return linhas.sort((a, b) => a.tipo.localeCompare(b.tipo) || b.taxa - a.taxa || b.n - a.n);
+}
+
+function texto(dados) {
+    const t = tabela(dados);
+    if (!t.length) return 'O placar ainda está vazio. Conforme você usa o PrimoCode, ele anota qual modelo grátis acertou mais em cada tipo de tarefa (só neste computador).';
+    const w = Math.max(...t.map((x) => x.modelo.length), 6);
+    const out = ['Qual modelo grátis acerta mais, por tipo de tarefa (só neste computador):', ''];
+    let atual = '';
+    for (const x of t) {
+        if (x.tipo !== atual) { atual = x.tipo; out.push(`  ${x.tipo}`); }
+        out.push(`    ${x.modelo.padEnd(w)}  acerta ${String(x.taxa).padStart(3)}%  em ${x.n} ${x.n === 1 ? 'tarefa' : 'tarefas'}${x.firme ? '' : '  (ainda pouco dado)'}`);
+    }
+    out.push('', `Ele só passa a escolher sozinho depois de ${MIN_AMOSTRAS} tarefas por modelo, e de vez em quando testa outro. /placar zerar apaga tudo.`);
+    return out.join('\n');
+}
+
+module.exports = { TIPOS, MIN_AMOSTRAS, EXPLORACAO, classificar, pontuacao, escolher, ler, gravar, registrar, desfez, zerar, veredito, fechar, tabela, texto, arquivo };

package/lib/plugin/autoteste.js

@@ -0,0 +1,99 @@
+/**
+ * autoteste.js — o app se testa sozinho (ideia do Replit Agent). Depois de construir um app web:
+ *   1. sobe o app (lib/plugin/preview.js)
+ *   2. abre no navegador (lib/browser.js, o mesmo do agente)
+ *   3. clica nos fluxos principais (botões, links internos, submit de formulário), anotando erros do console,
+ *      erros de página e prints
+ *   4. se falhou, devolve as falhas pro agente consertar — no máximo 2 rodadas
+ *
+ * `navegador` é injetável: { open(url), evaluate(js), clickSelector(sel), screenshot(path), wait(ms) } — o padrão é lib/browser.js.
+ * Sem Chrome/Playwright no computador o passo diz isso e não finge ter testado.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_RODADAS = 2;
+
+/** Injeta um coletor de erros na página (antes dos cliques). */
+const COLETOR = `(function(){ if (window.__primoErros) return 1; window.__primoErros = [];
+  window.addEventListener('error', function(e){ window.__primoErros.push('erro: ' + (e.message || e)); });
+  window.addEventListener('unhandledrejection', function(e){ window.__primoErros.push('promessa sem catch: ' + ((e.reason && e.reason.message) || e.reason)); });
+  var ce = console.error; console.error = function(){ window.__primoErros.push('console.error: ' + Array.prototype.slice.call(arguments).join(' ')); ce.apply(console, arguments); };
+  return 1; })()`;
+
+/** Os alvos clicáveis do fluxo principal (até `max`), como seletores estáveis. */
+const ALVOS = `(function(max){
+  var out = [], vistos = {};
+  function sel(el){ if (el.id) return '#' + CSS.escape(el.id);
+    var i = Array.prototype.indexOf.call(el.parentNode.children, el) + 1;
+    return (el.parentNode === document.body ? 'body' : sel(el.parentNode)) + ' > ' + el.tagName.toLowerCase() + ':nth-child(' + i + ')'; }
+  document.querySelectorAll('button, [role=button], input[type=submit], input[type=button], a[href]').forEach(function(el){
+    if (out.length >= max) return;
+    var r = el.getBoundingClientRect(); if (!r.width || !r.height || el.disabled) return;
+    if (el.tagName === 'A') { var h = el.getAttribute('href') || ''; if (!/^(#|\\/|\\.)/.test(h) || h === '#') return; }
+    var s = sel(el); if (vistos[s]) return; vistos[s] = 1;
+    out.push({ seletor: s, nome: (el.innerText || el.value || el.getAttribute('aria-label') || el.tagName).trim().slice(0, 40) });
+  });
+  return out; })`;
+
+/** Roda uma passada: devolve { ok, erros: [], prints: [], cliques: n }. */
+async function passada({ url, navegador, dir, max = 6, nome = 'r1' }) {
+    const erros = [], prints = [];
+    const pasta = path.join(dir, '.primocode', 'autoteste');
+    fs.mkdirSync(pasta, { recursive: true });
+    await navegador.open(url);
+    await navegador.evaluate(COLETOR);
+    const alvos = (await navegador.evaluate(`${ALVOS}(${max})`)) || [];
+    const tira = async (rotulo) => { try { const r = await navegador.screenshot(path.join(pasta, `${nome}-${rotulo}.png`)); prints.push(r.path); } catch { /* sem print */ } };
+    await tira('abertura');
+    let cliques = 0;
+    for (const a of alvos) {
+        try { await navegador.clickSelector(a.seletor); cliques++; await (navegador.wait ? navegador.wait(400) : null); }
+        catch (e) { erros.push(`não consegui clicar em "${a.nome}": ${String(e.message || e).split('\n')[0]}`); }
+        await navegador.evaluate(COLETOR);   // a página pode ter recarregado
+        const feitos = (await navegador.evaluate('(window.__primoErros || []).splice(0)').catch(() => [])) || [];
+        for (const f of feitos) erros.push(`ao clicar em "${a.nome}": ${f}`);
+        const atual = await navegador.evaluate('location.href').catch(() => url);
+        if (atual && !String(atual).startsWith(url.replace(/\/$/, ''))) { erros.push(`"${a.nome}" levou pra fora do app (${atual})`); await navegador.open(url); await navegador.evaluate(COLETOR); }
+    }
+    await tira('fim');
+    const finais = (await navegador.evaluate('(window.__primoErros || []).splice(0)').catch(() => [])) || [];
+    erros.push(...finais);
+    return { ok: !erros.length, erros: [...new Set(erros)], prints, cliques, alvos: alvos.length };
+}
+
+/**
+ * O laço completo. `consertar(falhas)` é chamado quando há erro (devolve uma Promise): é o agente corrigindo.
+ * Devolve { ok, rodadas, relatorio: [passada...], erro? }.
+ */
+async function testar({ dir, navegador, subir, consertar, rodadasMax = MAX_RODADAS, log = () => {} }) {
+    subir = subir || ((d) => require('./preview.js').subir(d));
+    if (!navegador) { try { navegador = require('../browser.js'); } catch (e) { return { ok: false, rodadas: 0, relatorio: [], erro: 'sem navegador: ' + e.message }; } }
+    const app = await subir(dir);
+    if (!app.ok) return { ok: false, rodadas: 0, relatorio: [], erro: `não consegui subir o app: ${app.erro}` };
+    log(`app no ar em ${app.url}`);
+    const relatorio = [];
+    try {
+        for (let r = 0; r <= rodadasMax; r++) {
+            let p;
+            try { p = await passada({ url: app.url, navegador, dir, nome: `r${r + 1}` }); }
+            catch (e) { return { ok: false, rodadas: r, relatorio, erro: `o navegador não abriu (${String(e.message || e).split('\n')[0]}) — não testei` }; }
+            relatorio.push(p);
+            log(p.ok ? `rodada ${r + 1}: ${p.cliques} cliques, sem erros` : `rodada ${r + 1}: ${p.erros.length} problema(s)`);
+            if (p.ok) return { ok: true, rodadas: r, relatorio };
+            if (r === rodadasMax || !consertar) break;
+            await consertar(p.erros, p.prints);       // até 2 consertos
+        }
+        return { ok: false, rodadas: Math.min(relatorio.length - 1, rodadasMax), relatorio, erro: 'ainda com erros depois dos consertos' };
+    } finally { try { app.parar(); } catch { /* */ } }
+}
+
+/** O pedido que volta pro agente com as falhas. */
+function pedidoDeConserto(erros, prints = []) {
+    return `Testei o app abrindo e clicando nos fluxos principais e deu problema:\n${erros.map((e) => '- ' + e).join('\n')}\n`
+        + (prints.length ? `Prints: ${prints.join(', ')}\n` : '') + 'Conserte a causa de cada um e não mude o resto.';
+}
+
+module.exports = { testar, passada, pedidoDeConserto, COLETOR, MAX_RODADAS };

package/lib/plugin/edicao-visual.js

@@ -0,0 +1,133 @@
+/**
+ * edicao-visual.js — editar clicando (ideia do Lovable/v0). No preview local, um overlay injetado deixa a pessoa
+ * apontar um elemento da página; o PrimoCode captura:
+ *   seletor CSS + outerHTML (cortado) + texto + palpite do arquivo-fonte
+ * pergunta "o que mudar?" (na própria página) e manda o pedido pro agente.
+ *
+ *   injetar(html)                      → html com o overlay antes de </body>
+ *   palpiteArquivo(dir, captura)       → [{ arquivo, pontos }]  (id, classes e texto procurados no código)
+ *   montarPedido(captura, mudanca, p)  → o texto que vai pro agente
+ *   tratar(dir, aoEditar)              → `extra(req,res)` pro servidor do preview: recebe o POST /__primo/editar
+ *   proxiar(alvo, porta, opcoes)       → servidor que repassa um dev server e injeta o overlay no HTML
+ *
+ * O palpite é só isso: um palpite (grep), dito como tal no pedido. O agente confere no arquivo.
+ */
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+const ROTA = '/__primo/editar';
+const MARCA = 'data-primo-overlay';
+
+const OVERLAY = `(function(){
+  if (window.__primoOverlay) return; window.__primoOverlay = 1;
+  var ligado = false, cx = document.createElement('div');
+  cx.setAttribute('${MARCA}', '1');
+  cx.style.cssText = 'position:fixed;pointer-events:none;border:2px solid #7c5cff;background:rgba(124,92,255,.12);z-index:2147483646;display:none;border-radius:3px';
+  var bt = document.createElement('button'); bt.setAttribute('${MARCA}', '1'); bt.textContent = '✎ Editar';
+  bt.style.cssText = 'position:fixed;right:16px;bottom:16px;z-index:2147483647;padding:10px 14px;border:0;border-radius:999px;background:#7c5cff;color:#fff;font:600 13px system-ui;cursor:pointer;box-shadow:0 4px 16px rgba(0,0,0,.3)';
+  document.body.appendChild(cx); document.body.appendChild(bt);
+  function ehNosso(el){ return el && el.closest && el.closest('[${MARCA}]'); }
+  function seletor(el){
+    if (el.id) return '#' + CSS.escape(el.id);
+    if (el === document.body) return 'body';
+    var i = Array.prototype.indexOf.call(el.parentNode.children, el) + 1;
+    return seletor(el.parentNode) + ' > ' + el.tagName.toLowerCase() + ':nth-child(' + i + ')';
+  }
+  bt.addEventListener('click', function(e){ e.stopPropagation(); ligado = !ligado; bt.textContent = ligado ? '✕ Sair da edição' : '✎ Editar'; cx.style.display = 'none'; document.body.style.cursor = ligado ? 'crosshair' : ''; });
+  document.addEventListener('mouseover', function(e){ if (!ligado || ehNosso(e.target)) return; var r = e.target.getBoundingClientRect();
+    cx.style.display = 'block'; cx.style.left = r.left + 'px'; cx.style.top = r.top + 'px'; cx.style.width = r.width + 'px'; cx.style.height = r.height + 'px'; }, true);
+  document.addEventListener('click', function(e){
+    if (!ligado || ehNosso(e.target)) return;
+    e.preventDefault(); e.stopPropagation();
+    var el = e.target, cap = { url: location.pathname, seletor: seletor(el), html: el.outerHTML.slice(0, 2000), texto: (el.innerText || '').trim().slice(0, 200), tag: el.tagName.toLowerCase(), id: el.id || '', classes: (el.getAttribute('class') || '') };
+    var mud = window.prompt('O que mudar neste elemento?\\n' + cap.seletor);
+    if (!mud) return;
+    cap.mudanca = mud;
+    fetch('${ROTA}', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(cap) })
+      .then(function(r){ return r.json(); }).then(function(j){ bt.textContent = j && j.ok ? '✓ Enviado ao PrimoCode' : '! Falhou'; setTimeout(function(){ bt.textContent = ligado ? '✕ Sair da edição' : '✎ Editar'; }, 2500); })
+      .catch(function(){ bt.textContent = '! Falhou'; });
+  }, true);
+})();`;
+
+function injetar(html) {
+    if (String(html).includes('__primoOverlay')) return html;
+    const tag = `<script ${MARCA}="1">${OVERLAY}</script>`;
+    return /<\/body>/i.test(html) ? html.replace(/<\/body>/i, () => tag + '</body>') : html + tag;
+}
+
+const PULA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.primocode', 'pesquisas']);
+const EXTS = new Set(['.html', '.htm', '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.css', '.scss', '.astro', '.md']);
+
+function* arquivos(dir, prof = 0) {
+    if (prof > 6) return;
+    let ents = []; try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+        if (PULA.has(e.name) || e.name.startsWith('.')) continue;
+        const p = path.join(dir, e.name);
+        if (e.isDirectory()) yield* arquivos(p, prof + 1);
+        else if (EXTS.has(path.extname(e.name).toLowerCase())) yield p;
+    }
+}
+
+/** Procura no código o id, as classes e o texto do elemento. Mais pontos = mais provável. */
+function palpiteArquivo(dir, cap, max = 3) {
+    const classes = String(cap.classes || '').split(/\s+/).filter((c) => c.length > 2);
+    const texto = String(cap.texto || '').split('\n')[0].trim().slice(0, 60);
+    const achados = [];
+    for (const p of arquivos(dir)) {
+        let s; try { const st = fs.statSync(p); if (st.size > 400 * 1024) continue; s = fs.readFileSync(p, 'utf8'); } catch { continue; }
+        let pontos = 0;
+        if (cap.id && (s.includes(`id="${cap.id}"`) || s.includes(`id='${cap.id}'`) || s.includes(`#${cap.id}`))) pontos += 4;
+        for (const c of classes) if (s.includes(c)) pontos += 1;
+        if (texto.length > 3 && s.includes(texto)) pontos += 3;
+        if (pontos) achados.push({ arquivo: path.relative(dir, p), pontos });
+    }
+    return achados.sort((a, b) => b.pontos - a.pontos).slice(0, max);
+}
+
+function montarPedido(cap, mudanca, palpites = []) {
+    return [`Edição visual: na página ${cap.url || '/'}, o usuário clicou num elemento e quer: ${mudanca}`, '',
+        `Seletor: ${cap.seletor}`, `Texto: ${cap.texto || '(sem texto)'}`, 'HTML do elemento:', '```html', cap.html || '', '```',
+        palpites.length ? `Palpite de arquivo (grep, confira): ${palpites.map((p) => p.arquivo).join(', ')}` : 'Não achei o arquivo-fonte por grep: procure pelo texto/classes.',
+        'Faça só essa mudança e não mexa no resto da página.'].join('\n');
+}
+
+/** Handler pro servidor do preview: true se tratou a requisição. `aoEditar(pedido, cap)` é quem manda pro agente. */
+function tratar(dir, aoEditar) {
+    return (req, res) => {
+        if (req.method !== 'POST' || !(req.url || '').startsWith(ROTA)) return false;
+        let corpo = ''; req.on('data', (b) => { corpo += b; if (corpo.length > 200000) req.destroy(); });
+        req.on('end', async () => {
+            let cap; try { cap = JSON.parse(corpo); } catch { res.writeHead(400); return res.end('{"ok":false}'); }
+            if (!cap || !cap.seletor || !cap.mudanca) { res.writeHead(400); return res.end('{"ok":false}'); }
+            const pedido = montarPedido(cap, String(cap.mudanca).slice(0, 500), palpiteArquivo(dir, cap));
+            try { await aoEditar(pedido, cap); res.writeHead(200, { 'content-type': 'application/json' }); res.end('{"ok":true}'); }
+            catch { res.writeHead(500); res.end('{"ok":false}'); }
+        });
+        return true;
+    };
+}
+
+/** Repassa um dev server (alvo = 'http://localhost:5173') injetando o overlay no HTML. */
+function proxiar(alvo, porta, { dir, aoEditar }) {
+    const u = new URL(alvo);
+    const meu = tratar(dir, aoEditar);
+    const srv = http.createServer((req, res) => {
+        if (meu(req, res)) return;
+        const headers = { ...req.headers, host: u.host, 'accept-encoding': 'identity' };
+        const pr = http.request({ host: u.hostname, port: u.port, path: req.url, method: req.method, headers }, (r) => {
+            const html = /text\/html/.test(r.headers['content-type'] || '');
+            if (!html) { res.writeHead(r.statusCode, r.headers); return r.pipe(res); }
+            let b = ''; r.setEncoding('utf8'); r.on('data', (x) => { b += x; });
+            r.on('end', () => { const h = { ...r.headers }; const corpo = injetar(b); delete h['content-length']; res.writeHead(r.statusCode, h); res.end(corpo); });
+        });
+        pr.on('error', () => { res.writeHead(502); res.end('o app não respondeu'); });
+        req.pipe(pr);
+    });
+    return new Promise((ok) => srv.listen(porta, '127.0.0.1', () => ok(srv)));
+}
+
+module.exports = { OVERLAY, ROTA, injetar, palpiteArquivo, montarPedido, tratar, proxiar };

package/lib/plugin/pesquisar.js

@@ -0,0 +1,92 @@
+/**
+ * pesquisar.js — `/pesquisar <tema>`: pesquisa profunda com fontes.
+ *   1. o modelo quebra o tema em 3-5 sub-perguntas (JSON)
+ *   2. cada uma passa por `buscar` (a ferramenta buscar_web, lib/tool/web.js;
+ *      aqui só a interface `buscar(consulta) -> [{titulo, url, trecho}]`. Sem ela, o relatório diz que não buscou)
+ *   3. as melhores URLs são lidas (lib/web-pagina.js)
+ *   4. o modelo escreve o relatório em markdown citando [1], [2]… e só as fontes lidas entram na lista
+ *   5. grava em pesquisas/<tema>.md
+ * Nada é inventado: sem fonte lida, a seção diz "sem fonte" em vez de afirmar.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { acharJson, perguntarPadrao, slug } = require('../cli/util.js');
+
+const MAX_PERGUNTAS = 5, URLS_POR_PERGUNTA = 2;
+
+async function buscarPadrao() {
+    const { buscarWeb } = require('../tool/web.js');   // a ferramenta buscar_web de verdade
+    return async (consulta) => {
+        const r = await buscarWeb({ consulta, limite: URLS_POR_PERGUNTA + 2 });
+        if (!r.ok) throw new Error(r.error || 'buscar_web não achou nada');
+        return r.resultados;
+    };
+}
+
+/** O plano: sub-perguntas. Se o modelo não devolver JSON, usa o próprio tema. */
+async function planejar(tema, perguntar) {
+    const bruto = await perguntar(null, 'Quebre o tema em 3 a 5 sub-perguntas de pesquisa, curtas e distintas. Devolva SÓ um JSON: {"perguntas":["..."]}.', `Tema: ${tema}`);
+    const j = acharJson(bruto);
+    const l = (j && (Array.isArray(j) ? j : j.perguntas)) || [];
+    const ps = l.filter((x) => typeof x === 'string' && x.trim()).map((x) => x.trim()).slice(0, MAX_PERGUNTAS);
+    return ps.length ? ps : [tema];
+}
+
+async function pesquisar({ tema, dir = process.cwd(), perguntar, buscar, ler, log = () => {}, agora = () => new Date() }) {
+    tema = String(tema || '').trim();
+    if (!tema) return { ok: false, erro: 'Faltou o tema. Exemplo: /pesquisar como funciona cache no edge' };
+    perguntar = perguntar || perguntarPadrao;
+    ler = ler || (async (url) => { const r = await require('../web-pagina.js').baixar(url); return r.ok ? { titulo: r.titulo, texto: r.texto } : null; });
+    const avisos = [];
+    try { buscar = buscar || await buscarPadrao(); } catch (e) { buscar = null; avisos.push(e.message); }
+
+    const perguntas = await planejar(tema, perguntar);
+    log(`${perguntas.length} sub-pergunta(s)`);
+    const fontes = [], porPergunta = [];
+    for (const p of perguntas) {
+        const achadas = [];
+        if (buscar) {
+            let rs = [];
+            try { rs = (await buscar(p)) || []; } catch (e) { avisos.push(`busca "${p}": ${e.message}`); }
+            for (const r of rs.slice(0, URLS_POR_PERGUNTA)) {
+                if (!r || !r.url) continue;
+                let f = fontes.find((x) => x.url === r.url);
+                if (!f) {
+                    let lido = null;
+                    try { lido = await ler(r.url); } catch { /* segue sem */ }
+                    if (!lido || !lido.texto) { avisos.push(`não consegui ler ${r.url}`); continue; }
+                    f = { n: fontes.length + 1, url: r.url, titulo: r.titulo || lido.titulo || r.url, texto: String(lido.texto).slice(0, 6000) };
+                    fontes.push(f);
+                }
+                achadas.push(f);
+            }
+        }
+        porPergunta.push({ pergunta: p, fontes: achadas });
+        log(`"${p}" → ${achadas.length} fonte(s) lida(s)`);
+    }
+
+    let corpo;
+    if (!fontes.length) {
+        corpo = perguntas.map((p) => `## ${p}\n\nSem fonte: não consegui buscar nem ler nada pra esta pergunta.\n`).join('\n');
+    } else {
+        const material = porPergunta.map((x) => `### ${x.pergunta}\n` + (x.fontes.length ? x.fontes.map((f) => `[${f.n}] ${f.titulo} (${f.url})\n${f.texto}`).join('\n\n') : '(sem fonte)')).join('\n\n');
+        corpo = await perguntar(null, 'Escreva um relatório em markdown (PT-BR), uma seção "## pergunta" por sub-pergunta. Use SÓ o material dado; cite cada afirmação com [n]. Pergunta sem fonte: escreva "Sem fonte." Não invente.', `Tema: ${tema}\n\n${material}`);
+    }
+    const md = [`# ${tema}`, '', `_Pesquisa de ${agora().toISOString().slice(0, 10)} · ${fontes.length} fonte(s) lida(s)_`, '',
+        ...(avisos.length ? ['> Avisos: ' + [...new Set(avisos)].join(' · '), ''] : []), String(corpo).trim(), '',
+        '## Fontes', '', ...(fontes.length ? fontes.map((f) => `${f.n}. [${f.titulo}](${f.url})`) : ['_nenhuma_']), ''].join('\n');
+    const arquivo = path.join(dir, 'pesquisas', slug(tema) + '.md');
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    fs.writeFileSync(arquivo, md);
+    return { ok: true, arquivo, fontes: fontes.length, avisos, perguntas };
+}
+
+async function main(args) {
+    const r = await pesquisar({ tema: args.filter((a) => !a.startsWith('-')).join(' '), log: (l) => console.log('  ' + l) });
+    console.log(r.ok ? `  Relatório: ${r.arquivo}${r.avisos.length ? '\n  Avisos: ' + r.avisos.join(' · ') : ''}` : '  ' + r.erro);
+    return r.ok ? 0 : 1;
+}
+
+module.exports = { pesquisar, planejar, main };