primocode 11.0.0 → 11.1.0

package/lib/motioncraft.js

@@ -1,67 +0,0 @@
-/**
- * motioncraft.js — `primocode motioncraft <comando>`.
- *
- * O MotionCraft (vendor/motioncraft, MIT, de ahmdd4vd) monta o motion:
- * template Remotion, música e efeitos sintetizados, sincronia, QA de quadro
- * e render. O que ele NÃO tem é voz. A voz continua sendo a do PrimoCode
- * (`estudio_narrar`: Edge, ElevenLabs, Kokoro), que devolve as falas com o
- * tempo MEDIDO; `voz-para-words` entrega esse tempo no formato que o
- * `timeline build` do MotionCraft lê (audio/words.json).
- *
- * Todo o resto é repassado ao CLI do MotionCraft, sem mexer nele.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const CLI = path.join(__dirname, '..', 'vendor', 'motioncraft', 'scripts', 'motioncraft.mjs');
-
-/**
- * As falas medidas viram palavras com tempo: cada palavra recebe a fatia da
- * fala proporcional ao tamanho dela (a mesma conta do repartirTrechos do
- * estúdio). Sem Whisper, é o melhor que o texto permite — e melhor que o
- * "frase por pausa" do MotionCraft, porque o início e o fim vêm da síntese.
- */
-function falasParaWords(falas) {
-    const lista = (falas || []).filter((f) => f && f.ate > f.de && String(f.texto || '').trim());
-    const words = [];
-    const phrases = [];
-    for (const f of lista) {
-        const ws = String(f.texto).trim().split(/\s+/);
-        const letras = ws.reduce((n, w) => n + w.length, 0) || 1;
-        let t = f.de;
-        for (const w of ws) {
-            const fim = t + (f.ate - f.de) * (w.length / letras);
-            words.push({ w, start: +t.toFixed(3), end: +fim.toFixed(3) });
-            t = fim;
-        }
-        phrases.push({ start: +f.de.toFixed(3), end: +f.ate.toFixed(3), text: String(f.texto).trim() });
-    }
-    return { mode: 'word', source: 'primocode-narrar', text: words.map((w) => w.w).join(' '), words, phrases };
-}
-
-function main(argv) {
-    const [cmd, ...resto] = argv;
-    if (cmd === 'voz-para-words') {
-        const entrada = resto[0];
-        if (!entrada) { console.error('uso: primocode motioncraft voz-para-words <saida-do-narrar.json> [--out audio/words.json]'); return 1; }
-        const i = resto.indexOf('--out');
-        const saida = path.resolve(i >= 0 ? resto[i + 1] : 'audio/words.json');
-        let dados;
-        try { dados = JSON.parse(fs.readFileSync(entrada, 'utf8')); } catch (e) { console.error(`não li ${entrada}: ${e.message}`); return 1; }
-        const w = falasParaWords(dados.falas || dados);
-        if (!w.words.length) { console.error('o arquivo não tem falas com tempo (esperava "falas": [{de, ate, texto}]).'); return 1; }
-        fs.mkdirSync(path.dirname(saida), { recursive: true });
-        fs.writeFileSync(saida, JSON.stringify(w, null, 1));
-        console.log(JSON.stringify({ ok: true, arquivo: saida, palavras: w.words.length, frases: w.phrases.length }));
-        return 0;
-    }
-    if (!fs.existsSync(CLI)) { console.error('vendor/motioncraft não está neste pacote.'); return 1; }
-    const r = spawnSync(process.execPath, [CLI, ...argv], { stdio: 'inherit' });
-    return r.status == null ? 1 : r.status;
-}
-
-module.exports = { falasParaWords, main, CLI };

package/lib/perigo.js

