primocode 10.17.1 → 10.19.0

package/lib/segredos.js

@@ -0,0 +1,103 @@
+/**
+ * segredos.js — o /secrets: as chaves que o projeto usa, SÓ OS NOMES.
+ *
+ *   listar(dir)                 → [{ nome, noEnv, vazia, usadaEm: ['server.js'] }]   (nunca o valor)
+ *   nomeValido('openai_key')    → 'OPENAI_KEY' | null
+ *   gravar(dir, nome, valor)    → { criou, gitignore }   (escreve no .env, que nunca vai pro git)
+ *
+ * "Chave" é a senha que um serviço te dá (OpenAI, Stripe, banco de dados…). Quem escreve
+ * isso no código e sobe pro GitHub perde a chave em minutos. Por isso o valor só entra pelo
+ * teclado, escondido, e só vai para o `.env`; a tela mostra nome e nada mais.
+ * O agente escrevendo no .env continua passando pelo portão de sempre (lib/perigo.js): este
+ * módulo só serve ao /secrets, não abre porta nenhuma para ele.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const protecao = require('./protecao.js');
+
+const IGNORAR = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.primocode', '.venv', '__pycache__']);
+const CODIGO = /\.(m?js|cjs|jsx|tsx?|py|rb|php|go|html|vue|svelte)$/i;
+const USOS = [/process\.env\.([A-Z][A-Z0-9_]+)/g, /process\.env\[['"]([A-Z][A-Z0-9_]+)['"]\]/g, /import\.meta\.env\.([A-Z][A-Z0-9_]+)/g,
+    /os\.environ(?:\.get)?[[(]['"]([A-Z][A-Z0-9_]+)['"]/g, /getenv\(['"]([A-Z][A-Z0-9_]+)['"]/g];
+const PADRAO_NOME = /^[A-Z_][A-Z0-9_]*$/;
+
+function nomeValido(nome) {
+    const n = String(nome || '').trim().toUpperCase().replace(/[-\s]+/g, '_');
+    return PADRAO_NOME.test(n) ? n : null;
+}
+
+/** As linhas NOME=valor de um arquivo .env → { NOME: valorVazio? } (o valor em si nunca sai daqui). */
+function nomesDoEnv(arquivo) {
+    const out = {};
+    let txt = '';
+    try { txt = fs.readFileSync(arquivo, 'utf8'); } catch { return out; }
+    for (const l of txt.split('\n')) {
+        const m = l.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/);
+        if (m) out[m[1]] = !m[2].trim().replace(/^["']|["']$/g, '');
+    }
+    return out;
+}
+
+function usosNoCodigo(dir, limite = 400) {
+    const achou = {};
+    let vistos = 0;
+    const andar = (d, fundo) => {
+        let itens = [];
+        try { itens = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const it of itens) {
+            if (vistos >= limite) return;
+            if (it.isDirectory()) { if (!IGNORAR.has(it.name) && fundo < 6) andar(path.join(d, it.name), fundo + 1); continue; }
+            if (!CODIGO.test(it.name)) continue;
+            vistos++;
+            let txt = '';
+            try { txt = fs.readFileSync(path.join(d, it.name), 'utf8').slice(0, 300000); } catch { continue; }
+            const rel = path.relative(dir, path.join(d, it.name));
+            for (const re of USOS) for (const m of txt.matchAll(re)) (achou[m[1]] = achou[m[1]] || new Set()).add(rel);
+        }
+    };
+    andar(dir, 0);
+    return achou;
+}
+
+function listar(dir) {
+    const env = { ...nomesDoEnv(path.join(dir, '.env.example')), ...nomesDoEnv(path.join(dir, '.env')) };
+    const noEnv = nomesDoEnv(path.join(dir, '.env'));
+    const codigo = usosNoCodigo(dir);
+    const nomes = new Set([...Object.keys(env), ...Object.keys(codigo)]);
+    return [...nomes].sort().map((nome) => ({
+        nome,
+        noEnv: Object.prototype.hasOwnProperty.call(noEnv, nome),
+        vazia: !!noEnv[nome],
+        usadaEm: codigo[nome] ? [...codigo[nome]].slice(0, 3) : [],
+    }));
+}
+
+const guardaValor = (v) => (/^[\w.:/@+-]*$/.test(v) ? v : JSON.stringify(v));
+
+function gravar(dir, nome, valor) {
+    const n = nomeValido(nome);
+    if (!n) throw new Error('Nome de chave inválido: use letras, números e _ (ex.: OPENAI_API_KEY).');
+    if (/[\r\n]/.test(String(valor))) throw new Error('A chave não pode ter quebra de linha.');
+    const f = path.join(dir, '.env');
+    const criou = !fs.existsSync(f);
+    const linhas = criou ? [] : fs.readFileSync(f, 'utf8').split('\n');
+    const nova = `${n}=${guardaValor(String(valor))}`;
+    const i = linhas.findIndex((l) => new RegExp(`^\\s*(export\\s+)?${n}\\s*=`).test(l));
+    if (i >= 0) linhas[i] = nova;
+    else { while (linhas.length && linhas[linhas.length - 1] === '') linhas.pop(); linhas.push(nova); }
+    fs.writeFileSync(f, linhas.join('\n') + '\n', { mode: 0o600 });
+    try { fs.chmodSync(f, 0o600); } catch { /* sistema sem permissão de arquivo */ }
+    let gitignore = false;
+    if (!protecao.envFicaDeFora(dir)) {
+        const g = path.join(dir, '.gitignore');
+        const atual = fs.existsSync(g) ? fs.readFileSync(g, 'utf8') : '';
+        fs.writeFileSync(g, atual + (atual && !atual.endsWith('\n') ? '\n' : '') + '.env\n');
+        gitignore = true;
+    }
+    return { criou, gitignore, nome: n, substituiu: i >= 0 };
+}
+
+module.exports = { listar, gravar, nomeValido, nomesDoEnv };

package/lib/team.js

@@ -0,0 +1,317 @@
+/**
+ * team.js — o PrimoCode trabalha junto com as IAs de código que a pessoa já tem (26/10).
+ *
+ * "Um faz, o outro revisa." A pessoa já pagou o Claude Code, o Codex, o
+ * Gemini, o Antigravity ou o OpenCode: o `/team claude` liga um deles como
+ * parceiro. O PrimoCode faz a mudança e o parceiro revisa, só lendo; ou o
+ * parceiro faz (`/team claude faz <pedido>`) numa cópia do projeto e o
+ * PrimoCode mostra o que mudou antes de aplicar.
+ *
+ * As opções de cada um foram conferidas no `--help` de verdade (26/10), e
+ * conferidas de novo na hora de rodar (`precisa`): versão que não tem a opção
+ * não roda, em vez de rodar com uma opção adivinhada. Nenhum parceiro roda
+ * com a opção que pula as permissões dele.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/*
+ * `revisar` só lê; `fazer` edita a pasta onde roda (que é sempre uma cópia).
+ * `prompt` vai pelo stdin quando `stdin: true` (o `--tools` do claude engole o
+ * que vem depois). Conferido no `--help` em 26/10: claude 2.x, agy, opencode
+ * 1.x. O codex e o gemini não estão nesta máquina: as opções são as da
+ * documentação deles, e só rodam se o `--help` da versão instalada tiver todas.
+ */
+const PARCEIROS = {
+    claude: {
+        titulo: 'Claude Code', bin: 'claude', instalar: 'npm install -g @anthropic-ai/claude-code',
+        ajuda: ['--help'], precisa: ['--print', '--permission-mode', 'plan', 'acceptEdits', 'stream-json'],
+        stdin: true, formato: 'stream-json',
+        revisar: () => ['-p', '--permission-mode', 'plan', '--output-format', 'stream-json', '--verbose'],
+        fazer: () => ['-p', '--permission-mode', 'acceptEdits', '--output-format', 'stream-json', '--verbose'],
+    },
+    codex: {
+        titulo: 'Codex', bin: 'codex', instalar: 'npm install -g @openai/codex',
+        ajuda: ['exec', '--help'], precisa: ['--sandbox', 'read-only', 'workspace-write'],
+        revisar: (p) => ['exec', '--sandbox', 'read-only', p],
+        fazer: (p) => ['exec', '--sandbox', 'workspace-write', p],
+    },
+    gemini: {
+        titulo: 'Gemini CLI', bin: 'gemini', instalar: 'npm install -g @google/gemini-cli',
+        ajuda: ['--help'], precisa: ['--prompt', '--approval-mode', 'auto_edit'],
+        revisar: (p) => ['--approval-mode', 'default', '-p', p],
+        fazer: (p) => ['--approval-mode', 'auto_edit', '-p', p],
+    },
+    agy: {
+        titulo: 'Antigravity', bin: 'agy', instalar: 'baixe em antigravity.google',
+        ajuda: ['--help'], precisa: ['--print', '--mode', 'accept-edits'],
+        revisar: (p) => ['--print', p, '--mode', 'plan'],
+        fazer: (p) => ['--print', p, '--mode', 'accept-edits'],
+    },
+    opencode: {
+        titulo: 'OpenCode', bin: 'opencode', instalar: 'npm install -g opencode-ai',
+        ajuda: ['run', '--help'], precisa: ['--dir', '--agent'],
+        revisar: (p, dir) => ['run', '--dir', dir, '--agent', 'plan', p],
+        fazer: (p, dir) => ['run', '--dir', dir, p],
+    },
+};
+const NOMES = Object.keys(PARCEIROS);
+
+// As opções que tiram a trava do parceiro. Nunca entram (o teste confere).
+const PULA_PERMISSAO = /^(--dangerously-skip-permissions|--dangerously-bypass-approvals-and-sandbox|--yolo|-y|--auto|--full-auto|bypassPermissions|yolo|danger-full-access)$/;
+
+/** O caminho do programa no PATH, ou null. Sem rodar nada. */
+function achar(bin, { PATH = process.env.PATH || '', plataforma = process.platform, existe = fs.existsSync } = {}) {
+    const exts = plataforma === 'win32' ? ['.cmd', '.exe', '.bat', ''] : [''];
+    for (const pasta of PATH.split(path.delimiter).filter(Boolean)) {
+        for (const ext of exts) {
+            const p = path.join(pasta, bin + ext);
+            if (existe(p)) return p;
+        }
+    }
+    return null;
+}
+
+/** Os parceiros instalados: [{ nome, titulo, caminho }]. */
+function instalados(opts) {
+    return NOMES.map((nome) => ({ nome, titulo: PARCEIROS[nome].titulo, caminho: achar(PARCEIROS[nome].bin, opts) }))
+        .filter((x) => x.caminho);
+}
+
+/** `/team <arg>` → { acao: 'status' | 'ligar' | 'desligar' | 'fazer', nome?, pedido?, erro? }. */
+function entender(arg, achados) {
+    const t = String(arg || '').trim();
+    if (!t) return { acao: 'status' };
+    if (/^(off|desliga|desligar|sozinho|nenhum)$/i.test(t)) return { acao: 'desligar' };
+    const [primeira, ...resto] = t.split(/\s+/);
+    const nome = primeira.toLowerCase();
+    if (!PARCEIROS[nome]) return { erro: `Não conheço "${primeira}". Os parceiros são: ${NOMES.join(', ')}.` };
+    if (!achados.some((x) => x.nome === nome)) {
+        return { erro: `O ${PARCEIROS[nome].titulo} não está instalado neste computador. Pra instalar: ${PARCEIROS[nome].instalar}` };
+    }
+    if (!resto.length) return { acao: 'ligar', nome };
+    if (/^(faz|faça|faca|fazer|do)$/i.test(resto[0]) && resto.length > 1) return { acao: 'fazer', nome, pedido: resto.slice(1).join(' ') };
+    return { erro: `Não entendi "${resto.join(' ')}". Use /team ${nome} pra ligar, /team ${nome} faz <pedido>, ou /team off.` };
+}
+
+/** As linhas do `/team` sozinho. */
+function status(achados, ligado) {
+    if (!achados.length) {
+        return ['Nenhuma outra IA de código instalada: o PrimoCode trabalha sozinho, e dá conta.',
+            'Pra trabalhar em dupla, instale uma delas e digite /team <nome>:',
+            ...NOMES.map((n) => `  ${n} — ${PARCEIROS[n].instalar}`)];
+    }
+    const linhas = ['Parceiros instalados:'];
+    for (const x of achados) linhas.push(`  ${x.nome === ligado ? '●' : '○'} ${x.nome} (${x.titulo})${x.nome === ligado ? ' — ligado' : ''}`);
+    linhas.push(ligado
+        ? `Com o ${ligado} ligado: o PrimoCode faz e ele revisa. /team ${ligado} faz <pedido> deixa ele fazer · /team off desliga.`
+        : 'Nenhum ligado. /team <nome> liga: o PrimoCode faz e ele revisa.');
+    return linhas;
+}
+
+/* ── RODAR O PARCEIRO ──────────────────────────────────────────────── */
+
+const PRAZO = { revisar: Number(process.env.PRIMOCODE_TEAM_PRAZO || 5 * 60 * 1000), fazer: Number(process.env.PRIMOCODE_TEAM_PRAZO_FAZER || 15 * 60 * 1000) };
+const MAX_DIFF = 60000;
+
+// Segredo nunca vai no pedido: o arquivo inteiro (.env, chave) fica de fora, e o que parece chave vira "[segredo tirado]".
+const ARQUIVO_SECRETO = /(^|[/\\])(\.env(\..*)?|[^/\\]*\.(pem|key|p12|pfx)|id_rsa[^/\\]*|\.npmrc|\.netrc|credentials[^/\\]*)$/i;
+function semSegredo(texto) {
+    let t = String(texto || '');
+    for (const [, re] of require('./chave-exposta.js').TIPOS) t = t.replace(new RegExp(re.source, re.flags.replace('g', '') + 'g'), '[segredo tirado]');
+    return t;
+}
+
+const git = (dir, args, opts = {}) => require('child_process').execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 32 * 1024 * 1024, ...opts });
+function ehGit(dir) { try { return git(dir, ['rev-parse', '--is-inside-work-tree']).trim() === 'true'; } catch { return false; } }
+
+/** O que o pedido mudou, como diff (git) ou como ficou cada arquivo (sem git). Sem segredo. '' = nada a revisar. */
+function diffDaVez(dir, arquivos) {
+    const rels = [...new Set(arquivos.map((a) => path.relative(dir, path.resolve(dir, String(a)))))]
+        .filter((r) => r && !r.startsWith('..') && !path.isAbsolute(r) && !ARQUIVO_SECRETO.test(r));
+    if (!rels.length) return '';
+    let texto = '';
+    if (ehGit(dir)) {
+        try { texto = git(dir, ['diff', 'HEAD', '--', ...rels]); } catch { texto = ''; }
+        let novos = [];
+        try { novos = git(dir, ['ls-files', '--others', '--exclude-standard', '--', ...rels]).split('\n').filter(Boolean); } catch { novos = []; }
+        for (const r of novos) texto += `\n--- /dev/null\n+++ b/${r}\n` + lerTexto(path.join(dir, r)).split('\n').map((l) => `+${l}`).join('\n');
+    } else {
+        for (const r of rels) if (fs.existsSync(path.join(dir, r))) texto += `\n=== ${r} (como ficou) ===\n${lerTexto(path.join(dir, r))}`;
+    }
+    texto = texto.trim();
+    if (texto.length > MAX_DIFF) texto = `${texto.slice(0, MAX_DIFF)}\n[… cortado: a mudança passa de ${Math.round(MAX_DIFF / 1000)} mil caracteres]`;
+    return semSegredo(texto);
+}
+function lerTexto(p) {
+    try { const b = fs.readFileSync(p); return b.includes(0) ? '[arquivo binário]' : b.toString('utf8'); } catch { return ''; }
+}
+
+function pedidoDeRevisao({ pedido, diff }) {
+    return 'Você é o revisor. Outra IA de código (o PrimoCode) acabou de fazer a mudança abaixo para o pedido da pessoa. '
+        + 'Revise SÓ LENDO: não edite arquivo e não rode nada que mude o projeto. '
+        + 'Procure bug, o que o pedido pediu e ficou faltando, e risco (segurança, dado perdido). '
+        + 'Responda em português do Brasil, simples, pra quem nunca programou: uma lista curta, do mais grave ao menos grave, '
+        + 'com o arquivo (e a linha, quando der). Se estiver tudo certo, responda só: NADA A CORRIGIR.\n\n'
+        + `PEDIDO DA PESSOA:\n${semSegredo(pedido)}\n\nA MUDANÇA:\n${diff}`;
+}
+const semProblema = (texto) => /NADA A CORRIGIR/i.test(texto) && String(texto).trim().length < 200;
+const pedidoDeConserto = (nome, revisao) => `A revisão do ${nome} achou isto no que você acabou de fazer. `
+    + `Corrija só o que for problema de verdade; o que não for, diga em uma frase por quê.\n\n${revisao}`;
+
+// As opções conferidas no --help da versão instalada, uma vez por sessão.
+const conferidas = new Map();
+function conferirOpcoes(nome, { caminho, rodar = require('child_process').spawnSync } = {}) {
+    if (conferidas.has(nome)) return conferidas.get(nome);
+    const p = PARCEIROS[nome];
+    const r = rodar(caminho || p.bin, p.ajuda, { encoding: 'utf8', timeout: 20000, env: ambiente() });
+    const ajuda = `${r.stdout || ''}${r.stderr || ''}`;
+    const falta = p.precisa.filter((x) => !ajuda.includes(x));
+    const erro = falta.length ? `O ${p.titulo} instalado não tem ${falta.join(', ')} no --help, e eu não rodo com opção adivinhada. Atualize ele (${p.instalar}).` : null;
+    conferidas.set(nome, erro);
+    return erro;
+}
+
+/** O ambiente do parceiro: o da pessoa, sem as variáveis do PrimoCode (o token da conta não sai daqui). */
+function ambiente() {
+    const env = { ...process.env };
+    for (const k of Object.keys(env)) if (/^PRIMOCODE_/.test(k)) delete env[k];
+    return env;
+}
+
+/* Uma linha do stream-json do claude → o que mostrar ao vivo, e o resultado final. */
+function lerEvento(linha) {
+    let ev;
+    try { ev = JSON.parse(linha); } catch { return { mostrar: linha }; }
+    if (ev.type === 'result') return { fim: String(ev.result || '') };
+    if (ev.type !== 'assistant' || !ev.message || !Array.isArray(ev.message.content)) return {};
+    const partes = ev.message.content.map((b) => (b.type === 'text' ? b.text
+        : b.type === 'tool_use' ? `${b.name} ${(b.input && (b.input.file_path || b.input.pattern || b.input.command || b.input.path)) || ''}`.trim() : '')).filter(Boolean);
+    return { mostrar: partes.join(' ') };
+}
+
+/**
+ * Roda o parceiro sem tela, na pasta `dir`, com prazo. As linhas dele saem ao
+ * vivo por `linha`. → { ok, texto } ou { ok: false, erro }.
+ */
+function rodar(nome, modo, { prompt, dir, linha = () => {}, prazo = PRAZO[modo], spawn = require('child_process').spawn, caminho, conferir = conferirOpcoes } = {}) {
+    const p = PARCEIROS[nome];
+    const args = p[modo](prompt, dir);
+    if (args.some((a) => PULA_PERMISSAO.test(a))) return Promise.resolve({ ok: false, erro: 'opção que pula a permissão do parceiro: recusado' });
+    const semOpcao = conferir(nome, { caminho });
+    if (semOpcao) return Promise.resolve({ ok: false, erro: semOpcao });
+    return new Promise((resolve) => {
+        let filho;
+        try {
+            filho = spawn(caminho || p.bin, args, { cwd: dir, env: ambiente(), stdio: [p.stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
+        } catch (e) { resolve({ ok: false, erro: `Não consegui abrir o ${p.titulo}: ${e.message}` }); return; }
+        let saida = '', final = null, resto = '', ultimoErro = '', estourou = false;
+        const relogio = setTimeout(() => { estourou = true; try { filho.kill('SIGTERM'); } catch { /* já saiu */ } }, prazo);
+        const mostrar = (t) => { for (const l of String(t || '').split('\n')) if (l.trim()) linha(require('./ui').stripAnsi(l).slice(0, 200)); };
+        filho.stdout.on('data', (d) => {
+            resto += d.toString();
+            const linhas = resto.split('\n');
+            resto = linhas.pop();
+            for (const l of linhas) {
+                if (p.formato === 'stream-json') { const ev = lerEvento(l); if (ev.fim !== undefined) final = ev.fim; mostrar(ev.mostrar); } else { saida += `${l}\n`; mostrar(l); }
+            }
+        });
+        filho.stderr.on('data', (d) => { const t = d.toString().trim(); if (t) { ultimoErro = t.split('\n').pop(); mostrar(t); } });
+        if (p.stdin) filho.stdin.end(prompt);
+        filho.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, erro: `Não consegui abrir o ${p.titulo}: ${e.message}` }); });
+        filho.on('close', (codigo) => {
+            clearTimeout(relogio);
+            if (resto) { if (p.formato === 'stream-json') { const ev = lerEvento(resto); if (ev.fim !== undefined) final = ev.fim; } else saida += resto; }
+            if (estourou) return resolve({ ok: false, erro: `O ${p.titulo} passou de ${Math.round(prazo / 60000)} min e eu parei ele.` });
+            const texto = require('./ui').stripAnsi(final !== null ? final : saida).trim();
+            if (codigo !== 0 && !texto) return resolve({ ok: false, erro: `O ${p.titulo} saiu com erro (código ${codigo})${ultimoErro ? `: ${ultimoErro.slice(0, 160)}` : ''}.` });
+            resolve({ ok: true, texto });
+        });
+    });
+}
+
+/* ── O PARCEIRO FAZ, NUMA CÓPIA ──────────────────────────────────────
+ * `/team claude faz <pedido>`: o parceiro trabalha numa cópia do projeto (um
+ * git worktree, quando é git; senão uma cópia da pasta), nunca no projeto. O
+ * PrimoCode mede o que mudou, mostra, passa cada arquivo pelo portão dele
+ * (lib/perigo.js) e só aplica com o "sim" da pessoa. O .env não vai pra cópia. */
+
+const IDENTIDADE = ['-c', 'user.name=PrimoCode', '-c', 'user.email=primocode@local'];
+const FORA_DA_COPIA = /(^|[/\\])(node_modules|\.git)([/\\]|$)/;
+
+const real = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+
+function copiarArquivo(de, para) {
+    fs.mkdirSync(path.dirname(para), { recursive: true });
+    fs.copyFileSync(de, para);
+}
+
+/** → { pasta (onde o parceiro roda), raizCopia, aplicarEm, base (a árvore de antes), git, limpar() } */
+function prepararCopia(pastaDoProjeto) {
+    const dir = real(pastaDoProjeto);   // o git devolve o caminho real (/private/var no macOS)
+    const raizCopia = fs.mkdtempSync(path.join(require('os').tmpdir(), 'primocode-team-'));
+    if (ehGit(dir)) {
+        const raiz = git(dir, ['rev-parse', '--show-toplevel']).trim();
+        git(raiz, ['worktree', 'add', '--detach', raizCopia, 'HEAD']);
+        const limpar = () => { try { git(raiz, ['worktree', 'remove', '--force', raizCopia]); } catch { fs.rmSync(raizCopia, { recursive: true, force: true }); } };
+        try {
+            // O que ainda não tem commit também é do projeto: entra na cópia.
+            const sujo = git(raiz, ['diff', 'HEAD', '--binary']);
+            if (sujo.trim()) git(raizCopia, ['apply', '--binary', '-'], { input: sujo });
+            for (const r of git(raiz, ['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean)) {
+                if (!ARQUIVO_SECRETO.test(r)) copiarArquivo(path.join(raiz, r), path.join(raizCopia, r));
+            }
+            git(raizCopia, ['add', '-A']);
+            const base = git(raizCopia, ['write-tree']).trim();
+            return { pasta: path.join(raizCopia, path.relative(raiz, dir)), raizCopia, aplicarEm: raiz, base, git: true, limpar };
+        } catch (e) { limpar(); throw e; }
+    }
+    fs.cpSync(dir, raizCopia, { recursive: true, filter: (src) => { const r = path.relative(dir, src); return !FORA_DA_COPIA.test(r) && !ARQUIVO_SECRETO.test(r); } });
+    git(raizCopia, ['init', '-q']);
+    git(raizCopia, ['add', '-A']);
+    const base = git(raizCopia, ['write-tree']).trim();
+    return { pasta: raizCopia, raizCopia, aplicarEm: dir, base, git: false, limpar: () => fs.rmSync(raizCopia, { recursive: true, force: true }) };
+}
+
+/** O que o parceiro mudou na cópia: { patch, arquivos: [{ status: 'A' | 'M' | 'D', caminho }] }. */
+function mudancasDaCopia(copia) {
+    git(copia.raizCopia, ['add', '-A']);
+    const patch = git(copia.raizCopia, ['diff', '--cached', '--binary', '--no-renames', copia.base]);
+    const arquivos = git(copia.raizCopia, ['diff', '--cached', '--name-status', '--no-renames', copia.base]).split('\n').filter(Boolean)
+        .map((l) => { const [st, caminho] = l.split('\t'); return { status: st[0], caminho }; });
+    return { patch, arquivos };
+}
+
+/** Cada arquivo passa pelo portão, como se o PrimoCode fosse escrever (ou apagar). → as recusas, [] = pode. */
+async function passarPeloPortao(arquivos, { projectDir: pasta, aplicarEm, modo, estado, perguntar }) {
+    const perigo = require('./perigo.js');
+    const projectDir = real(pasta);
+    const recusas = [];
+    for (const a of arquivos) {
+        const rel = path.relative(projectDir, path.join(aplicarEm, a.caminho));
+        const [nome, args] = a.status === 'D' ? ['run_shell', { command: `rm ${JSON.stringify(rel)}` }] : ['write_file', { path: rel }];
+        const r = await perigo.portao(estado, { modo, nome, args, projectDir, perguntar });
+        if (!r.ok) recusas.push(`${a.caminho}: ${r.motivo || r.error}`);
+    }
+    return recusas;
+}
+
+/** Aplica o patch no projeto. Confere antes: patch que não encaixa não mexe em nada. */
+function aplicar(copia, patch) {
+    try {
+        git(copia.aplicarEm, ['apply', '--check', '--binary', '-'], { input: patch });
+        git(copia.aplicarEm, ['apply', '--binary', '-'], { input: patch });
+        return { ok: true };
+    } catch (e) { return { ok: false, erro: 'a mudança não encaixa no projeto como ele está agora (alguém mexeu nele no meio). Nada foi aplicado.' }; }
+}
+
+const pedidoDeFazer = (pedido) => 'Faça o pedido abaixo nesta pasta. Ela é uma cópia do projeto: o PrimoCode mostra o que você mudou '
+    + 'antes de aplicar. Não faça commit, não instale nada fora desta pasta e não mexa fora dela. '
+    + `No fim, diga em português do Brasil, em poucas frases, o que fez.\n\nPEDIDO:\n${semSegredo(pedido)}`;
+
+module.exports = { PARCEIROS, NOMES, PULA_PERMISSAO, achar, instalados, entender, status,
+    semSegredo, ehGit, diffDaVez, pedidoDeRevisao, semProblema, pedidoDeConserto, conferirOpcoes, lerEvento, rodar, PRAZO,
+    prepararCopia, mudancasDaCopia, passarPeloPortao, aplicar, pedidoDeFazer };

package/lib/tools.js

@@ -413,6 +413,22 @@ function trechosParecidos(conteudo, alvo, quantas = 8) {
 
 // Edição cirúrgica: troca um trecho exato em vez de reescrever o arquivo.
 // É o que impede o agente de reescrever 800 linhas para mudar uma.
+/* ── O ARQUIVO MUDOU DESDE QUE O AGENTE LEU ──────────────────────────────
+ * O agente lê, pensa, e edita em cima do que leu. Se a pessoa (ou o servidor de dev, ou outro agente)
+ * mexeu no arquivo no meio, a edição apagava o trabalho dela sem aviso. Guardamos a impressão (sha1)
+ * do que o agente viu por último — na leitura e nas próprias escritas — e recusamos editar por cima
+ * de uma versão que ele não viu. Arquivo nunca lido aqui passa (o old_string já confere o trecho). */
+const crypto = require('crypto');
+const VISTOS = new Map();
+const impressao = (texto) => crypto.createHash('sha1').update(texto).digest('hex');
+const marcarVisto = (filePath, texto) => { VISTOS.set(filePath, impressao(texto)); };
+function mudouPorFora(filePath, atual) {
+    const visto = VISTOS.get(filePath);
+    if (!visto || visto === impressao(atual)) return null;
+    return { ok: false, error: 'O arquivo mudou desde a última vez que você leu (alguém editou por fora). Nada foi escrito.',
+        comoResolver: `leia de novo com read_file("${path.basename(filePath)}") e refaça a edição em cima do que está lá agora.` };
+}
+
 function editFile({ path: rawPath, old_string, new_string, replace_all }, projectDir) {
     const filePath = resolveInProject(rawPath, projectDir);
     if (!fs.existsSync(filePath)) return { ok: false, error: `Arquivo não existe: ${rawPath}` };
@@ -420,6 +436,8 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     if (old_string === new_string) return { ok: false, error: 'old_string e new_string são iguais' };
 
     const original = fs.readFileSync(filePath, 'utf-8');
+    const mudou = mudouPorFora(filePath, original);
+    if (mudou) return mudou;
     const ocorrencias = original.split(old_string).length - 1;
 
     // Não bateu letra por letra: o casador frouxo (lib/casar.js) acha o
@@ -455,6 +473,7 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
             : original.replace(old_string, () => new_string ?? '');
 
     fs.writeFileSync(filePath, atualizado, 'utf-8');
+    marcarVisto(filePath, atualizado);
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -472,35 +491,51 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     };
 }
 
+/* O que volta ao modelo passa por um teto de ~6 mil caracteres de JSON (summarizeForModel, lib/act.js).
+   Antes a leitura devolvia até 40 mil e o teto cortava calado: o modelo via ~90 linhas de um arquivo de 600,
+   com "truncado: false", e editava às cegas o resto. Agora a leitura cabe no teto e diz até onde veio. */
+const TETO_LEITURA = 5000;
+function recortar(todas, inicio, maxLinhas) {
+    const linhas = [];
+    let tam = 0;
+    for (let i = inicio; i < todas.length && linhas.length < maxLinhas; i++) {
+        const l = `${i + 1}\t${todas[i]}`;
+        const t = JSON.stringify(l).length - 1;   // o custo dela dentro do JSON (aspas, \n escapado)
+        if (linhas.length && tam + t > TETO_LEITURA) break;
+        linhas.push(l.length > TETO_LEITURA ? l.slice(0, TETO_LEITURA) + '…(linha cortada)' : l);
+        tam += t;
+    }
+    return { content: linhas.join('\n'), de: inicio + 1, ate: inicio + linhas.length };
+}
+
 function readFile({ path: rawPath, offset, limit }, projectDir) {
     const filePath = resolverParaLer(rawPath, projectDir);
     const bruto = fs.readFileSync(filePath, 'utf-8');
+    marcarVisto(filePath, bruto);
     const todas = bruto.split('\n');
 
-    // Sem recorte pedido: devolve o começo, avisando que cortou.
-    if (offset == null && limit == null) {
-        const truncado = bruto.length > 40000;
-        return {
-            ok: true,
-            content: truncado ? bruto.slice(0, 40000) : bruto,
-            linhas: todas.length,
-            bytes: bruto.length,
-            truncado,
-            dica: truncado ? 'Use offset/limit para ler o resto.' : undefined,
-        };
+    // Cabe inteiro: vem inteiro, do jeito que está.
+    if (offset == null && limit == null && JSON.stringify(bruto).length <= TETO_LEITURA) {
+        return { ok: true, content: bruto, linhas: todas.length, bytes: bruto.length, truncado: false };
     }
 
     /* Arquivo pequeno vem INTEIRO, mesmo pedido aos pedaços: o modelo lia um
        app.js de 393 linhas de 50 em 50, cada pedaço uma ida ao servidor
-       (teste da loja, 01/10). Inteiro, uma vez, custa menos. */
-    if (todas.length <= 400 && bruto.length <= 40000) {
-        return { ok: true, content: todas.map((l, i) => `${i + 1}\t${l}`).join('\n'), linhas: todas.length, bytes: bruto.length,
-            inteiro: true, dica: 'arquivo pequeno: veio inteiro, com o número das linhas — não precisa ler de novo' };
+       (teste da loja, 01/10). Inteiro, uma vez, custa menos — se couber. */
+    const inteiro = recortar(todas, 0, todas.length);
+    if (inteiro.ate === todas.length) {
+        return { ok: true, content: inteiro.content, linhas: todas.length, bytes: bruto.length, inteiro: true,
+            dica: 'veio inteiro, com o número das linhas — não precisa ler de novo' };
     }
-    const inicio = Math.max(0, (offset || 1) - 1);
-    const fim = Math.min(todas.length, inicio + (limit || 200));
-    const recorte = todas.slice(inicio, fim).map((l, i) => `${inicio + i + 1}\t${l}`).join('\n');
-    return { ok: true, content: recorte, linhas: todas.length, de: inicio + 1, ate: fim, bytes: bruto.length };
+    const inicio = Math.min(Math.max(0, (offset || 1) - 1), Math.max(0, todas.length - 1));
+    const pedido = Math.max(1, Number(limit) || 200);
+    const r = recortar(todas, inicio, pedido);
+    const resto = r.ate < todas.length;
+    return {
+        ok: true, content: r.content, linhas: todas.length, de: r.de, ate: r.ate, bytes: bruto.length,
+        truncado: resto,
+        ...(resto ? { proximoOffset: r.ate + 1, dica: `vieram as linhas ${r.de}–${r.ate} de ${todas.length} (o teto de uma leitura). Continue com read_file offset=${r.ate + 1}, ou use grep pra achar o trecho.` } : {}),
+    };
 }
 
 // ── multi_edit: várias trocas no mesmo arquivo, em ordem, tudo-ou-nada ────
@@ -510,6 +545,8 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
     if (!Array.isArray(edits) || !edits.length) return { ok: false, error: 'edits (lista) é obrigatório' };
 
     let conteudo = fs.readFileSync(filePath, 'utf-8');
+    const mudou = mudouPorFora(filePath, conteudo);
+    if (mudou) return mudou;
     const original = conteudo;
     const linhasAntes = conteudo.split('\n').length;
     let substituicoes = 0;
@@ -539,6 +576,7 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
     }
 
     fs.writeFileSync(filePath, conteudo, 'utf-8');
+    marcarVisto(filePath, conteudo);
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -637,8 +675,10 @@ async function despachar(name, args, ctx) {
                 // tela o que foi perdido.
                 let antes = '';
                 if (!created) { try { antes = fs.readFileSync(filePath, 'utf-8'); } catch { antes = ''; } }
+                if (!created) { const mudou = mudouPorFora(filePath, antes); if (mudou) return mudou; }
                 fs.mkdirSync(path.dirname(filePath), { recursive: true });
                 fs.writeFileSync(filePath, content, 'utf-8');
+                marcarVisto(filePath, content);
                 return {
                     ok: true, created,
                     path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -672,12 +712,35 @@ async function despachar(name, args, ctx) {
                 const r = grepFiles({ ...args, glob: b.padrao }, b.raiz);
                 return b.outra && r && r.ok !== false ? { ...r, pasta: b.raiz } : r;
             }
-            case 'run_shell':
+            case 'run_shell': {
+                /* `primocode kit …` (lib/kits.js) roda aqui dentro: a tela de gosto e a de referências abrem
+                   deste processo (no app, pela linha de protocolo do stderr dele), e o render fala no terminal. */
+                const kit = await require('./kits.js').doShell(args.command, { projectDir,
+                    abrirVideo: process.stdout.isTTY && process.env.PRIMOCODE_APP !== '1' ? (arq) => { try { openInBrowser(arq); } catch { /* sem navegador */ } } : null,
+                    aoFalar: (t) => { try { process.stdout.write(require('./ui.js').c.muted(`  ⎿ ${t}`) + '\n'); } catch { /* sem terminal */ } } });
+                if (kit) return kit;
                 // Dentro da cerca (lib/sandbox.js); desligada ou sem mecanismo cai no exec de sempre.
-                return sandbox.executar(args.command, { projectDir, timeout: args.timeout_ms || 60000,
+                const prazo = Number(args.timeout_ms) || 60000;
+                const r = await sandbox.executar(args.command, { projectDir, timeout: prazo,
                     env: ambienteLimpo(process.env, permitidasNoShell()) });
+                // morto pelo prazo: sem isto parecia um erro do código ("code 1", saída vazia) e o modelo "consertava" o que não quebrou
+                if (r && r.ok === false && r.killed) {
+                    const quanto = prazo >= 1000 ? `${String(+(prazo / 1000).toFixed(1)).replace('.', ',')} s` : `${prazo} ms`;
+                    return { ...r, error: `passou do prazo de ${quanto} e foi parado (não é erro do código). Comando longo (build, install, servidor, testes lentos): rode com run_background e leia com background_output, ou passe timeout_ms maior.` };
+                }
+                return r;
+            }
             case 'run_in_new_terminal':
                 return runInNewTerminal(args.command, args.cwd || projectDir);
+            /* Em segundo plano, com a saída legível (lib/fundo.js). Mesmo env
+               filtrado do run_shell: o servidor de dev não herda as chaves. */
+            case 'run_background':
+                return require('./fundo').iniciar(args.command, { projectDir,
+                    env: ambienteLimpo(process.env, permitidasNoShell()) });
+            case 'background_output':
+                return require('./fundo').saida(args.id, { desde: args.desde });
+            case 'stop_background':
+                return require('./fundo').parar(args.id);
             case 'open_in_browser': {
                 const alvo = /^https?:\/\//i.test(args.target || '')
                     ? args.target