primocode 10.19.0 → 11.1.0

package/lib/permission/sandbox.js

@@ -0,0 +1,252 @@
+/**
+ * sandbox.js — a cerca em volta do run_shell.
+ *
+ * Decisão do Joel (08/10, JOEL-FEAT-002): isolamento NATIVO, leve, sem VM.
+ *   macOS  → sandbox-exec (Seatbelt) com um perfil gerado na hora
+ *   Linux  → bubblewrap (bwrap), se existir
+ *   Windows/sem mecanismo → best_effort (avisa uma vez e segue) ou
+ *                           hard_requirement (recusa)
+ *
+ * O que o comando pode: escrever na pasta do projeto, em /tmp e em
+ * ~/.primocode/cache; ler quase tudo, MENOS os arquivos de credencial da
+ * LEITURA_NEGADA_HOME (chaves, tokens, a conta do PrimoCode, o Keychain) e
+ * .env*. Rede ligada (o `npm install` precisa), com opção de cortar.
+ * No macOS ainda fica de fora: osascript, o comando `security` (Keychain) e
+ * escrever hook em .git/hooks (rodaria FORA da cerca no próximo commit).
+ * O ssh-agent da pessoa fica fora por padrão (review do Arthur, #162): sem
+ * ele, "não lê ~/.ssh" vale de verdade, e não só para o arquivo.
+ * Quando bloqueia, a mensagem diz POR QUE, para o modelo aprender.
+ *
+ * Config em ~/.primocode/config.json:
+ *   "sandbox": { "ligado": true, "modo": "best_effort"|"hard_requirement",
+ *                "rede": true, "ssh_agent": false, "env_permitidas": ["MINHA_KEY"],
+ *                "escrita_extra": ["~/.npm"] }
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile, spawnSync } = require('child_process');
+
+const MODOS = ['best_effort', 'hard_requirement'];
+const LEITURA_NEGADA_HOME = ['.ssh', '.aws', '.config/gcloud', '.npmrc',
+    '.primocode/conta.json', '.netrc', '.git-credentials', '.config/gh', '.docker', '.kube', 'Library/Keychains',
+    '.config/git/credentials', '.pypirc', '.gnupg', '.cargo/credentials', '.cargo/credentials.toml'];
+// Socket do ssh-agent do macOS (launchd). O caminho exato vem do SSH_AUTH_SOCK; a regex pega os outros.
+const SOCKET_SSH_MAC = '^/private/(tmp|var/run)/com\\.apple\\.launchd\\.[^/]+/Listeners$';
+const SECRETA = /(_KEY|_TOKEN|SECRET)/i;
+
+let _avisou = false;
+let _avisouDesligado = false;
+let _forcaMecanismo; // teste: undefined = detectar; null = ausente; 'seatbelt'|'bwrap'
+
+function arquivoConfig(home) { return path.join(home || os.homedir(), '.primocode', 'config.json'); }
+
+function lerConfig(home) {
+    try { return JSON.parse(fs.readFileSync(arquivoConfig(home), 'utf8')) || {}; } catch { return {}; }
+}
+
+function config(home) {
+    const s = lerConfig(home).sandbox || {};
+    return {
+        ligado: typeof s.ligado === 'boolean' ? s.ligado : process.platform === 'darwin',
+        modo: MODOS.includes(s.modo) ? s.modo : 'best_effort',
+        rede: s.rede !== false,
+        ssh_agent: s.ssh_agent === true,
+        env_permitidas: Array.isArray(s.env_permitidas) ? s.env_permitidas.map(String) : [],
+        escrita_extra: Array.isArray(s.escrita_extra) ? s.escrita_extra.map(String) : [],
+    };
+}
+
+function salvar(parcial, home) {
+    const arq = arquivoConfig(home);
+    const atual = lerConfig(home);
+    atual.sandbox = { ...(atual.sandbox || {}), ...parcial };
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, JSON.stringify(atual, null, 2));
+    return config(home);
+}
+
+function temBinario(nome) {
+    try { return spawnSync(nome, ['--version'], { stdio: 'ignore', timeout: 3000 }).error === undefined; } catch { return false; }
+}
+
+function mecanismo() {
+    if (_forcaMecanismo !== undefined) return _forcaMecanismo;
+    if (process.platform === 'darwin') return fs.existsSync('/usr/bin/sandbox-exec') ? 'seatbelt' : null;
+    if (process.platform === 'linux') return temBinario('bwrap') ? 'bwrap' : null;
+    return null;
+}
+
+/** Linha para a PESSOA ver no terminal (o stderr do comando só o modelo lê). Vai pro
+ *  stderr do processo para não sujar a saída do `-p`. */
+function avisarPessoa(msg) {
+    try { console.error(require('../tui/ui.js').c.warn(`  ⎿ ${msg}`)); } catch { /* sem tela */ }
+}
+
+function socketSsh() {
+    const s = process.env.SSH_AUTH_SOCK;
+    try { return s && fs.statSync(s).isSocket() ? real(s) : null; } catch { return null; }
+}
+
+function real(p) { try { return fs.realpathSync(p); } catch { return path.resolve(p); } }
+function expandir(p, home) { return p.startsWith('~') ? path.join(home, p.slice(1)) : p; }
+const sbq = (s) => '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+
+function caminhos(projectDir, cfg, home) {
+    const escrita = [real(projectDir), '/tmp', real('/tmp'), real(os.tmpdir()), path.join(home, '.primocode', 'cache'),
+        ...cfg.escrita_extra.map((p) => expandir(p, home))];
+    try { fs.mkdirSync(path.join(home, '.primocode', 'cache'), { recursive: true }); } catch { /* sem cache, sem drama */ }
+    const negadosLeitura = LEITURA_NEGADA_HOME.map((p) => path.join(home, p));
+    return { escrita: [...new Set(escrita.map((p) => real(p)))], negadosLeitura };
+}
+
+/** Perfil Seatbelt. Em Seatbelt a ÚLTIMA regra que casa vence: negações no fim. */
+function perfilSeatbelt(projectDir, cfg = config(), home = os.homedir()) {
+    const { escrita, negadosLeitura } = caminhos(projectDir, cfg, home);
+    const l = ['(version 1)', '(allow default)', '(deny file-write*)'];
+    for (const p of escrita) l.push(`(allow file-write* (subpath ${sbq(p)}))`);
+    l.push('(allow file-write* (literal "/dev/null") (literal "/dev/tty") (literal "/dev/dtracehelper") (regex #"^/dev/fd/"))');
+    // Hook em .git/hooks roda fora da cerca no próximo `git commit` da pessoa. O .sample do `git init` passa.
+    l.push('(deny file-write* (regex #"/\\.git/hooks/[^/]+$"))');
+    // A pasta em si também: sem `rm -rf .git/hooks && mv pasta-minha .git/hooks`, nem `mv .git` pra recriar.
+    // Só unlink/rename (não create): o `git init` precisa criar a pasta hooks.
+    l.push('(deny file-write-unlink (regex #"/\\.git/hooks$"))');
+    l.push('(deny file-write-unlink (regex #"/\\.git$"))');
+    l.push('(allow file-write* (regex #"/\\.git/hooks/[^/]+\\.sample$"))');
+    for (const p of negadosLeitura) l.push(`(deny file-read* (subpath ${sbq(real(p))}) (subpath ${sbq(p)}))`);
+    l.push('(deny file-read* (regex #"/\\.env($|\\.[^/]*$)"))');
+    // osascript manda o Terminal/Finder fazer o que a cerca não deixa; `security` lê o Keychain.
+    l.push('(deny process-exec (literal "/usr/bin/osascript") (literal "/usr/bin/security"))');
+    l.push('(deny appleevent-send)');
+    l.push('(deny mach-lookup (global-name "com.apple.SecurityServer") (global-name "com.apple.securityd"))');
+    if (!cfg.ssh_agent) {
+        const sock = socketSsh();
+        l.push(`(deny network-outbound (remote unix-socket (path-regex #"${SOCKET_SSH_MAC}")))`);
+        if (sock) l.push(`(deny network-outbound (remote unix-socket (path-literal ${sbq(sock)})))`);
+    }
+    if (!cfg.rede) l.push('(deny network*)');
+    return l.join('\n');
+}
+
+function argsBwrap(projectDir, cfg = config(), home = os.homedir()) {
+    const { escrita, negadosLeitura } = caminhos(projectDir, cfg, home);
+    const a = ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc'];
+    for (const p of escrita) if (fs.existsSync(p)) a.push('--bind', p, p);
+    for (const p of negadosLeitura) {
+        if (!fs.existsSync(p)) continue;
+        if (fs.statSync(p).isDirectory()) a.push('--tmpfs', p); else a.push('--ro-bind', '/dev/null', p);
+    }
+    // .env* na pasta do projeto (um nível; o resto o Seatbelt cobre por regex)
+    try {
+        for (const f of fs.readdirSync(projectDir)) {
+            if (/^\.env($|\.)/.test(f)) a.push('--ro-bind', '/dev/null', path.join(real(projectDir), f));
+        }
+    } catch { /* pasta sumiu */ }
+    // Montado DEPOIS do --bind do projeto, para valer por cima dele. [VERIFICAR] no Linux.
+    const hooks = path.join(real(projectDir), '.git', 'hooks');
+    if (fs.existsSync(hooks)) a.push('--ro-bind', hooks, hooks);
+    const sock = cfg.ssh_agent ? null : socketSsh();
+    if (sock) a.push('--ro-bind', '/dev/null', sock);
+    if (!cfg.rede) a.push('--unshare-net');
+    a.push('--die-with-parent', '--chdir', real(projectDir));
+    return a;
+}
+
+/** Decide como envolver o comando. Devolve { cmd, args } ou { recusado } ou { semCerca }. */
+function envolver(command, projectDir, opts = {}) {
+    const home = opts.home || os.homedir();
+    const cfg = opts.cfg || config(home);
+    if (!cfg.ligado) {
+        let aviso = null;
+        if (!_avisouDesligado) {
+            _avisouDesligado = true;
+            aviso = process.platform === 'darwin'
+                ? 'aviso: o sandbox está desligado; os comandos do agente rodam sem cerca. /sandbox on liga.'
+                : 'aviso: o sandbox vem desligado fora do macOS; os comandos do agente rodam sem cerca. /sandbox on liga (no Linux precisa do bwrap).';
+        }
+        return { semCerca: true, motivo: 'desligado', aviso };
+    }
+    const mec = mecanismo();
+    if (!mec) {
+        if (cfg.modo === 'hard_requirement') {
+            return { recusado: 'o sandbox está em hard_requirement e este computador não tem como isolar (macOS: sandbox-exec; Linux: bwrap). Comando não rodou. Instale o bwrap ou use /sandbox off.' };
+        }
+        let aviso = null;
+        if (!_avisou) { _avisou = true; aviso = 'aviso: sem sandbox neste computador (modo best_effort); o comando roda sem isolamento.'; }
+        return { semCerca: true, motivo: 'sem_mecanismo', aviso };
+    }
+    if (mec === 'seatbelt') return { cmd: '/usr/bin/sandbox-exec', args: ['-p', perfilSeatbelt(projectDir, cfg, home), '/bin/sh', '-c', command], mec, cfg, home };
+    return { cmd: 'bwrap', args: [...argsBwrap(projectDir, cfg, home), '/bin/sh', '-c', command], mec, cfg, home };
+}
+
+/** Se o comando falhou por causa da cerca, diz por quê (e qual caminho). */
+function explicar(stderr, projectDir, cfg, home) {
+    const txt = String(stderr || '');
+    const m = /(?:^|\n)(?:[^\n:]*:\s*)?(\/[^\n:]+?|\.{1,2}\/[^\n:]+?|[^\s:'"]+?):?\s*(?:(?:open|read|stat|lstat|opendir|write):\s*)?(?:Operation not permitted|Permission denied|Read-only file system)/.exec(txt)
+        || /(?:Operation not permitted|Permission denied|Read-only file system)[^\n]*?['"]([^'"\n]+)['"]/.exec(txt);
+    if (!m) return null;
+    const alvo = path.resolve(projectDir, m[1].trim());
+    const { negadosLeitura } = caminhos(projectDir, cfg, home);
+    const secreto = negadosLeitura.some((p) => alvo === p || alvo.startsWith(p + path.sep) || alvo.startsWith(real(p) + path.sep))
+        || /(^|\/)\.env($|\.)/.test(alvo);
+    if (secreto) return `o sandbox bloqueou leitura de segredo: ${alvo} (${LEITURA_NEGADA_HOME.map((p) => '~/' + p).join(', ')} e .env* ficam fora do alcance). Não tente ler isso; peça ao usuário o que precisa.`;
+    if (/\/\.git\/hooks\//.test(alvo)) return `o sandbox bloqueou escrita em hook do git: ${alvo}. Hook roda fora da cerca; se o usuário quiser um, ele instala.`;
+    if (/Read-only|Operation not permitted|Permission denied/.test(txt)) {
+        return `o sandbox bloqueou escrita fora do projeto: ${alvo}. Escreva só dentro de ${projectDir}, em /tmp ou em ~/.primocode/cache.`;
+    }
+    return null;
+}
+
+function filtrarEnv(env, permitidas) {
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+        if (v === undefined) continue;
+        if (SECRETA.test(k) && !permitidas.includes(k)) continue;
+        out[k] = v;
+    }
+    return out;
+}
+
+/** Roda o comando dentro da cerca. Mesmo formato do runShell: { ok, code, stdout, stderr }. */
+function executar(command, { projectDir, timeout = 60000, env = process.env, home, homeProtegido } = {}) {
+    const cwd = projectDir || process.cwd();
+    const cfg = config(home);
+    const env2 = filtrarEnv(env, cfg.env_permitidas);
+    // `home` só escolhe de onde lê a config; as pastas protegidas são as do ~ de verdade (`homeProtegido` é para teste).
+    const e = envolver(command, cwd, { cfg, home: homeProtegido });
+    // Sem .git/hooks (git init --template=), um `mv` criaria a pasta lá dentro. Criada aqui, fora da cerca, o unlink barra a troca.
+    try { if (fs.statSync(path.join(cwd, '.git')).isDirectory()) fs.mkdirSync(path.join(cwd, '.git', 'hooks'), { recursive: true }); } catch { /* sem .git: nada a proteger */ }
+    return new Promise((resolve) => {
+        if (e.recusado) return resolve({ ok: false, code: 126, stdout: '', stderr: e.recusado, sandbox: { recusado: true } });
+        const termina = (error, stdout, stderr) => {
+            let err = stderr || '';
+            const info = { mecanismo: e.mec || null };
+            if (e.aviso) { err = e.aviso + '\n' + err; avisarPessoa(e.aviso); }
+            if (error && e.mec) {
+                const why = explicar(err, cwd, cfg, e.home);
+                if (why) { err = err + '\n[sandbox] ' + why; info.bloqueou = why; }
+            }
+            const r = error ? { ok: false, code: error.code ?? 1, stdout, stderr: err, killed: error.killed } : { ok: true, code: 0, stdout, stderr: err };
+            r.sandbox = info;
+            resolve(r);
+        };
+        const opt = { timeout, cwd, maxBuffer: 10 * 1024 * 1024, env: env2 };
+        if (e.semCerca) return require('child_process').exec(command, opt, termina);
+        execFile(e.cmd, e.args, opt, termina);
+    });
+}
+
+function estado(home) {
+    const cfg = config(home);
+    const mec = mecanismo();
+    return { ...cfg, mecanismo: mec, ativo: cfg.ligado && !!mec };
+}
+
+function _teste({ mecanismo: m, avisou } = {}) {
+    if (m !== undefined) _forcaMecanismo = m === 'auto' ? undefined : m;
+    if (avisou !== undefined) { _avisou = avisou; _avisouDesligado = avisou; }
+}
+
+module.exports = { config, salvar, estado, mecanismo, envolver, executar, explicar, filtrarEnv, perfilSeatbelt, argsBwrap, MODOS, _teste };

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/session/runner/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/plano-previo.js

@@ -6,7 +6,7 @@
  *   resposta(texto, passos)          → { acao: 'comecar' | 'cancelar' | 'editar' | 'invalida', n? }   (puro)
  *   comoPassos(pedido, passos)       → [{ titulo, pedido }] no formato do enviarPedido        (puro)
  *
- * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/perigo.js (recusa escrita), e a 2ª entrega os passos
+ * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/permission/perigo.js (recusa escrita), e a 2ª entrega os passos
  * aprovados ao laço de passos que o enviarPedido já tem (checkpoint do pedido inteiro, fatos passados de um passo
  * pro outro, retomada). Quem não programa não precisa saber disso: vê 3 a 5 frases e aperta Enter.
  */

package/lib/plugin/auto-preview.js

@@ -0,0 +1,71 @@
+/**
+ * auto-preview.js — quando o agente sobe um servidor de dev (run_background: npm run dev, vite, next dev,
+ * python -m http.server…), espera o endereço aparecer na saída e ABRE o app no navegador, já com o overlay
+ * de edição visual (botão "✎ Editar", lib/plugin/edicao-visual.js) — sem a pessoa pedir.
+ *
+ * Só abre com terminal de verdade (ctx.escolher existe) ou PRIMOCODE_PREVIEW_AUTO=1; nunca em -p, voz ou
+ * subagente. PRIMOCODE_SEM_PREVIEW=1 desliga. Uma vez por endereço. Sem dependência nova.
+ */
+'use strict';
+
+const path = require('path');
+
+const RE_DEV = /\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|preview)\b|\b(vite|next\s+dev|nuxt\s+dev|astro\s+dev|remix\s+dev|webpack(-dev-server|\s+serve)|parcel|live-server|http-server|serve)\b|python3?\s+-m\s+http\.server|flask\s+run|uvicorn|rails\s+s(erver)?\b|php\s+-S/i;
+const abertos = new Map();   // url real → { urlAberta, proxy }
+
+function ehServidorDev(comando) { return RE_DEV.test(String(comando || '')); }
+
+function ativo(ctx) {
+    if (process.env.PRIMOCODE_SEM_PREVIEW === '1') return false;
+    return process.env.PRIMOCODE_PREVIEW_AUTO === '1' || !!(ctx && typeof ctx.escolher === 'function');
+}
+
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Espera o endereço do servidor `id` e abre. Devolve { url, visual?, aberto } ou null (sem endereço a tempo / desligado).
+ * deps (testes): fundo, abrir(url), proxiar(alvo, porta, opcoes), portaLivre(), espera, aoEditar(pedido)
+ */
+async function abrirQuandoPronto(id, ctx = {}, deps = {}) {
+    if (!deps.forcar && !ativo(ctx)) return null;
+    const fundo = deps.fundo || require('../fundo');
+    const espera = deps.espera == null ? 20000 : deps.espera;
+    let url = null;
+    for (const fim = Date.now() + espera; Date.now() < fim && !url;) {
+        const s = fundo.saida(id);
+        if (!s || s.ok === false) return null;
+        url = fundo.endereco(s.texto);
+        if (!url && ctx.comando) {   // servidor que não imprime o endereço (ou imprime em buffer): a porta que está no comando
+            const m = String(ctx.comando).match(/(?:--port[ =]|-p\s+|PORT=|http\.server\s+|runserver\s+|:)(\d{2,5})\b/);
+            if (m && await (deps.responde || require('./preview.js').responde)(`http://localhost:${m[1]}`)) url = `http://localhost:${m[1]}`;
+        }
+        if (!url) { if (s.rodando === false) return null; await dormir(deps.intervalo || 300); }
+    }
+    if (!url) return null;
+    if (abertos.has(url)) return { url, ...abertos.get(url), jaAberto: true };
+    const dir = ctx.projectDir || process.cwd();
+    const V = require('./edicao-visual.js');
+    const P = require('./preview.js');
+    let alvo = url, proxy = null;
+    try {
+        const porta = await (deps.portaLivre || P.portaLivre)();
+        const aoEditar = deps.aoEditar || ctx.aoEditar || (async (pedido) => {
+            const { sh } = require('../cli/util.js');
+            sh(process.execPath, [path.join(__dirname, '..', '..', 'bin', 'primocode.js'), '-p', pedido], { cwd: dir });
+        });
+        proxy = await (deps.proxiar || V.proxiar)(url, porta, { dir, aoEditar });
+        if (proxy && proxy.unref) proxy.unref();
+        alvo = `http://localhost:${porta}`;
+    } catch { alvo = url; proxy = null; }   // sem proxy abre o app puro: melhor que não abrir
+    const abrir = deps.abrir || ((u) => require('../tool/tools').openInBrowser(u));
+    const r = await abrir(alvo);
+    const aberto = !r || r.ok !== false;
+    const info = { urlAberta: alvo, visual: alvo !== url, aberto };
+    if (aberto) abertos.set(url, info);
+    else if (proxy) try { proxy.close(); } catch { /* */ }
+    return { url, ...info };
+}
+
+function esquecer() { abertos.clear(); }
+
+module.exports = { ehServidorDev, abrirQuandoPronto, ativo, esquecer, RE_DEV };

package/lib/plugin/autoteste.js

@@ -0,0 +1,100 @@
+/**
+ * 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)); });
+  window.alert = function(){}; window.confirm = function(){ return true; }; window.prompt = function(){ return ''; };  // diálogo travaria o navegador
+  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 };