primocode 9.8.0-beta.5 → 9.8.0-beta.7

package/lib/app.js

@@ -98,6 +98,9 @@ function tipoDe(arquivo) {
  * @param {()=>void}                op.interromper para o que estiver rodando
  * @param {()=>object}              op.estado      { pasta, modo, esforco, projeto }
  * @param {string}                  op.versao
+ * @param {()=>string}              [op.pastaProjeto] liga a IDE (/ide) nesta pasta
+ * @param {'rc'|'ide'}              [op.abrirEm]      qual tela a janela abre
+ * @param {boolean}                 [op.semJanela]    só o servidor, sem abrir navegador
  */
 async function abrir(op) {
     const chave = crypto.randomBytes(16).toString('hex');
@@ -117,6 +120,13 @@ async function abrir(op) {
         }
     }
 
+    /* A IDE (lib/ide.js) mora neste mesmo servidor e fala pelo mesmo fluxo:
+       "um app ao invés de CLI, aí fica uma IDE e uma CLI". Só sobe quando
+       quem abriu diz qual é a pasta do projeto. */
+    const ide = op.pastaProjeto
+        ? require('./ide.js').montar({ pasta: op.pastaProjeto, emitir: (e, d) => emitir(e, d) })
+        : null;
+
     const pararEspelho = espelhar((pedaco) => {
         if (ehRuido(pedaco)) return;
         memoria.push(pedaco);
@@ -175,7 +185,11 @@ async function abrir(op) {
            /app.js sem parâmetro nenhum. A página vinha, ficava sem estilo e
            sem script, e o "app bonito" era um formulário branco. */
         if (rota.startsWith('/api/')) {
-            const dada = url.searchParams.get('k') || req.headers['x-primo-chave'];
+            // A prévia da IDE leva a chave no CAMINHO (ver lib/ide.js): os
+            // arquivos que a página do projeto pede por endereço relativo não
+            // carregam query nenhuma.
+            const naPrevia = rota.match(/^\/api\/ide\/previa\/([0-9a-f]+)/);
+            const dada = (naPrevia && naPrevia[1]) || url.searchParams.get('k') || req.headers['x-primo-chave'];
             if (dada !== chave) {
                 res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
                 return res.end('chave inválida — abra a janela com o comando /app');
@@ -185,7 +199,13 @@ async function abrir(op) {
            127.0.0.1 sem preflight. Ela não saberia a chave, mas o cinto e o
            suspensório custam três linhas. */
         const origem = req.headers.origin;
-        if (origem && !origem.startsWith(`http://127.0.0.1:${servidor.__porta}`)
+        /* A exceção é a prévia da IDE: ela roda num iframe sandbox de origem
+           opaca, e o navegador manda `Origin: null` até num <script
+           type="module">. Só GET e só nas rotas da prévia, que apenas LEEM o
+           projeto — nenhuma delas dá ordem ao agente. */
+        const previaOpaca = origem === 'null' && req.method === 'GET'
+            && rota.startsWith('/api/ide/previa/');
+        if (origem && !previaOpaca && !origem.startsWith(`http://127.0.0.1:${servidor.__porta}`)
             && !origem.startsWith(`http://localhost:${servidor.__porta}`)) {
             res.writeHead(403).end();
             return;
@@ -254,6 +274,8 @@ async function abrir(op) {
             return res.end(JSON.stringify(r));
         }
 
+        if (ide && await ide.atender(req, res, url)) return;
+
         if (rota === '/api/estado') {
             res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
             return res.end(JSON.stringify(Object.assign({ versao: op.versao }, op.estado())));
@@ -262,7 +284,7 @@ async function abrir(op) {
         // Estáticos. `basename` corta qualquer "../" antes de virar caminho:
         // este servidor fala com o disco do usuário e não pode servir o que
         // estiver fora da pasta do aplicativo.
-        const nome = rota === '/' ? 'index.html' : path.basename(rota);
+        const nome = rota === '/' ? 'index.html' : rota === '/ide' ? 'ide.html' : path.basename(rota);
         const arquivo = path.join(WEB, nome);
         fs.readFile(arquivo, (erro, dados) => {
             if (erro) { res.writeHead(404).end('não encontrado'); return; }
@@ -274,11 +296,22 @@ async function abrir(op) {
     const porta = await escutar(servidor, PORTA_PADRAO);
     servidor.__porta = porta;
     const url = `http://127.0.0.1:${porta}/?k=${chave}`;
+    const urlIde = `http://127.0.0.1:${porta}/ide?k=${chave}`;
 
-    const janela = await abrirJanela(url);
+    // `semJanela` é para o teste (e para quem só quer o endereço): sem ele,
+    // rodar a suíte abriria uma janela de verdade na tela de quem roda.
+    const janela = op.semJanela ? { modo: 'nenhum' }
+        : await abrirJanela(op.abrirEm === 'ide' && ide ? urlIde : url);
     return {
-        url, porta, chave, servidor, janela,
-        fechar() { try { pararEspelho(); } catch {} try { servidor.close(); } catch {} },
+        url, urlIde: ide ? urlIde : null, porta, chave, servidor, janela,
+        fechar() {
+            try { pararEspelho(); } catch {}
+            try { if (ide) ide.fechar(); } catch {}
+            try { servidor.close(); } catch {}
+            // SSE abertos seguram o close() para sempre; a janela é que
+            // fechou, então as conexões dela também.
+            for (const r of ouvintes) { try { r.end(); } catch {} }
+        },
     };
 }
 
@@ -345,6 +378,8 @@ function abrirJanela(url) {
             const filho = execFile(exe, [
                 `--app=${url}`,
                 `--user-data-dir=${perfil}`,
+                // Sem Keychain: ver SEM_KEYCHAIN em lib/browser.js.
+                ...require('./browser.js').SEM_KEYCHAIN,
                 '--window-size=1180,820',
                 '--no-first-run',
                 '--no-default-browser-check',

package/lib/browser.js

@@ -177,6 +177,16 @@ function httpPutJson(url, timeoutMs = 3000) {
 
 function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
 
+/* O Chrome NUNCA mexe no Keychain do Mac (nem no cofre de senhas do Linux).
+ *   "Para de fazer coisas de tentar armazenar chave no Chrome, eu apaguei o
+ *    Chrome." (24/09/2026)
+ * Cada perfil novo do PrimoCode (o do agente, o revisor escondido, a janela
+ * do /rc e do /ide) fazia o Chrome pedir o "Chrome Safe Storage" ao sistema —
+ * uma janela de senha do Mac, do nada, várias vezes. O PrimoCode não guarda
+ * senha em navegador nenhum: estas duas flags fazem o Chrome usar um cofre de
+ * mentira e texto simples no próprio perfil, sem tocar no do sistema. */
+const SEM_KEYCHAIN = ['--use-mock-keychain', '--password-store=basic'];
+
 // ---- WebSocket client mínimo (RFC 6455) para CDP ----------------
 // Suficiente pra CDP (mensagens curtas, texto UTF-8, um cliente por página).
 class MiniWebSocket {
@@ -393,6 +403,7 @@ async function ensureChromeRunning() {
     const args = [
         `--remote-debugging-port=${DEBUG_PORT}`,
         `--user-data-dir=${PROFILE_DIR}`,
+        ...SEM_KEYCHAIN,
         '--no-first-run',
         '--no-default-browser-check',
         '--disable-features=Translate',
@@ -810,6 +821,7 @@ function close() {
 let PORTA_REVISOR = Number(process.env.PRIMOCODE_CDP_PORT_REVISOR || 0);
 let perfilRevisor = null;
 let revisorChild = null;
+let saidaRegistrada = false;
 
 function lerPortaDoPerfil(perfil) {
     try {
@@ -819,7 +831,20 @@ function lerPortaDoPerfil(perfil) {
     } catch { return 0; }
 }
 
-async function subirRevisor() {
+/* Quem está subindo o revisor AGORA. O agente liga o navegador escondido
+   adiantado, quando escreve a primeira página (lib/act.js), e a conferência
+   do "pronto" chama isto de novo — às vezes com o primeiro ainda subindo.
+   Sem esta promessa em comum, a segunda chamada via PORTA_REVISOR zerada e
+   lançava um SEGUNDO Chrome, que ficava órfão. */
+let subindoRevisor = null;
+
+function subirRevisor() {
+    if (subindoRevisor) return subindoRevisor;
+    subindoRevisor = _subirRevisor().finally(() => { subindoRevisor = null; });
+    return subindoRevisor;
+}
+
+async function _subirRevisor() {
     if (PORTA_REVISOR) {
         try {
             const v = await httpGetJson(`http://127.0.0.1:${PORTA_REVISOR}/json/version`, 800);
@@ -839,6 +864,7 @@ async function subirRevisor() {
         // Zero: o Chrome escolhe uma porta livre e escreve qual no perfil.
         `--remote-debugging-port=${process.env.PRIMOCODE_CDP_PORT_REVISOR || 0}`,
         `--user-data-dir=${perfilRevisor}`,
+        ...SEM_KEYCHAIN,
         // Sempre invisível: é o pedido, e é o que separa este do navegador da
         // pessoa. Não há variável para ligar a janela aqui de propósito.
         '--headless=new', '--disable-gpu', '--disable-dev-shm-usage',
@@ -868,6 +894,17 @@ async function subirRevisor() {
     revisorChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
     revisorChild.on('error', () => {});
     revisorChild.unref();
+    /* O REVISOR MORRE COM O PROCESSO. Ele é `detached` + `unref` para não
+       segurar o CLI de pé — e por isso mesmo sobrevivia a ele: só o pipeline
+       (construir_app) chamava fecharRevisor, e toda sessão que conferiu uma
+       página deixava um Chrome invisível para trás. Medido em 24/09 nesta
+       máquina: 7 revisores órfãos somando ~2 GB de memória, um deles com 3
+       minutos de CPU. É o tipo de lentidão que a pessoa sente no computador
+       inteiro e não liga ao PrimoCode. */
+    if (!saidaRegistrada) {
+        saidaRegistrada = true;
+        process.on('exit', () => { try { fecharRevisor(); } catch { /* saindo */ } });
+    }
 
     const prazo = Date.now() + 15000;
     while (Date.now() < prazo) {
@@ -1098,6 +1135,44 @@ async function abrirEscondido(url) {
 /* O revisor é ferramenta de uma tarefa, não um processo que fica. Deixá-lo de
    pé come memória até a pessoa desligar o computador, e ele não é o navegador
    dela — ninguém sentiria falta nem saberia que existe para fechar. */
+/* LIGAR O REVISOR ANTES DA HORA — e não só ligar: navegar uma vez.
+ *
+ * Medido em 24/09, cada fase da conferência num Chrome recém-aberto:
+ * subir 313ms · abrir aba 24ms · canal 29ms · PRIMEIRA navegação 3.019ms ·
+ * assentar 1.200ms. Na segunda página, no mesmo Chrome, a navegação levou
+ * 4ms. O caro não é o processo, é a primeira ida à rede (o Chrome sobe o
+ * serviço de rede e o primeiro renderizador nela) — navegar para about:blank
+ * ou data: não aquece isso (a conferência seguinte continuou em ~2,1s);
+ * navegar para um http local aquece (caiu para 1.240ms, que é o assentar).
+ *
+ * Por isso isto abre uma aba num servidor de uma linha, em 127.0.0.1, e fecha.
+ * Uma vez por navegador: depois da primeira, não há o que aquecer. Nunca
+ * rejeita — aquecer é atalho, e quem confere de verdade tenta de novo e diz
+ * o que houve. */
+let aquecido = null;   // a porta do revisor que já foi aquecido
+let aquecendo = null;
+function aquecerRevisor() {
+    if (aquecendo) return aquecendo;
+    aquecendo = (async () => {
+        await subirRevisor();
+        if (aquecido && aquecido === PORTA_REVISOR) return true;
+        const srv = http.createServer((req, res) => {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<!doctype html><title>.</title>');
+        });
+        try {
+            await new Promise((ok, falhou) => { srv.once('error', falhou); srv.listen(0, '127.0.0.1', ok); });
+            const aba = await abaEscondida(`http://127.0.0.1:${srv.address().port}/`, { assentar: 0, prazoLoad: 10000 });
+            await aba.fechar();
+            aquecido = PORTA_REVISOR;
+            return true;
+        } finally {
+            try { srv.close(); } catch { /* já fechou */ }
+        }
+    })().catch(() => false).finally(() => { aquecendo = null; });
+    return aquecendo;
+}
+
 function fecharRevisor() {
     if (revisorChild && revisorChild.pid) {
         try { process.kill(-revisorChild.pid); } catch {
@@ -1116,8 +1191,9 @@ function fecharRevisor() {
 }
 
 module.exports = {
-    scriptDaSeta, verSeta,
+    SEM_KEYCHAIN,
+    scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
-    inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor,
+    inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor, subirRevisor, aquecerRevisor,
 };

package/lib/checkpoint-git.js

@@ -0,0 +1,218 @@
+/**
+ * checkpoint-git.js — a foto do projeto inteiro, num git que a pessoa não vê.
+ *
+ * O checkpoint por arquivo (lib/checkpoint.js) só enxerga o que passa por
+ * write_file/edit_file/multi_edit. Um `rm`, um `mv`, um `sed -i` ou um
+ * `npm run build` pelo run_shell mudam o disco sem avisar ninguém — e é
+ * justamente aí que "ele apagou meu site" acontece. A saída (a mesma ideia do
+ * Cline, escrita aqui do zero) é tirar uma foto do projeto INTEIRO no começo
+ * de cada pedido, num repositório git "sombra":
+ *
+ *   ~/.primocode/checkpoints/<projeto>-<hash>/git   ← GIT_DIR
+ *   a pasta do projeto                              ← GIT_WORK_TREE
+ *
+ * Por que um git à parte e não o .git do projeto: o repositório da pessoa é
+ * dela. Branch, index, stash e HEAD não podem mudar porque o agente tirou uma
+ * foto. Por isso TODO comando daqui passa --git-dir e --work-tree explícitos
+ * E as variáveis GIT_DIR/GIT_WORK_TREE — nunca há descoberta de repositório
+ * a partir da pasta, que acharia o .git da pessoa.
+ *
+ * Por que a config global fica de fora (GIT_CONFIG_GLOBAL=/dev/null): quem
+ * tem commit.gpgsign=true ou um core.hooksPath global veria o PrimoCode pedir
+ * a senha da chave GPG ou rodar hooks a cada pedido.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/** Maior que isso não entra na foto: vídeo exportado, dump de banco, zip.
+    A foto é de código e texto; binário grande encheria o disco da pessoa. */
+const LIMITE_BYTES = 20 * 1024 * 1024;
+/** Pasta com mais arquivos novos que isso na primeira foto provavelmente não
+    é um projeto (é Documentos, Downloads…). Aí fica o checkpoint por arquivo. */
+const MAX_ARQUIVOS = 20000;
+/** O pedido não pode ficar parado esperando a foto. */
+const TEMPO_MAXIMO_MS = 20000;
+
+/** O que nunca entra na foto, além do .gitignore do próprio projeto. São
+    coisas que se regeneram (npm install, build) ou que não são da pessoa. */
+const IGNORAR_SEMPRE = [
+    'node_modules/', '.git/', 'dist/', 'build/', '.next/', '.nuxt/', '.turbo/',
+    '.cache/', 'coverage/', '__pycache__/', '.venv/', 'venv/', '*.log', '.DS_Store',
+];
+
+let _temGit = null;
+/** Detectado uma vez por processo; o teste zera com _reiniciar(). */
+function temGit() {
+    if (process.env.PRIMOCODE_SEM_GIT === '1') return false;
+    if (_temGit === null) {
+        try {
+            const r = spawnSync('git', ['--version'], { encoding: 'utf8', timeout: 5000, windowsHide: true });
+            _temGit = r.status === 0 && /git version/.test(r.stdout || '');
+        } catch { _temGit = false; }
+    }
+    return _temGit;
+}
+function _reiniciar() { _temGit = null; }
+
+/** O ambiente limpo: nenhuma variável GIT_* herdada (um hook que chamou o
+    PrimoCode deixaria GIT_INDEX_FILE apontando para o index da pessoa). */
+function ambiente(gitDir, workTree) {
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) if (!/^GIT_/.test(k)) env[k] = v;
+    env.GIT_DIR = gitDir;
+    env.GIT_WORK_TREE = workTree;
+    env.GIT_CONFIG_NOSYSTEM = '1';
+    env.GIT_CONFIG_GLOBAL = os.devNull;
+    env.GIT_TERMINAL_PROMPT = '0';
+    env.GIT_OPTIONAL_LOCKS = '0';
+    return env;
+}
+
+function git(gitDir, workTree, args, { input } = {}) {
+    const r = spawnSync('git', [
+        `--git-dir=${gitDir}`, `--work-tree=${workTree}`, '--literal-pathspecs',
+        '-c', 'core.autocrlf=false', '-c', 'core.quotepath=false', '-c', 'core.fsmonitor=false',
+        '-c', 'commit.gpgsign=false', '-c', `core.hooksPath=${path.join(gitDir, 'sem-hooks')}`,
+        '-c', 'user.name=PrimoCode', '-c', 'user.email=desfazer@primocode.local',
+        '-c', 'advice.addEmbeddedRepo=false', '-c', 'core.safecrlf=false',
+        ...args,
+    ], { cwd: workTree, env: ambiente(gitDir, workTree), encoding: 'utf8', input,
+        timeout: TEMPO_MAXIMO_MS, maxBuffer: 64 * 1024 * 1024, windowsHide: true });
+    if (r.error) throw r.error;
+    if (r.status !== 0) throw new Error((r.stderr || '').trim() || `git ${args[0]} saiu com ${r.status}`);
+    return r.stdout;
+}
+
+/** Um processo morto no meio (timeout, Ctrl+C) deixa o index.lock para trás,
+    e dali em diante TODA foto falharia. Lock velho é lixo: sai. */
+function destravar(gitDir) {
+    const lock = path.join(gitDir, 'index.lock');
+    try { if (Date.now() - fs.statSync(lock).mtimeMs > 60000) fs.rmSync(lock, { force: true }); } catch {}
+}
+
+/** Cria o repositório sombra na primeira vez. Devolve false quando a pasta
+    não serve para foto (grande demais). */
+function preparar(gitDir, workTree) {
+    if (fs.existsSync(path.join(gitDir, 'HEAD'))) return true;
+    fs.mkdirSync(gitDir, { recursive: true });
+    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'
+        + 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 });
+    return true;
+}
+
+/** Arquivo novo grande demais vai para o exclude ANTES do add: o git não
+    sabe ignorar por tamanho, então listamos os não rastreados e medimos. */
+function excluirGrandes(gitDir, workTree, { primeira } = {}) {
+    const novos = git(gitDir, workTree, ['ls-files', '-z', '--others', '--exclude-standard']).split('\0').filter(Boolean);
+    if (primeira && novos.length > MAX_ARQUIVOS) return false;
+    const grandes = [];
+    for (const rel of novos) {
+        try { if (fs.statSync(path.join(workTree, rel)).size > LIMITE_BYTES) grandes.push(rel); } catch {}
+    }
+    if (grandes.length) {
+        // Âncora com "/" e caracteres especiais escapados: o padrão pega só ESTE arquivo.
+        const linhas = grandes.map((r) => '/' + r.replace(/([\\*?[\]!# ])/g, '\\$1'));
+        fs.appendFileSync(path.join(gitDir, 'info', 'exclude'), linhas.join('\n') + '\n');
+    }
+    return true;
+}
+
+/** Põe o estado atual do disco no index da sombra (só no dela). */
+function registrarEstado(gitDir, workTree, opcoes) {
+    destravar(gitDir);
+    if (excluirGrandes(gitDir, workTree, opcoes) === false) return false;
+    git(gitDir, workTree, ['add', '-A', '--ignore-errors', '--', '.']);
+    return true;
+}
+
+/** A foto do começo do pedido. Devolve o sha, ou null quando não deu (sem
+    git, pasta grande demais, erro) — quem chama cai no checkpoint por arquivo. */
+function fotografar(gitDir, workTree, mensagem) {
+    const primeira = !fs.existsSync(path.join(gitDir, 'HEAD'));
+    if (!preparar(gitDir, workTree)) return null;
+    if (!registrarEstado(gitDir, workTree, { primeira })) {
+        // Não é projeto: a sombra criada agora não serve e não pode ficar.
+        if (primeira) fs.rmSync(gitDir, { recursive: true, force: true });
+        return null;
+    }
+    git(gitDir, workTree, ['commit', '-q', '--allow-empty', '--no-verify', '-m', String(mensagem || 'pedido').slice(0, 500) || 'pedido']);
+    return git(gitDir, workTree, ['rev-parse', 'HEAD']).trim();
+}
+
+/** O que mudou da foto `sha` até o disco de agora: [{ rel, status }] com
+    status A (nasceu depois), M (mudou) ou D (sumiu). Renomear aparece como
+    D + A de propósito (--no-renames): desfazer é recriar um e apagar o outro. */
+function mudancas(gitDir, workTree, sha) {
+    registrarEstado(gitDir, workTree);
+    const saida = git(gitDir, workTree, ['diff', '--cached', '--no-renames', '--name-status', '-z', sha, '--']);
+    const partes = saida.split('\0').filter(Boolean);
+    const lista = [];
+    for (let i = 0; i + 1 < partes.length; i += 2) {
+        const status = partes[i][0] === 'T' ? 'M' : partes[i][0];
+        lista.push({ rel: partes[i + 1], status });
+    }
+    return lista;
+}
+
+/** Tira pastas que ficaram vazias depois de apagar o que nasceu no pedido
+    (quem criou `css/novo.css` espera que `css/` suma junto). Para na raiz. */
+function podarVazias(workTree, rel) {
+    let d = path.dirname(path.join(workTree, rel));
+    const raiz = path.resolve(workTree);
+    while (d.startsWith(raiz + path.sep)) {
+        try { if (fs.readdirSync(d).length) break; fs.rmdirSync(d); } catch { break; }
+        d = path.dirname(d);
+    }
+}
+
+/** 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) {
+    const feitos = [];
+    const lista = mudancas(gitDir, workTree, sha);
+    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.
+    for (let i = 0; i < voltar.length; i += 200) {
+        const lote = voltar.slice(i, i + 200);
+        try {
+            git(gitDir, workTree, ['checkout', sha, '--', ...lote]);
+            for (const rel of lote) feitos.push({ rel, acao: statusDe.get(rel) === 'D' ? 'recriado' : 'restaurado' });
+        } catch (e) { for (const rel of lote) feitos.push({ rel, acao: 'falhou', erro: e.message }); }
+    }
+    for (const m of lista.filter((x) => x.status === 'A')) {
+        try {
+            fs.rmSync(path.join(workTree, m.rel), { force: true });
+            podarVazias(workTree, m.rel);
+            feitos.push({ rel: m.rel, acao: 'apagado' });
+        } catch (e) { feitos.push({ rel: m.rel, acao: 'falhou', erro: e.message }); }
+    }
+    // O index da sombra volta a espelhar o disco, para a próxima comparação.
+    try { registrarEstado(gitDir, workTree); } catch {}
+    return feitos;
+}
+
+/** O arquivo está fora da foto (ignorado pelas regras)? Aí o checkpoint por
+    arquivo cobre — editar `dist/app.js` continua tendo volta. */
+function ignorado(gitDir, workTree, abs) {
+    const rel = path.relative(workTree, abs);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return true;
+    const r = spawnSync('git', [`--git-dir=${gitDir}`, `--work-tree=${workTree}`, 'check-ignore', '-q', '--no-index', '--', rel],
+        { cwd: workTree, env: ambiente(gitDir, workTree), timeout: 5000, windowsHide: true });
+    return r.status === 0;
+}
+
+module.exports = { IGNORAR_SEMPRE, LIMITE_BYTES, MAX_ARQUIVOS, temGit, _reiniciar,
+    fotografar, mudancas, restaurar, ignorado };