@@ -1,401 +0,0 @@
-/**
- * perigo.js — o que não tem volta pede licença antes.
- *
- * Até aqui o PrimoCode rodava qualquer `run_shell` e escrevia qualquer arquivo
- * sem perguntar. Para quase tudo isso é certo: quem não programa não sabe
- * responder "autoriza `npm install`?", e uma pergunta que ninguém sabe
- * responder vira um "sim" automático. O problema é o resto — o `rm -rf ~`, o
- * `git push --force`, o `curl … | sh`. Esses não se desfazem.
- *
- * Por isso a régua é estreita DE PROPÓSITO: perigoso é o que apaga, reescreve
- * história ou sai da pasta do projeto. `rm -rf node_modules` dentro do projeto
- * NÃO é perigoso — se fosse, o Primo perguntaria dez vezes por dia, e na
- * décima primeira a pessoa diria sim sem ler. Falso positivo aqui é tão ruim
- * quanto falso negativo: ele treina a pessoa a não ler a pergunta.
- *
- * Os três modos (/permissoes):
- *   auto      — o padrão. Roda tudo, mas SEMPRE pergunta antes do perigoso.
- *   perguntar — pergunta antes de todo comando e de toda escrita de arquivo.
- *   livre     — nunca pergunta. Nem o perigoso.
- *   plano     — SÓ LÊ: recusa escrita de arquivo, comando que muda coisa e MCP novo.
- *               O agente investiga e entrega o plano; a pessoa executa em outro modo.
- */
-
-'use strict';
-
-const os = require('os');
-const path = require('path');
-const protecao = require('./protecao');
-const trava = require('./trava');
-
-const MODOS = ['auto', 'perguntar', 'livre', 'plano'];
-const COMANDOS = new Set(['run_shell', 'run_in_new_terminal', 'run_background']);
-const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
-
-function normalizarModo(m) {
-    const s = String(m || '').trim().toLowerCase();
-    const apelido = { ask: 'perguntar', suggest: 'perguntar', full: 'livre', 'full-auto': 'livre', yolo: 'livre', plan: 'plano', 'read-only': 'plano' };
-    const n = apelido[s] || s;
-    return MODOS.includes(n) ? n : 'auto';
-}
-
-/* Quebra o comando em trechos (separados por ; && || | e quebra de linha) e
-   cada trecho em palavras — respeitando aspas. Sem respeitar aspas,
-   `git commit -m "tira o rm -rf /"` viraria um trecho `rm -rf /` e o Primo
-   pararia para perguntar sobre uma mensagem de commit. */
-function trechos(cmd) {
-    const saida = [];
-    let palavras = [], atual = '', aspa = null, temPalavra = false;
-    const fechaPalavra = () => { if (temPalavra) palavras.push(atual); atual = ''; temPalavra = false; };
-    const fechaTrecho = (sep) => { fechaPalavra(); if (palavras.length) saida.push({ palavras, sep }); palavras = []; };
-    const s = String(cmd || '');
-    for (let i = 0; i < s.length; i++) {
-        const ch = s[i];
-        if (aspa) {
-            if (ch === aspa) aspa = null;
-            else if (ch === '\\' && aspa === '"' && i + 1 < s.length) atual += s[++i];
-            else atual += ch;
-            continue;
-        }
-        if (ch === '"' || ch === "'") { aspa = ch; temPalavra = true; continue; }
-        if (ch === '\\' && i + 1 < s.length) { atual += s[++i]; temPalavra = true; continue; }
-        if (ch === ';' || ch === '\n') { fechaTrecho(';'); continue; }
-        if (ch === '&' && s[i + 1] === '&') { fechaTrecho(';'); i++; continue; }
-        if (ch === '|' && s[i + 1] === '|') { fechaTrecho(';'); i++; continue; }
-        if (ch === '|') { fechaTrecho('|'); continue; }
-        if (ch === '&') { fechaTrecho(';'); continue; }
-        if (/\s/.test(ch)) { fechaPalavra(); continue; }
-        atual += ch; temPalavra = true;
-    }
-    fechaTrecho(';');
-    return saida;
-}
-
-const TEMPORARIAS = [...new Set(['/tmp', '/private/tmp', os.tmpdir()])];
-
-function dentro(pai, filho) {
-    const r = path.relative(pai, filho);
-    return !!r && !r.startsWith('..') && !path.isAbsolute(r);
-}
-
-function expandir(alvo) {
-    const home = os.homedir();
-    return String(alvo).replace(/^~(?=\/|$)/, home).replace(/^\$\{?HOME\}?(?=\/|$)/, home);
-}
-
-/** O alvo cai FORA do projeto (ou é o projeto inteiro, ou um curinga que o esvazia)? */
-function alvoRuim(alvo, cwd, projeto, { recursivo, raizOk = false }) {
-    const a = String(alvo);
-    if (/^\.?\/?\*$|^\.\*$/.test(a)) return recursivo ? 'apaga tudo o que tem na pasta' : null;
-    const e = expandir(a);
-    // Variável que não é o HOME: não dá para saber aonde aponta, e "não sei"
-    // num rm é motivo de perguntar.
-    if (/\$/.test(e)) return 'apaga um caminho que depende de variável';
-    const alvoAbs = path.resolve(cwd, e.replace(/\/\*$/, ''));
-    const rel = path.relative(projeto, alvoAbs);
-    if (e === '/' || alvoAbs === path.parse(alvoAbs).root) return 'apaga a partir da raiz do computador';
-    if (alvoAbs === os.homedir()) return 'apaga a sua pasta pessoal inteira';
-    if (rel === '') return raizOk ? null : 'apaga a pasta do projeto inteira';
-    // A pasta temporária é descartável por definição: limpar lá não é perigo.
-    // (Mas nunca o que mora dentro da sua pasta pessoal.)
-    if (!dentro(os.homedir(), alvoAbs) && TEMPORARIAS.some((t) => dentro(t, alvoAbs))) return null;
-    if (rel.startsWith('..') || path.isAbsolute(rel)) return `apaga algo fora da pasta do projeto (${a})`;
-    return null;
-}
-
-// Palavras que vêm ANTES do comando de verdade e não mudam o que ele faz.
-const PREFIXOS = new Set(['env', 'nohup', 'time', 'command', 'exec', 'nice', 'xargs']);
-
-function analisarTrecho(palavras, estado) {
-    let p = palavras.slice();
-    // `VAR=x cmd`, `env -i cmd`, `xargs -0 rm`: pula até o comando.
-    while (p.length && (PREFIXOS.has(p[0]) || /^[A-Za-z_]\w*=/.test(p[0]) || (estado.pulandoFlags && /^-/.test(p[0])))) {
-        estado.pulandoFlags = PREFIXOS.has(p[0]) && p[0] !== 'command';
-        p.shift();
-    }
-    estado.pulandoFlags = false;
-    if (!p.length) return null;
-    const cmd = path.basename(p[0]);
-    const args = p.slice(1);
-    const flags = args.filter((x) => /^-/.test(x));
-    const alvos = args.filter((x) => !/^-/.test(x));
-    const tem = (re) => flags.some((f) => re.test(f));
-
-    if (cmd === 'sudo' || cmd === 'doas') return 'usa sudo: mexe como administrador no computador inteiro';
-    if (cmd === 'cd') { estado.cwd = path.resolve(estado.cwd, expandir(alvos[0] || os.homedir())); return null; }
-    if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) {
-        return analisarComando(args[1], estado.cwd, estado.projeto, estado.baixados);
-    }
-    // `python3 -c`, `node -e`: o SQL dentro do código do interpretador (o furo do teste real de 24/10).
-    if (/^(python[\d.]*|node|bun|deno|ruby|perl|php)$/.test(cmd)) {
-        const i = args.findIndex((x) => /^-[ce]$|^--eval$/.test(x));
-        const r = i >= 0 && args[i + 1] ? apagaBancoNoCodigo(args[i + 1]) : null;
-        if (r) return r;
-    }
-    if (cmd === 'rm' || cmd === 'rmdir' || cmd === 'trash') {
-        const recursivo = cmd === 'rmdir' || tem(/^-[a-zA-Z]*[rR]|^--recursive$/);
-        for (const a of alvos) {
-            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo });
-            if (r) return r;
-        }
-        return null;
-    }
-    if (cmd === 'find' && args.includes('-delete')) {
-        for (const a of alvos.slice(0, 1)) {
-            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo: true, raizOk: true });
-            if (r) return r.replace(/^apaga/, 'apaga com find');
-        }
-        return null;
-    }
-    if (cmd === 'git') {
-        const sub = alvos[0];
-        if (sub === 'add') { const r = protecao.gitAddLevaSegredo(alvos, flags, estado.cwd); if (r) return r; }
-        if (sub === 'push' && (tem(/^--force$|^-[a-zA-Z]*f/) || alvos.some((a) => /^\+/.test(a)))) {
-            return 'git push --force: reescreve o histórico no GitHub, e o que estava lá some';
-        }
-        if (sub === 'reset' && flags.includes('--hard')) return 'git reset --hard: joga fora o que não foi salvo em commit';
-        if (sub === 'clean' && tem(/^-[a-zA-Z]*f/) && !tem(/^-[a-zA-Z]*n|^--dry-run$/)) {
-            return 'git clean: apaga arquivos que o git não guardou';
-        }
-        return null;
-    }
-    if (cmd === 'dd') return 'dd: escreve direto no disco';
-    if (/^mkfs(\.|$)/.test(cmd) || cmd === 'newfs' || cmd === 'fdisk') return 'formata um disco';
-    if (cmd === 'diskutil' && /^(erase|zero|secureErase|partitionDisk|reformat)/i.test(alvos[0] || '')) return 'diskutil: apaga um disco';
-    if ((cmd === 'chmod' || cmd === 'chown') && tem(/^-[a-zA-Z]*R/)) {
-        for (const a of alvos) {
-            const e = path.resolve(estado.cwd, expandir(a));
-            if (e === '/' || e === os.homedir()) return `${cmd} -R em ${a}: muda a permissão de tudo`;
-        }
-        return null;
-    }
-    if (cmd === 'kill' && args.includes('-1')) return 'kill -1: encerra todos os seus programas';
-    if (['shutdown', 'reboot', 'halt', 'poweroff'].includes(cmd)) return 'desliga ou reinicia o computador';
-    if (['npm', 'pnpm', 'yarn'].includes(cmd) && alvos[0] === 'publish' && !flags.includes('--dry-run')) return `${cmd} publish: publica o pacote para o mundo inteiro`;
-    return null;
-}
-
-/* O LIVRO DE AÇÕES (lib/auditoria.js) mora fora do projeto, e o `rm` nele já
-   pedia licença. Mas `> livro`, `sed -i`, `truncate` e `mv` passavam: o
-   agente podia apagar ou reescrever o registro do que ele mesmo fez (review
-   do #95, item 3). Ler o livro (cat, grep, tail…) segue livre. */
-const LIVRO = path.join(os.homedir(), '.primocode', 'registro');
-const SO_LE = new Set(['cat', 'head', 'tail', 'less', 'more', 'grep', 'rg', 'wc', 'ls', 'jq', 'nl', 'stat', 'file', 'cd']);
-function mexeNoLivro(palavras, cwd) {
-    const p = palavras.filter((x) => !PREFIXOS.has(x) && !/^[A-Za-z_]\w*=/.test(x));
-    if (!p.length) return false;
-    const noLivro = (x) => {
-        const alvo = path.resolve(cwd, expandir(String(x).replace(/^\d?>>?/, '')));
-        return alvo === LIVRO || dentro(LIVRO, alvo);
-    };
-    // Redirecionar para dentro do livro é escrever nele, seja qual for o comando.
-    for (let i = 0; i < p.length; i++) {
-        const redireciona = /^\d?>>?$/.test(p[i]) ? p[i + 1] : /^\d?>>?./.test(p[i]) ? p[i] : /.>>?./.test(p[i]) ? p[i].split(/>>?/).pop() : null;
-        if (redireciona && noLivro(redireciona)) return true;
-    }
-    if (SO_LE.has(path.basename(p[0]))) return false;
-    return p.slice(1).some((x) => !/^-/.test(x) && noLivro(x.split(/>>?/)[0]));
-}
-
-/* Apagar o BANCO: o `rm` acima olha arquivo, e isto não é arquivo nenhum. "Apagou o banco de produção" é a
-   queixa que mais volta no fórum do Replit (replit.discourse.group, fev/2026), e um Postgres ou um Supabase não
-   voltam com /undo: a foto do checkpoint só vê a pasta. DELETE com WHERE e migração comum passam direto. */
-const APAGA_BANCO = [
-    [/\bDROP\s+(?:TABLE|DATABASE|SCHEMA)\b/i, 'apaga uma tabela ou o banco inteiro (DROP)'],
-    [/\bTRUNCATE\s+(?:TABLE\s+)?[\w."`]/i, 'esvazia uma tabela do banco (TRUNCATE)'],
-    [/\bDELETE\s+FROM\s+[\w."`]+\s*(?:;|["']|$)/im, 'apaga todas as linhas de uma tabela (DELETE sem WHERE)'],
-    [/\bprisma\s+(?:migrate\s+reset|db\s+push\b[^;&|]*--(?:force-reset|accept-data-loss))/i, 'zera o banco pelo Prisma (os dados somem)'],
-    [/\b(?:rails|rake)\s+db:(?:drop|reset|schema:load)\b/i, 'zera o banco pelo Rails (os dados somem)'],
-    [/\bmanage\.py\s+flush\b/i, 'esvazia o banco pelo Django (os dados somem)'],
-    [/\bsupabase\s+db\s+reset\b/i, 'zera o banco do Supabase (os dados somem)'],
-    [/\bsequelize(?:-cli)?\s+db:drop\b|\bknex\s+migrate:rollback\b[^;&|]*--all\b/i, 'apaga o banco ou desfaz todas as migrações'],
-];
-function apagaBanco(s) {
-    const achado = APAGA_BANCO.find(([re]) => re.test(s));
-    return achado ? `${achado[1]}: isso não volta com /undo` : null;
-}
-
-/* No código de um `python3 -c`, o DELETE vem montado: `"DELETE FROM " + t`, `execute(\"DELETE FROM x\")`. Aqui
-   vale qualquer DELETE FROM que não tenha WHERE antes do fim do texto (aspa, ; ou quebra de linha). */
-function apagaBancoNoCodigo(codigo) {
-    return apagaBanco(codigo)
-        || (/\bDELETE\s+FROM\b(?![^;'"`\n]*\bWHERE\b)/i.test(codigo) ? 'apaga todas as linhas de uma tabela (DELETE sem WHERE): isso não volta com /undo' : null);
-}
-
-/* O comando apaga dado de banco? É o que dispara a cópia (lib/backup-banco.js). Olha o texto, o `sh -c` e o código
-   de um `python3 -c`/`node -e`, igual ao portão. */
-function apagaBancoNoComando(comando, profundidade = 0) {
-    const s = String(comando || '');
-    if (apagaBanco(s)) return true;
-    if (profundidade > 2) return false;
-    for (const t of trechos(s)) {
-        const [cmd, ...args] = t.palavras.map((x, i) => (i === 0 ? path.basename(x) : x));
-        if (/^(sh|bash|zsh)$/.test(cmd) && args[0] === '-c' && args[1] && apagaBancoNoComando(args[1], profundidade + 1)) return true;
-        if (/^(python[\d.]*|node|bun|deno|ruby|perl|php)$/.test(cmd)) {
-            const i = args.findIndex((x) => /^-[ce]$|^--eval$/.test(x));
-            if (i >= 0 && args[i + 1] && apagaBancoNoCodigo(args[i + 1])) return true;
-        }
-    }
-    return false;
-}
-
-function analisarComando(comando, cwd, projeto, baixados = null) {
-    const s = String(comando || '');
-    const banco = apagaBanco(s);
-    if (banco) return banco;
-    // Baixar e rodar na hora: o que roda é o que o site mandar naquele segundo.
-    if (/\b(curl|wget)\b[^;&]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/.test(s)) {
-        return 'baixa um script da internet e roda sem ler';
-    }
-    // O mesmo que mcp_conectar, pela porta dos fundos: não pula o portão.
-    if (/\bprimocode\s+mcp\s+(conectar|connect|add)\b/.test(s)) return 'instala e roda um servidor MCP de terceiros';
-    const estado = { cwd, projeto, pulandoFlags: false, baixados };
-    for (const t of trechos(s)) {
-        if (mexeNoLivro(t.palavras, estado.cwd)) return 'mexe no livro de ações do PrimoCode (~/.primocode/registro), o registro do que o agente fez';
-        const r = analisarTrecho(t.palavras, estado);
-        if (r) return r;
-        const prot = protecao.shellEscreveEmProtegido(t.palavras);
-        if (prot) return prot;
-        const baix = protecao.rodaBaixado(t.palavras, estado.cwd, baixados);
-        if (baix) return baix;
-        if (baixados) protecao.baixadosPor(t.palavras).forEach((x) => baixados.add(path.resolve(estado.cwd, x)));
-    }
-    return null;
-}
-
-/**
- * Esta ação é perigosa?
- * @returns {{perigoso: boolean, motivo: string}}
- */
-function classificar(nome, args, { projectDir, baixados = null } = {}) {
-    const a = args || {};
-    const projeto = path.resolve(projectDir || process.cwd());
-    let motivo = null, fora = false;
-    if (COMANDOS.has(nome)) {
-        const cwd = a.cwd ? path.resolve(projeto, expandir(a.cwd)) : projeto;
-        motivo = analisarComando(a.command, cwd, projeto, baixados);
-    } else if (nome === 'mcp_conectar') {
-        /* Instala e roda código de terceiro (npx/uvx/docker) com as chaves do
-           usuário: sempre pergunta, como o curl | sh. O motivo leva o comando,
-           então "a sessão inteira" libera AQUELE servidor, não qualquer um. */
-        const cmd = [a.comando || a.command, ...(Array.isArray(a.args) ? a.args : [])].filter(Boolean).join(' ');
-        motivo = `instala e roda o servidor MCP "${a.nome || '?'}"${cmd ? ` (${cmd.slice(0, 80)})` : ''}`;
-    } else if (ESCRITAS.has(nome) && a.path) {
-        const alvo = path.resolve(projeto, expandir(a.path));
-        const rel = path.relative(projeto, alvo);
-        if (rel.startsWith('..') || path.isAbsolute(rel) || /^[a-zA-Z]:[\\/]/.test(String(a.path))) {
-            motivo = `mexe num arquivo fora da pasta do projeto (${a.path})`;
-            fora = true;
-        } else motivo = protecao.motivoDoArquivo(rel);
-    }
-    return { perigoso: !!motivo, motivo: motivo || '', fora };
-}
-
-/* Comando que só olha: todo trecho começa por uma palavra de leitura, sem
-   redirecionar para arquivo. Na dúvida, não é leitura. */
-const LEITURA = new Set([...SO_LE, 'pwd', 'echo', 'find', 'tree', 'which', 'diff', 'sort', 'uniq', 'du', 'df']);
-const GIT_LE = new Set(['status', 'diff', 'log', 'show', 'branch', 'ls-files', 'blame', 'rev-parse']);
-function somenteLeitura(comando) {
-    const s = String(comando || '');
-    if (/[>`]|\$\(|\bfind\b[^;&|]*(-delete|-exec)/.test(s)) return false;
-    const ts = trechos(s);
-    if (!ts.length) return false;
-    return ts.every((t) => {
-        const p = t.palavras.filter((x) => !PREFIXOS.has(x) && !/^[A-Za-z_]\w*=/.test(x));
-        if (!p.length) return false;
-        const cmd = path.basename(p[0]);
-        if (cmd === 'git') return GIT_LE.has(p.slice(1).find((x) => !x.startsWith('-')));
-        return LEITURA.has(cmd);
-    });
-}
-
-/* O rótulo de risco em português, na pergunta do modo "perguntar" (ideia do modo writes do Codex CLI, brechas-3 #4
-   [VERIFICAR]): quem pergunta de tudo cansa, mas "rodar: npm i lodash" sozinho não diz se é leitura ou instalação.
-   Puro. Na dúvida, "muda coisa". */
-const INSTALA = /(^|[\s;&|])(npm\s+(i|install|add|ci)\b|pnpm\s+(i|install|add)\b|yarn\s+(add|install)\b|pip3?\s+install\b|brew\s+install\b|apt(-get)?\s+install\b|cargo\s+install\b|go\s+install\b|npx\s|uvx\s|curl\b[^|]*\|\s*(ba|z)?sh)/;
-const APAGA = /(^|[\s;&|])(rm|rmdir|mv|unlink|shred|truncate)\s|git\s+(reset|clean|checkout\s+--|push\s+--force|push\s+-f)\b/;
-function rotulo(comando) {
-    const s = String(comando || '');
-    if (apagaBanco(s)) return 'apaga dados do banco';
-    if (somenteLeitura(s)) return 'só lê';
-    if (INSTALA.test(s)) return 'instala coisa';
-    if (APAGA.test(s)) return 'apaga ou reescreve';
-    return 'muda coisa';
-}
-
-function sha256(t) { return require('crypto').createHash('sha256').update(String(t)).digest('hex'); }
-
-function chaveDoPerigo(nome, args) {
-    const a = args || {};
-    if (nome === 'mcp_conectar') return `${nome}\0${JSON.stringify([a.nome, a.comando || a.command, a.args, a.env])}`;
-    return `${nome}\0${JSON.stringify(a)}`;
-}
-
-function novo() { return { liberados: new Set(), negados: new Set(), baixados: new Set() }; }
-
-/* Uma pergunta por vez. Subagentes rodam em paralelo (Promise.all) e dois
-   pedidos ao mesmo tempo no mesmo terminal se atropelariam. */
-let fila = Promise.resolve();
-function emFila(fn) { const p = fila.then(fn, fn); fila = p.catch(() => {}); return p; }
-
-/**
- * O portão. Devolve {ok:true} ou {ok:false, error, motivo}.
- *
- * `perguntar(frase, {tipo, motivo, primeira})` → 'agora' | 'sessao' | 'nao',
- * o mesmo contrato do portão do desktop (lib/permissao.js).
- */
-async function portao(estado, { modo, nome, args, projectDir, subagent = false, perguntar = null }) {
-    const m = normalizarModo(modo);
-    // O /lock vale em TODO modo, até no livre: arquivo travado o agente só lê (lib/trava.js).
-    const travado = trava.recusa(nome, args, projectDir);
-    if (travado) return { ok: false, motivo: travado.motivo, error: travado.error };
-    if (m === 'livre') return { ok: true };
-    if (m === 'plano') {
-        const mexe = ESCRITAS.has(nome) || nome === 'mcp_conectar'
-            || (COMANDOS.has(nome) && !somenteLeitura((args || {}).command));
-        if (mexe) {
-            return { ok: false, motivo: 'modo plano', error: 'Recusado: o modo plano só lê. Investigue com read_file, grep e comandos de leitura, e entregue o plano; a pessoa muda de modo (/perms auto) para executar.' };
-        }
-        return { ok: true };
-    }
-    const { perigoso, motivo: motivoPerigo, fora } = classificar(nome, args, { projectDir, baixados: estado.baixados });
-    const tipo = perigoso ? 'perigo' : (m === 'perguntar' && (COMANDOS.has(nome) || nome === 'mcp_usar')) ? 'comando'
-        : (m === 'perguntar' && ESCRITAS.has(nome)) ? 'arquivo' : null;
-    if (!tipo) return { ok: true };
-
-    const motivo = perigoso ? motivoPerigo
-        : tipo === 'comando' ? (nome === 'mcp_usar' ? `usar ${(args || {}).servidor}.${(args || {}).ferramenta}`
-            : `rodar (${rotulo((args || {}).command)}): ${String((args || {}).command || '').slice(0, 80)}`)
-            : `escrever ${String((args || {}).path || 'um arquivo')}`;
-    const recusa = (texto) => ({ ok: false, motivo, error: texto });
-
-    // Escrever fora da pasta o tools.js já recusa sozinho: perguntar seria
-    // pedir um "sim" que não serve para nada.
-    if (perigoso && fora && ESCRITAS.has(nome)) {
-        return recusa(`Recusado: ${motivo}. O PrimoCode só escreve dentro da pasta do projeto — use /dir se a pessoa quiser trabalhar em outra pasta.`);
-    }
-    if (subagent) {
-        return recusa(`Recusado: ${motivo}. Subagente não tem como pedir autorização — `
-            + 'deixe esse passo para o agente principal e diga no seu resumo o que falta fazer.');
-    }
-    const chave = `${nome}:${JSON.stringify(args || {})}`;
-    const negado = `A pessoa não autorizou: ${motivo}. Não faça o mesmo por outro comando (python -c, node -e, script): conte na resposta que isso foi recusado e siga sem ele, ou pergunte.`;
-    if (estado.negados.has(chave)) return recusa(negado);
-    // "A sessão inteira" libera o TIPO de pergunta: no perigoso, aquele motivo
-    // (um push --force autorizado não autoriza um rm -rf ~); no modo
-    // perguntar, os comandos ou as escritas comuns.
-    // O motivo do mcp_conectar é texto de tela (cortado em 80): a chave leva o comando inteiro.
-    const liberacao = perigoso ? `perigo:${motivo}${nome === 'mcp_conectar' ? ':' + sha256(chaveDoPerigo(nome, args)) : ''}` : tipo;
-    if (estado.liberados.has(liberacao)) return { ok: true };
-    if (typeof perguntar !== 'function') {
-        return recusa(`Recusado: ${motivo}. Isso precisa de autorização e não há ninguém para autorizar neste modo. Não faça o mesmo por outro comando: conte na resposta que isso foi recusado.`);
-    }
-
-    const resposta = await emFila(() => perguntar(motivo, { tipo, motivo, primeira: false }));
-    if (resposta === 'sessao') { estado.liberados.add(liberacao); return { ok: true }; }
-    if (resposta === 'agora') return { ok: true };
-    estado.negados.add(chave);
-    return recusa(negado);
-}
-
-module.exports = { apagaBancoNoComando, somenteLeitura, rotulo, classificar, portao, novo, normalizarModo, trechos, MODOS };

package/lib/permissao.js

@@ -1,137 +0,0 @@
-/**
- * permissao.js — o portão do controle do computador.
- *
- *   "Implementar controle do computador do usuário. Sempre pedir permissão
- *    antes: aparece o pedido, o usuário autoriza, e só então o agente age. O
- *    usuário assiste o agente mexendo na máquina em tempo real."
- *
- * ── O QUE FALTAVA ────────────────────────────────────────────────────────
- * O controle do computador já existia inteiro (lib/desktop.js): mouse,
- * teclado, janelas, clique em botão pelo nome. O que não existia era o
- * pedido. O agente decidia mexer e mexia — o ponteiro saía andando sozinho
- * sem ninguém ter dito que podia.
- *
- * E a diferença entre isso e as outras ferramentas é real, não cerimônia:
- * escrever arquivo acontece DENTRO da pasta do projeto, e o que der errado se
- * desfaz. Mover o mouse e apertar teclas acontece no computador inteiro, no
- * programa que estiver na frente — e um `alt+tab` no momento errado digita o
- * que o agente ia escrever dentro da sua conversa aberta no WhatsApp.
- *
- * ── AS TRÊS RESPOSTAS ────────────────────────────────────────────────────
- * "Sim, agora" · "Sim, esta sessão inteira" · "Não".
- *
- * A do meio existe porque uma tarefa de desktop são dez, vinte ações. Pedir
- * a cada clique transformaria a permissão num botão que a pessoa aperta sem
- * ler — que é o mesmo que não pedir, com uma etapa a mais. Pedir UMA vez, com
- * o que ele vai fazer escrito, é a pergunta que ainda é lida.
- *
- * A sessão é a sessão: fechar o PrimoCode esquece tudo. Não há arquivo de
- * "sempre permitir" de propósito — uma autorização permanente é exatamente o
- * que ninguém lembra de ter dado.
- *
- * ── O QUE NÃO PASSA POR AQUI ─────────────────────────────────────────────
- * Ler a tela (`desktop_screenshot`, `desktop_windows`, `desktop_elements`,
- * `desktop_size`) não mexe em nada — é o agente ABRINDO O OLHO, e é o que ele
- * precisa fazer para saber onde clicar. Exigir autorização para olhar
- * obrigaria a pessoa a responder duas vezes a mesma pergunta: uma para ele
- * ver, outra para ele agir.
- *
- * O print merece uma linha à parte: ele vê a sua tela inteira, e isso é
- * sério. Mas quem decide se o conteúdo da tela sai da máquina é o modelo, e
- * modelo de texto não enxerga imagem — o print vira arquivo no disco, para o
- * agente medir onde as coisas estão. Ler é olhar; o portão é para AGIR.
- */
-
-'use strict';
-
-// Ferramentas que MEXEM na máquina. Todo o resto do `desktop_*` é olhar.
-const AGEM = new Set([
-    'desktop_click', 'desktop_double_click', 'desktop_click_element',
-    'desktop_move', 'desktop_drag', 'desktop_type', 'desktop_key',
-    'desktop_scroll', 'desktop_open_app',
-]);
-
-/* O que cada uma faz, em português de gente. Vai na pergunta: "autoriza
-   desktop_click_element" não é uma pergunta que alguém consiga responder. */
-const EM_PORTUGUES = {
-    desktop_click: 'clicar na sua tela',
-    desktop_double_click: 'dar um clique duplo na sua tela',
-    desktop_click_element: 'clicar num botão da janela aberta',
-    desktop_move: 'mover o seu mouse',
-    desktop_drag: 'arrastar com o seu mouse',
-    desktop_type: 'digitar no programa que está na frente',
-    desktop_key: 'apertar teclas no programa que está na frente',
-    desktop_scroll: 'rolar a tela',
-    desktop_open_app: 'abrir um programa no seu computador',
-};
-
-function novo() {
-    return { liberado: false, negado: false, pedidos: 0 };
-}
-
-/** Esta ferramenta mexe na máquina? */
-function precisa(nome) { return AGEM.has(nome); }
-
-/** A frase do que ele quer fazer, com o alvo quando há um. */
-function descrever(nome, args) {
-    const a = args || {};
-    const base = EM_PORTUGUES[nome] || nome;
-    const alvo = a.name || a.app || a.window || a.text || a.key
-        || (a.x != null ? `${a.x},${a.y}` : '');
-    const curto = String(alvo || '').replace(/\s+/g, ' ').trim();
-    return curto ? `${base} — ${curto.length > 60 ? curto.slice(0, 59) + '…' : curto}` : base;
-}
-
-/**
- * O portão.
- *
- * @param {object} estado      o estado da sessão (de `novo()`)
- * @param {string} nome        a ferramenta
- * @param {object} args        os argumentos dela
- * @param {function} perguntar async (frase) => 'agora' | 'sessao' | 'nao'
- * @returns {Promise<{ok: boolean, error?: string, primeira?: boolean}>}
- */
-async function pedir(estado, nome, args, perguntar) {
-    if (!precisa(nome)) return { ok: true };
-    if (estado.liberado) return { ok: true };
-
-    /* Negar uma vez vale para a sessão. Sem isto, quem disse não leva a mesma
-       pergunta na ação seguinte, e na seguinte — o agente tem vinte ações
-       para tentar, e a pessoa acabaria dizendo sim de cansaço. */
-    if (estado.negado) {
-        return {
-            ok: false,
-            error: 'O usuário NÃO autorizou o controle do computador nesta sessão. '
-                + 'Não tente de novo com outra ferramenta de desktop: a resposta é a mesma. '
-                + 'Resolva por outro caminho (arquivos, terminal, navegador) ou diga a ele '
-                + 'o que precisaria ser feito à mão.',
-        };
-    }
-
-    // Sem quem responda (pipe, CI, subagente), a resposta é NÃO. O padrão
-    // seguro de uma pergunta que ninguém ouviu não é "pode".
-    if (typeof perguntar !== 'function') {
-        return {
-            ok: false,
-            error: 'Controle do computador precisa de autorização, e não há ninguém '
-                + 'para autorizar neste modo. Use outro caminho.',
-        };
-    }
-
-    const primeira = estado.pedidos === 0;
-    estado.pedidos++;
-    const resposta = await perguntar(descrever(nome, args), { primeira });
-
-    if (resposta === 'sessao') { estado.liberado = true; return { ok: true, primeira }; }
-    if (resposta === 'agora') return { ok: true, primeira };
-
-    estado.negado = true;
-    return {
-        ok: false,
-        error: 'O usuário recusou o controle do computador. Não insista com outra '
-            + 'ferramenta de desktop — resolva por outro caminho ou explique a ele '
-            + 'o que precisaria ser feito à mão.',
-    };
-}
-
-module.exports = { novo, precisa, pedir, descrever, AGEM, EM_PORTUGUES };