primocode 10.17.0 → 10.19.0

package/lib/afirmacoes.js

@@ -0,0 +1,56 @@
+/**
+ * afirmacoes.js — o "pronto" que diz ter mudado um arquivo que ninguém mexeu.
+ *
+ * O resumo do finish é o que a pessoa lê. "Atualizei o auth.js e corrigi o teste" com o auth.js intacto é a
+ * mentira que mais custa: ela confia e segue. Aqui: os arquivos que o resumo diz ter criado/editado/corrigido,
+ * conferidos contra o que a tarefa escreveu (tools) ou o que mudou no disco desde que ela começou (um `sed -i`,
+ * um gerador). Puro, menos o stat.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const VERBO = /\b(editei|alterei|atualizei|criei|corrigi|consertei|mudei|modifiquei|escrevi|adicionei|removi|refatorei|reescrevi|ajustei|implementei|updated|edited|created|modified|changed|fixed|added|wrote|rewrote|refactored|implemented)\b/i;
+const ARQ = /`?((?:[\w@.-]+\/)*[\w@-][\w@.-]*\.(?:js|mjs|cjs|ts|tsx|jsx|py|md|json|css|scss|html|go|rs|java|rb|php|ya?ml|toml|sh|sql|vue|svelte|txt))`?/gi;
+
+/** Os caminhos que o resumo diz ter mudado: os que aparecem na mesma frase, depois de um verbo de mudança. */
+function alegados(resumo) {
+    const out = new Set();
+    for (const frase of String(resumo || '').split(/(?<=[.!?;])\s+|\n+/)) {
+        const m = VERBO.exec(frase);
+        if (!m) continue;
+        const depois = frase.slice(m.index);
+        let a;
+        ARQ.lastIndex = 0;
+        while ((a = ARQ.exec(depois))) out.add(a[1].replace(/^\.\//, ''));
+    }
+    return [...out];
+}
+
+/** Dos alegados, os que a tarefa não tocou e que não mudaram no disco desde `desde` (ms). */
+function semMudanca(resumo, { tocados = new Set(), pasta = process.cwd(), desde = 0 } = {}) {
+    const nomesTocados = new Set([...tocados].map((p) => path.basename(p)));
+    const relTocados = new Set([...tocados].map((p) => path.relative(pasta, p).split(path.sep).join('/')));
+    return alegados(resumo).filter((a) => {
+        if (relTocados.has(a) || nomesTocados.has(path.basename(a))) return false;
+        try { if (fs.statSync(path.resolve(pasta, a)).mtimeMs >= desde - 1000) return false; } catch { /* não existe: alegou e não há */ }
+        return true;
+    });
+}
+
+/* "os testes passam", "todos os testes passaram", "tests pass", "build passou": a afirmação de prova */
+const DIZ_QUE_PASSOU = /\b((os |todos os )?testes? (passa|passam|passou|passaram|est[aã]o passando|verdes?|ok)|(all )?tests? (pass|passes|passed|passing|are green)|(o )?build (passa|passou|ok)|build (passes|passed))\b/i;
+const NEGA = /\b(n[aã]o|nenhum|sem|not|no|without|couldn't|could not|didn't|did not)\b[^.]{0,40}\b(test|teste|build)/i;
+
+/** O resumo diz que o teste passou, e o registro da tarefa não prova: null se está tudo certo, senão o motivo. */
+function testeSemProva(resumo, testes = []) {
+    const t = String(resumo || '');
+    if (!DIZ_QUE_PASSOU.test(t) || NEGA.test(t)) return null;
+    if (!testes.length) return 'nenhum teste rodou nesta tarefa';
+    const ultimo = testes[testes.length - 1];
+    if (ultimo && ultimo.ok === false) return `o último teste (\`${String(ultimo.comando || '').replace(/ · pelo PrimoCode$/, '')}\`) falhou`;
+    return null;
+}
+
+module.exports = { alegados, semMudanca, testeSemProva };

package/lib/agendar.js

@@ -0,0 +1,124 @@
+/**
+ * agendar.js — o /schedule: um pedido que roda sozinho, em dia e hora marcados.
+ *
+ *   /schedule "toda segunda às 9h" resuma o que mudou na semana
+ *   /schedule                      lista        /schedule off 2   tira o 2
+ *
+ *   entender(frase)          → { ok, dias, hora, minuto, texto } | { ok: false }   (dias: null = todo dia, ou [1..5])
+ *   separar(texto)           → { quando, pedido }     ("frase entre aspas" + o resto)
+ *   criar(dir, quando, pedido, deps) / listar(dir) / remover(dir, n, deps)
+ *
+ * No Mac vira um agente do launchd (~/Library/LaunchAgents) que roda `primocode -p "<pedido>"` na pasta do projeto
+ * e escreve o resultado em .primocode/agendados/<data>.md. Sem ninguém olhando: o modo -p recusa o que precisaria
+ * de um "sim" da pessoa. Em outro sistema o pedido fica salvo e a tela diz que o relógio automático é só do Mac.
+ * Os testes trocam `rodar` (launchctl) e `casa`: nada do sistema muda de verdade.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const DIAS = { domingo: 0, segunda: 1, terca: 2, terça: 2, quarta: 3, quinta: 4, sexta: 5, sabado: 6, sábado: 6 };
+const NOME_DIA = ['domingo', 'segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado'];
+const ARQ = (dir) => path.join(dir, '.primocode', 'agendados.json');
+const PASTA = (dir) => path.join(dir, '.primocode', 'agendados');
+const PREFIXO_LABEL = 'ai.primocode.agendado.';
+
+/** "toda segunda às 9h", "todo dia às 18:30", "dias úteis 8h30", "às 7h" → quando roda. */
+function entender(frase) {
+    const f = String(frase || '').toLowerCase().replace(/-feira/g, '').replace(/\s+/g, ' ').trim();
+    const h = f.match(/(?:\bàs?\b|\bas\b)?\s*(\d{1,2})\s*(?:h|:)\s*(\d{2})?\s*(?:h|horas?)?\s*$/) || f.match(/(?:às?|as)\s+(\d{1,2})\s*$/);
+    if (!h) return { ok: false };
+    const hora = Number(h[1]), minuto = h[2] ? Number(h[2]) : 0;
+    if (hora > 23 || minuto > 59) return { ok: false };
+    const resto = f.slice(0, h.index).replace(/(?:^|\s)(?:às?|as)\s*$/, '').trim();
+    let dias = null, rotulo = 'todo dia';
+    if (/dias? [uú]teis|segunda a sexta/.test(resto)) { dias = [1, 2, 3, 4, 5]; rotulo = 'dias úteis'; }
+    else if (/fim de semana|finais? de semana/.test(resto)) { dias = [6, 0]; rotulo = 'fim de semana'; }
+    else if (/todo dia|todos os dias|diari|^$/.test(resto)) { /* todo dia */ }
+    else {
+        const achados = [...new Set((resto.match(/\b(domingo|segunda|ter[cç]a|quarta|quinta|sexta|s[aá]bado)s?\b/g) || []).map((d) => DIAS[d.replace(/s$/, '')]))];
+        if (!achados.length) return { ok: false };
+        dias = achados; rotulo = 'toda ' + achados.map((d) => NOME_DIA[d]).join(' e ');
+    }
+    return { ok: true, dias, hora, minuto, texto: `${rotulo} às ${hora}h${minuto ? String(minuto).padStart(2, '0') : ''}` };
+}
+
+/** `"frase" pedido` (aspas retas ou curvas) ou, sem aspas, "toda segunda às 9h pedido…". */
+function separar(texto) {
+    const t = String(texto || '').trim();
+    let m = t.match(/^["“'‘]([^"”'’]+)["”'’]\s*(.*)$/s);
+    if (m) return { quando: m[1].trim(), pedido: m[2].trim() };
+    m = t.match(/^((?:todo dia|todos os dias|toda \S+|todas as \S+|dias [uú]teis|fim de semana)?\s*(?:às?|as)\s*\d{1,2}(?:\s*(?:h|:)\s*\d{0,2}\s*h?)?)\s+(.+)$/is);
+    return m ? { quando: m[1].trim(), pedido: m[2].trim() } : { quando: '', pedido: t };
+}
+
+function listar(dir) {
+    try { const j = JSON.parse(fs.readFileSync(ARQ(dir), 'utf8')); return Array.isArray(j) ? j : []; } catch { return []; }
+}
+function gravar(dir, lista) {
+    fs.mkdirSync(path.dirname(ARQ(dir)), { recursive: true });
+    fs.writeFileSync(ARQ(dir), JSON.stringify(lista, null, 2) + '\n');
+}
+
+const labelDe = (dir, id) => `${PREFIXO_LABEL}${crypto.createHash('sha1').update(path.resolve(dir)).digest('hex').slice(0, 8)}.${id}`;
+const plistDe = (casa, label) => path.join(casa, 'Library', 'LaunchAgents', `${label}.plist`);
+const xml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const aspas = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+
+/** O script que o relógio roda: lê o pedido de um arquivo (nada de aspas dentro de aspas) e anexa ao .md do dia. */
+function scriptDo(dir, a, { node = process.execPath, bin = path.join(__dirname, '..', 'bin', 'primocode.js') } = {}) {
+    return ['#!/bin/sh', `# /schedule ${a.id}: ${a.quando}`, `cd ${aspas(path.resolve(dir))} || exit 1`, 'mkdir -p .primocode/agendados',
+        'SAIDA=".primocode/agendados/$(date +%Y-%m-%d).md"',
+        `{ printf '\\n## %s — %s\\n\\n' "$(date +%H:%M)" ${aspas(a.pedido.slice(0, 80))}; ${aspas(node)} ${aspas(bin)} -p "$(cat .primocode/agendados/${a.id}.pedido.txt)"; } >> "$SAIDA" 2>&1`, ''].join('\n');
+}
+
+function plistDo(label, script, q) {
+    const horarios = (q.dias || [null]).map((d) => `        <dict>${d === null ? '' : `<key>Weekday</key><integer>${d}</integer>`}<key>Hour</key><integer>${q.hora}</integer><key>Minute</key><integer>${q.minuto}</integer></dict>`).join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n    <key>Label</key><string>${xml(label)}</string>\n    <key>ProgramArguments</key><array><string>/bin/sh</string><string>${xml(script)}</string></array>\n    <key>StartCalendarInterval</key>\n    <array>\n${horarios}\n    </array>\n</dict></plist>\n`;
+}
+
+const lancar = (cmd, args) => { const r = spawnSync(cmd, args, { encoding: 'utf8' }); return { status: r.status, stderr: r.stderr || '' }; };
+
+/** Salva o pedido e, no Mac, liga o relógio. Devolve { ok, item, relogio, erro? }. */
+function criar(dir, quando, pedido, { plataforma = process.platform, casa = os.homedir(), rodar = lancar, uid = process.getuid ? process.getuid() : 501, node, bin } = {}) {
+    const q = entender(quando);
+    if (!q.ok) return { ok: false, erro: 'Não entendi quando. Me diga o dia e a hora, por exemplo: /schedule "toda segunda às 9h" resuma as novidades.' };
+    if (!String(pedido || '').trim()) return { ok: false, erro: 'Faltou o pedido. Exemplo: /schedule "todo dia às 8h" veja se o site está no ar.' };
+    const lista = listar(dir);
+    const id = String(Math.max(0, ...lista.map((x) => Number(x.id) || 0)) + 1);
+    const item = { id, quando: q.texto, pedido: pedido.trim(), dias: q.dias, hora: q.hora, minuto: q.minuto, criado: new Date().toISOString() };
+    fs.mkdirSync(PASTA(dir), { recursive: true });
+    fs.writeFileSync(path.join(PASTA(dir), `${id}.pedido.txt`), item.pedido + '\n');
+    const script = path.join(PASTA(dir), `${id}.sh`);
+    fs.writeFileSync(script, scriptDo(dir, item, { node, bin }), { mode: 0o755 });
+    let relogio = false;
+    if (plataforma === 'darwin') {
+        const label = labelDe(dir, id), plist = plistDe(casa, label);
+        fs.mkdirSync(path.dirname(plist), { recursive: true });
+        fs.writeFileSync(plist, plistDo(label, script, q));
+        const r = rodar('launchctl', ['bootstrap', `gui/${uid}`, plist]);
+        if (r.status !== 0) { try { fs.rmSync(plist); } catch { /* */ } return { ok: false, erro: `O relógio do Mac não aceitou: ${(r.stderr || '').trim().split('\n')[0] || 'erro desconhecido'}` }; }
+        relogio = true;
+    }
+    gravar(dir, [...lista, item]);
+    return { ok: true, item, relogio };
+}
+
+function remover(dir, n, { casa = os.homedir(), rodar = lancar, uid = process.getuid ? process.getuid() : 501 } = {}) {
+    const lista = listar(dir);
+    const i = lista.findIndex((x, k) => x.id === String(n) || String(k + 1) === String(n));
+    if (i < 0) return { ok: false, erro: `Não achei o agendamento ${n}. /schedule mostra a lista.` };
+    const [item] = lista.splice(i, 1);
+    const label = labelDe(dir, item.id);
+    rodar('launchctl', ['bootout', `gui/${uid}/${label}`]);
+    for (const f of [plistDe(casa, label), path.join(PASTA(dir), `${item.id}.sh`), path.join(PASTA(dir), `${item.id}.pedido.txt`)]) { try { fs.rmSync(f); } catch { /* já não existia */ } }
+    gravar(dir, lista);
+    return { ok: true, item };
+}
+
+module.exports = { entender, separar, criar, listar, remover, labelDe, plistDo, scriptDo, NOME_DIA };

package/lib/backup-banco.js

@@ -0,0 +1,121 @@
+/**
+ * backup-banco.js — a cópia do banco que o PrimoCode faz sozinho antes de apagar dado.
+ *
+ *   achar(projectDir)              → ['app.db', …]                 (arquivos SQLite do projeto, de verdade: confere o cabeçalho)
+ *   fazer(projectDir, agora?)      → { pasta, criado, arquivos } | null   (copia pra .primocode/backup/AAAA-MM-DD_HHMMSS/)
+ *   listar(projectDir)             → [backup], o mais novo primeiro
+ *   pendentes(projectDir)          → [backup] que ainda não foram restaurados
+ *   desde(projectDir, iso)         → os pendentes feitos a partir de `iso` (os do pedido que o /undo volta)
+ *   restaurar(projectDir, backup)  → [{ arquivo, acao }]            (copia de volta e marca como restaurado)
+ *
+ * O portão (lib/perigo.js) pergunta antes de DROP, TRUNCATE, DELETE sem WHERE e afins, e o checkpoint do /undo só vê a
+ * pasta: um banco que o .gitignore esconde não voltava. Aqui, quando a pessoa deixa o comando rodar, o arquivo de
+ * banco vai pra uma pasta de cópias ANTES, e o /undo devolve. Sem comando novo: quem nunca programou não precisa saber.
+ * Só SQLite (arquivo na pasta): Postgres e Supabase moram fora do computador e a cópia não alcança.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const EXT = /\.(db|sqlite3?|db3)$/i;
+const PULAR = new Set(['node_modules', '.git', '.primocode', '.venv', 'venv', '__pycache__', '.next', 'dist', 'build']);
+const COMPANHEIROS = ['-wal', '-shm', '-journal'];
+const MAX_PROFUNDIDADE = 6;
+const MAX_BYTES = 500 * 1024 * 1024;   // mais que isso, copiar a cada comando travaria o terminal
+const GUARDAR = 5;                     // quantas cópias ficam; as mais velhas saem
+
+const pastaDe = (projectDir) => path.join(projectDir, '.primocode', 'backup');
+
+function ehSqlite(arquivo) {
+    try {
+        const fd = fs.openSync(arquivo, 'r');
+        try { const b = Buffer.alloc(16); fs.readSync(fd, b, 0, 16, 0); return b.toString('latin1') === 'SQLite format 3\0'; }
+        finally { fs.closeSync(fd); }
+    } catch { return false; }
+}
+
+function achar(projectDir) {
+    const raiz = path.resolve(projectDir), achados = [];
+    const andar = (dir, fundo) => {
+        let itens = [];
+        try { itens = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const d of itens) {
+            const abs = path.join(dir, d.name);
+            if (d.isDirectory()) { if (fundo < MAX_PROFUNDIDADE && !PULAR.has(d.name)) andar(abs, fundo + 1); }
+            else if (d.isFile() && EXT.test(d.name) && ehSqlite(abs)) achados.push(path.relative(raiz, abs));
+        }
+    };
+    andar(raiz, 0);
+    return achados.sort();
+}
+
+function manifestDe(pasta) {
+    try { return { pasta, ...JSON.parse(fs.readFileSync(path.join(pasta, 'manifest.json'), 'utf8')) }; } catch { return null; }
+}
+
+function listar(projectDir) {
+    let nomes = [];
+    try { nomes = fs.readdirSync(pastaDe(projectDir)); } catch { return []; }
+    return nomes.sort().reverse().map((n) => manifestDe(path.join(pastaDe(projectDir), n))).filter(Boolean);
+}
+
+const doisDigitos = (n) => String(n).padStart(2, '0');
+function rotuloDaData(d) {
+    return `${d.getFullYear()}-${doisDigitos(d.getMonth() + 1)}-${doisDigitos(d.getDate())}_${doisDigitos(d.getHours())}${doisDigitos(d.getMinutes())}${doisDigitos(d.getSeconds())}`;
+}
+
+function fazer(projectDir, agora = new Date()) {
+    const raiz = path.resolve(projectDir);
+    const bancos = achar(raiz);
+    if (!bancos.length) return null;
+    const tamanho = bancos.reduce((s, b) => { try { return s + fs.statSync(path.join(raiz, b)).size; } catch { return s; } }, 0);
+    if (tamanho > MAX_BYTES) return null;
+    let pasta = path.join(pastaDe(raiz), rotuloDaData(agora)), n = 1;
+    while (fs.existsSync(pasta)) pasta = path.join(pastaDe(raiz), `${rotuloDaData(agora)}-${++n}`);
+    const copiados = [];
+    for (const b of bancos) {
+        for (const sufixo of ['', ...COMPANHEIROS]) {
+            const de = path.join(raiz, b + sufixo);
+            if (!fs.existsSync(de)) continue;
+            const para = path.join(pasta, b + sufixo);
+            fs.mkdirSync(path.dirname(para), { recursive: true });
+            fs.copyFileSync(de, para);
+            if (!sufixo) copiados.push(b);
+        }
+    }
+    const manifest = { criado: agora.toISOString(), arquivos: copiados, restaurado: false };
+    fs.writeFileSync(path.join(pasta, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    for (const velho of listar(raiz).slice(GUARDAR)) fs.rmSync(velho.pasta, { recursive: true, force: true });
+    return { pasta, ...manifest };
+}
+
+const pendentes = (projectDir) => listar(projectDir).filter((b) => !b.restaurado);
+
+function desde(projectDir, iso) {
+    const t = new Date(iso).getTime();
+    return pendentes(projectDir).filter((b) => new Date(b.criado).getTime() >= t - 1000);
+}
+
+function restaurar(projectDir, backup) {
+    const raiz = path.resolve(projectDir), feitos = [];
+    for (const b of backup.arquivos) {
+        for (const sufixo of ['', ...COMPANHEIROS]) {
+            const de = path.join(backup.pasta, b + sufixo), para = path.join(raiz, b + sufixo);
+            try {
+                if (fs.existsSync(de)) { fs.mkdirSync(path.dirname(para), { recursive: true }); fs.copyFileSync(de, para); if (!sufixo) feitos.push({ arquivo: b, acao: 'voltou' }); }
+                else if (sufixo && fs.existsSync(para)) fs.rmSync(para);   // o -wal de hoje não combina com o banco de ontem
+            } catch (e) { if (!sufixo) feitos.push({ arquivo: b, acao: 'falhou', erro: e.message }); }
+        }
+    }
+    // marca este e tudo o que veio depois: o que se restaurou é de antes deles, não sobra nada pra voltar
+    const t = new Date(backup.criado).getTime();
+    for (const b of pendentes(raiz)) {
+        if (new Date(b.criado).getTime() < t) continue;
+        try { fs.writeFileSync(path.join(b.pasta, 'manifest.json'), JSON.stringify({ criado: b.criado, arquivos: b.arquivos, restaurado: true }, null, 2)); } catch { /* sem marca, só oferece de novo */ }
+    }
+    return feitos;
+}
+
+module.exports = { achar, fazer, listar, pendentes, desde, restaurar, pastaDe };

package/lib/boas-vindas.js

@@ -116,7 +116,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar(c.err('  Sua conta ainda não tem um plano.'));
         mostrar(c.muted('  O PrimoCode é por assinatura, a partir de ') + c.brand('R$ 69,90/mês') + c.muted('.'));
         mostrar('');
-        mostrar(c.dim('  Veja os planos e assine: ') + c.brand('/planos'));
+        mostrar(c.dim('  Veja os planos e assine: ') + c.brand('/account plans'));
         mostrar(c.dim('  Já assinou? ') + c.brand('/account')
             + c.dim(' atualiza o plano nesta máquina.'));
         mostrar('');
@@ -127,7 +127,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
        Estar logado é o estado NORMAL do produto — anunciar isso toda vez é
        ruído, e ruído no primeiro instante empurra para baixo o que importa,
        que é a caixa de digitar. O selo do plano continua existindo onde quem
-       procura vai olhar (/account, /status); a abertura só diz alguma coisa
+       procura vai olhar (/account, /doctor status); a abertura só diz alguma coisa
        quando há algo a resolver. */
 
     /* Não há etapa 3. O que vinha aqui era a escolha do provedor de IA, e
@@ -143,7 +143,8 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
        a pessoa e o cursor. */
     if (primeira) {
         mostrar('');
-        mostrar(c.muted('  Tudo pronto. Pode pedir a primeira coisa.'));
+        mostrar(c.muted('  Tudo pronto. Pode pedir qualquer coisa, escrevendo normal, como numa conversa.'));
+        mostrar(c.muted('  Nunca programou? Digite ') + c.brand('/new') + c.muted(' e crie seu primeiro app com 3 perguntas.'));
     }
     mostrar('');
     return { liberado: true, plano, primeira, perguntou: false };

package/lib/catalogo.js

@@ -42,8 +42,14 @@ const GRUPOS = [
         itens: [
             { tool: 'run_shell',           escreve: false, faz: 'roda comando e devolve a saída',
               args: 'command. timeout_ms (opcional, número, padrão 60000).' },
-            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal para o que fica de pé (servidor, watch)',
+            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal quando a PESSOA quer ver o servidor ou o watch rodando',
               args: 'command. cwd (opcional): pasta onde rodar.' },
+            { tool: 'run_background',      escreve: false, faz: 'se o comando fica de pé (servidor, watch), roda em segundo plano e deixa você ler a saída depois',
+              args: 'command. Devolve um id; confira que subiu com background_output.' },
+            { tool: 'background_output',   escreve: false, faz: 'lê a saída de uma tarefa em segundo plano (só o que é novo desde a última leitura)',
+              args: 'id. desde (opcional, número): o "ate" da leitura anterior.' },
+            { tool: 'stop_background',     escreve: false, faz: 'para uma tarefa em segundo plano',
+              args: 'id.' },
         ],
     },
     {
@@ -303,7 +309,7 @@ const SHELL_QUE_CRIA = /\b(mkdir|touch|git\s+clone|npm\s+(init|create)|npx\s+(cr
 
 function criaProjeto(tool, args) {
     if (CRIAM_PROJETO.has(tool)) return true;
-    if (tool === 'run_shell' || tool === 'run_in_new_terminal') {
+    if (tool === 'run_shell' || tool === 'run_in_new_terminal' || tool === 'run_background') {
         return SHELL_QUE_CRIA.test(String((args && (args.command || args.comando)) || ''));
     }
     return false;

package/lib/chave-exposta.js

@@ -0,0 +1,61 @@
+/**
+ * chave-exposta.js — a chave que ficou escrita no código do app, antes do "pronto".
+ *
+ *   procurar(arquivos, { raiz }) → [{ arquivo, linha, tipo }]     (lê só os arquivos que a tarefa mexeu)
+ *   tipoDaLinha(texto)           → nome do tipo, ou null          (puro)
+ *
+ * Quem nunca programou cola a chave da OpenAI ou do Stripe direto no script.js, e o site publicado entrega a chave
+ * pra qualquer visitante (aibuilderclub.com, "vibe coding for non-technical founders" [VERIFICAR]). O .env é o lugar
+ * certo e não conta. A chave do Firebase (AIza…) fica de fora de propósito: ela é pública por natureza, vive no front.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TIPOS = [
+    ['chave da OpenAI ou parecida', /\bsk-(?:proj-|live-|test-)?[A-Za-z0-9_-]{20,}/],
+    ['chave secreta do Stripe', /\b(?:rk|sk)_live_[A-Za-z0-9]{16,}/],
+    ['token do GitHub', /\bgh[pousr]_[A-Za-z0-9]{20,}/],
+    ['chave da AWS', /\bAKIA[0-9A-Z]{16}\b/],
+    ['token do Slack', /\bxox[abprs]-[A-Za-z0-9-]{10,}/],
+    // o bloco inteiro, do BEGIN ao END: só o cabeçalho deixava o corpo da chave no /exportar (achado da revisão)
+    ['chave privada', /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/],
+    // senha/segredo com VALOR literal longo entre aspas: `token = getToken()` não é segredo
+    // o nome pode vir dentro de outro (DB_PASSWORD, JWT_SECRET, clientSecret, OPENAI_API_KEY) e entre aspas no JSON
+    // ("password": "…"); o \b do começo deixava passar os nomes mais comuns (achado da revisão)
+    ['senha ou segredo escrito no código', /(?:senha|password|passwd|secret|api[_-]?key|token)\w*["']?\s*[:=]\s*["'](?!AIza)[^"'\s]{16,}["']/i],
+];
+const FORA = /(^|\/)\.env(\.|$)|(^|\/)(node_modules|\.git)\//;   // o .env é o lugar certo
+
+function tipoDaLinha(texto) {
+    for (const [nome, re] of TIPOS) if (re.test(String(texto || ''))) return nome;
+    return null;
+}
+
+function procurar(arquivos, { raiz = process.cwd() } = {}) {
+    const achados = [];
+    for (const abs of new Set(arquivos || [])) {
+        const rel = path.relative(raiz, abs) || abs;
+        if (FORA.test(rel)) continue;
+        let texto;
+        try { if (fs.statSync(abs).size > 1024 * 1024) continue; texto = fs.readFileSync(abs, 'utf8'); } catch { continue; }
+        texto.split('\n').some((l, i) => {
+            const tipo = tipoDaLinha(l);
+            if (tipo) achados.push({ arquivo: rel, linha: i + 1, tipo });
+            return achados.length >= 5;
+        });
+        if (achados.length >= 5) break;
+    }
+    return achados;
+}
+
+/** O que a pessoa e o modelo leem. Puro. */
+function relato(achados) {
+    if (!achados || !achados.length) return '';
+    const onde = achados.slice(0, 3).map((a) => `${a.arquivo} (linha ${a.linha}: ${a.tipo})`).join('; ');
+    return `ficou uma chave escrita no código: ${onde}. Quem abrir o site ou o app consegue ler e usar essa chave.`;
+}
+
+module.exports = { procurar, tipoDaLinha, relato, TIPOS };

package/lib/checkpoint-git.js

@@ -43,6 +43,8 @@ const TEMPO_MAXIMO_MS = 20000;
 const IGNORAR_SEMPRE = [
     'node_modules/', '.git/', 'dist/', 'build/', '.next/', '.nuxt/', '.turbo/',
     '.cache/', 'coverage/', '__pycache__/', '.venv/', 'venv/', '*.log', '.DS_Store',
+    // a cópia do banco e as travas do /lock moram na pasta: voltar a foto não pode levá-las embora
+    '.primocode/backup/', '.primocode/travados.json',
 ];
 
 let _temGit = null;
@@ -103,7 +105,7 @@ function preparar(gitDir, workTree) {
     git(gitDir, workTree, ['init', '-q']);
     fs.mkdirSync(path.join(gitDir, 'info'), { recursive: true });
     fs.writeFileSync(path.join(gitDir, 'info', 'exclude'),
-        '# o que o /desfazer nunca fotografa (o .gitignore do projeto vale também)\n'
+        '# o que o /undo nunca fotografa (o .gitignore do projeto vale também)\n'
         + IGNORAR_SEMPRE.join('\n') + '\n');
     // Os hooks de exemplo do template não rodam, mas não precisam ficar lá.
     fs.rmSync(path.join(gitDir, 'hooks'), { recursive: true, force: true });
@@ -178,10 +180,11 @@ function podarVazias(workTree, rel) {
 /** Volta o disco para a foto `sha`: o que mudou ou sumiu volta, o que nasceu
     depois sai. Só se apaga o que a sombra VIU nascer — arquivo ignorado
     (node_modules, .gitignore, grande demais) nunca entra no index, então nunca
-    aparece como A, então nunca é apagado. */
-function restaurar(gitDir, workTree, sha) {
+    aparece como A, então nunca é apagado. Com `so`, volta só aqueles. */
+function restaurar(gitDir, workTree, sha, { so = null } = {}) {
     const feitos = [];
-    const lista = mudancas(gitDir, workTree, sha);
+    // `so`: só estes caminhos relativos (o "/desfazer fora": o resto do pedido fica)
+    const lista = mudancas(gitDir, workTree, sha).filter((m) => !so || so.has(m.rel));
     const statusDe = new Map(lista.map((m) => [m.rel, m.status]));
     const voltar = lista.filter((m) => m.status !== 'A').map((m) => m.rel);
     // Em lotes: um projeto com milhares de mudanças estouraria a linha de comando.

package/lib/checkpoint.js

@@ -108,7 +108,7 @@ function iniciar(pedido, projectDir) {
 
 /** Fecha o pedido. Com foto, anota o que mudou (é o que o `/desfazer lista`
     mostra) — e, se nada mudou, o checkpoint some: uma pergunta não pode
-    ocupar o lugar de um pedido que o /desfazer deveria voltar. */
+    ocupar o lugar de um pedido que o /undo deveria voltar. */
 function encerrar() {
     const g = atual && atual.git;
     atual = null;
@@ -116,6 +116,7 @@ function encerrar() {
     try {
         const m = foto.mudancas(g.gitDir, g.projectDir, g.manifest.git.sha);
         if (!m.length && !g.manifest.arquivos.length) { fs.rmSync(g.dir, { recursive: true, force: true }); return; }
+        esquecerRefazer(g.projectDir);   // mudou depois do /undo: refazer agora apagaria trabalho novo
         g.manifest.mudancas = m;
         gravarManifest(g);
     } catch { /* sem a conta, a lista calcula na hora */ }
@@ -127,6 +128,7 @@ function guardarOriginal(cp, abs) {
     if (cp.manifest.arquivos.some((a) => a.caminho === abs)) return;
     const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
     const item = { caminho: abs, existia };
+    if (cp.manifest.arquivos.length === 0) esquecerRefazer(cp.manifest.projectDir);
     if (existia) {
         item.copia = String(cp.manifest.arquivos.length);
         fs.copyFileSync(abs, path.join(cp.dir, item.copia));
@@ -211,11 +213,12 @@ function previa(projectDir, n = 1) {
 
 /** Desfaz os N pedidos mais recentes, do mais novo para o mais velho — assim,
     se dois pedidos mexeram no mesmo arquivo, o que sobra é o original do mais
-    antigo. Cada checkpoint desfeito é apagado: o próximo /desfazer volta mais
+    antigo. Cada checkpoint desfeito é apagado: o próximo /undo volta mais
     um pedido, em vez de repetir o mesmo. */
 function desfazer(projectDir, n = 1) {
     const feitos = new Map();   // um arquivo, uma linha: vale a última ação
     const anotar = (caminho, acao, erro) => { feitos.delete(caminho); feitos.set(caminho, erro ? { caminho, acao, erro } : { caminho, acao }); };
+    guardarRefazer(projectDir, n);
     for (const cp of lista(projectDir).slice(0, Math.max(1, n))) {
         if (cp.git) {
             try {
@@ -243,7 +246,121 @@ function desfazer(projectDir, n = 1) {
     return [...feitos.values()];
 }
 
+/** Volta só ALGUNS arquivos do pedido mais novo (o "/desfazer fora" do
+    lib/escopo.js): o resto do pedido fica, e o checkpoint também — um
+    /undo depois ainda volta o pedido inteiro. O /redo de antes é
+    esquecido: ele passaria por cima do que voltou agora. */
+function desfazerArquivos(projectDir, caminhos) {
+    const cp = lista(projectDir)[0];
+    if (!cp || !caminhos || !caminhos.length) return [];
+    const quer = new Set(caminhos.map((c) => path.resolve(cp.projectDir, c)));
+    const feitos = [];
+    esquecerRefazer(projectDir);
+    if (cp.git) {
+        const so = new Set([...quer].map((abs) => path.relative(cp.projectDir, abs)));
+        try {
+            for (const f of foto.restaurar(path.join(path.dirname(cp.dir), 'git'), cp.projectDir, cp.git.sha, { so })) {
+                feitos.push({ ...f, caminho: path.join(cp.projectDir, f.rel) });
+            }
+        } catch (e) { feitos.push({ caminho: cp.projectDir, acao: 'falhou', erro: e.message }); }
+    }
+    for (const a of cp.arquivos || []) {
+        if (!quer.has(a.caminho) || feitos.some((f) => f.caminho === a.caminho)) continue;
+        try {
+            if (a.existia) { fs.copyFileSync(path.join(cp.dir, a.copia), a.caminho); feitos.push({ caminho: a.caminho, acao: 'restaurado' }); }
+            else { fs.rmSync(a.caminho, { force: true }); feitos.push({ caminho: a.caminho, acao: 'apagado' }); }
+        } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+    }
+    return feitos;
+}
+
+/* O /refazer: antes de o /desfazer voltar os arquivos, o estado de AGORA de
+   cada um vai para <projeto>/refazer/. Só o último /undo tem volta, e só
+   enquanto nada mudou depois — um pedido novo que mexe no disco apaga a volta,
+   senão o /redo passaria por cima do trabalho novo. */
+function pastaRefazer(projectDir) { return path.join(pastaDoProjeto(projectDir), 'refazer'); }
+
+function esquecerRefazer(projectDir) {
+    try { if (projectDir) fs.rmSync(pastaRefazer(projectDir), { recursive: true, force: true }); } catch {}
+}
+
+function guardarRefazer(projectDir, n) {
+    const dir = pastaRefazer(projectDir);
+    esquecerRefazer(projectDir);
+    const pedidos = lista(projectDir).slice(0, Math.max(1, n)).map((cp) => cp.pedido);
+    const arquivos = [];
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        for (const { caminho } of previa(projectDir, n)) {
+            const existia = fs.existsSync(caminho) && fs.statSync(caminho).isFile();
+            const item = { caminho, existia };
+            if (existia) { item.copia = String(arquivos.length); fs.copyFileSync(caminho, path.join(dir, item.copia)); }
+            arquivos.push(item);
+        }
+        fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify({ quando: Date.now(), pedidos, arquivos }));
+    } catch { /* sem a volta do refazer, o desfazer ainda funciona */ }
+}
+
+/** O que o /refazer devolveria (null = nada a refazer). */
+function refazerDisponivel(projectDir) {
+    try { return JSON.parse(fs.readFileSync(path.join(pastaRefazer(projectDir), 'manifest.json'), 'utf8')); }
+    catch { return null; }
+}
+
+/** Devolve os arquivos ao estado de antes do último /desfazer. */
+function refazer(projectDir) {
+    const m = refazerDisponivel(projectDir);
+    if (!m) return [];
+    const dir = pastaRefazer(projectDir);
+    const feitos = [];
+    for (const a of m.arquivos) {
+        try {
+            if (a.existia) {
+                fs.mkdirSync(path.dirname(a.caminho), { recursive: true });
+                fs.copyFileSync(path.join(dir, a.copia), a.caminho);
+                feitos.push({ caminho: a.caminho, acao: 'refeito' });
+            } else {
+                fs.rmSync(a.caminho, { force: true });
+                feitos.push({ caminho: a.caminho, acao: 'apagado' });
+            }
+        } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+    }
+    esquecerRefazer(projectDir);
+    return feitos;
+}
+
+/* O /conferir e o /voltar: quando o projeto passa nos testes, o checkpoint
+   mais novo (o do último pedido, já feito) ganha `funcionava` no manifest.
+   Pedidos que vierem depois ficam com índice menor; `desfazer(indice)` desfaz
+   exatamente esses, e o projeto volta a como estava logo após o pedido marcado. */
+function marcarFuncionando(projectDir, como) {
+    const cp = lista(projectDir)[0];
+    if (!cp) return null;
+    try {
+        const arq = path.join(cp.dir, 'manifest.json');
+        const m = JSON.parse(fs.readFileSync(arq, 'utf8'));
+        m.funcionava = new Date().toISOString();
+        // COMO foi conferido ("npm test", "a página abriu"): o /voltar e a lista mostram, e "funcionava" sozinho não dizia
+        if (como) { m.funcionava_como = String(como).slice(0, 60); cp.funcionava_como = m.funcionava_como; }
+        /* O pedido EM ANDAMENTO tem o manifest em memória, e o encerrar() regrava ele por cima do disco: sem isto, a
+           marca que o teste do agente põe antes do "pronto" sumia no fim do pedido (achado da revisão de 24/10). */
+        for (const vivo of [atual && atual.git, atual && atual.arq]) {
+            if (vivo && vivo.dir === cp.dir && vivo.manifest) { vivo.manifest.funcionava = m.funcionava; if (m.funcionava_como) vivo.manifest.funcionava_como = m.funcionava_como; }
+        }
+        fs.writeFileSync(arq, JSON.stringify(m, null, 2));
+        cp.funcionava = m.funcionava;
+        return cp;
+    } catch { return null; }
+}
+
+/** O ponto mais novo marcado como funcionando: { indice, cp } (0 = o mais novo). */
+function ultimoQueFuncionava(projectDir) {
+    const cps = lista(projectDir);
+    const indice = cps.findIndex((cp) => cp.funcionava);
+    return indice < 0 ? null : { indice, cp: cps[indice] };
+}
+
 /** Qual jeito de guardar vale nesta pasta — o /desfazer lista conta à pessoa. */
 function modo(projectDir) { return podeFotografar(projectDir) ? 'foto' : 'arquivo'; }
 
-module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, previa, desfazer, modo, pastaDoProjeto };
+module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, previa, desfazer, desfazerArquivos, refazer, refazerDisponivel, marcarFuncionando, ultimoQueFuncionava, modo, pastaDoProjeto };