@fefsbenson/jarvis 1.1.0 → 1.3.0

package/bin/cli.js

@@ -12,7 +12,9 @@
  *
  * JARVIS · PRAGMA · by Felipe Brandão
  */
-import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync,
+         readFileSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { tmpdir } from 'node:os';
@@ -323,11 +325,452 @@ async function instalar(args) {
   return r.status ?? 0;
 }
 
+// ══════════════════════════════════════════════════════════════════
+//  UPDATE — traz a versão nova sem apagar o que o dono fez
+// ══════════════════════════════════════════════════════════════════
+
+/**
+ * O manifesto que a instalação grava: hash de cada arquivo COMO SAIU do
+ * pacote. É ele que torna a atualização possível sem escolher entre duas
+ * coisas ruins — apagar o trabalho do dono, ou nunca entregar correção.
+ *
+ * Sem manifesto (instalação anterior à v1.1.7) o update ainda funciona,
+ * mas não sabe o que foi alterado: aí ele preserva por precaução tudo que
+ * difere do pacote novo, e diz isso na tela.
+ */
+function lerManifesto(raiz) {
+  const f = join(raiz, '.claude', 'jarvis', 'instalacao-original.json');
+  if (!existsSync(f)) return null;
+  try {
+    const d = JSON.parse(readFileSync(f, 'utf8'));
+    return (d && d.arquivos) ? d : null;
+  } catch { return null; }
+}
+
+function hashDe(caminho) {
+  try {
+    return createHash('sha256').update(readFileSync(caminho)).digest('hex');
+  } catch { return null; }
+}
+
+/**
+ * Pastas que NUNCA se sobrescreve, porque são do dono por natureza:
+ * credenciais, memória do sistema, o trabalho dele, estado e registros.
+ * Isto não depende do manifesto — é contrato, e vale mesmo sem ele.
+ */
+const INTOCAVEIS = [
+  '.env', '.venv', 'node_modules', '.git',
+  'jarvis.config.yaml',
+  '.claude/settings.local.json',
+  '.claude/jarvis/',          // memória, estado, ponteiros
+  '.claude/sessions/',        // histórico de sessões
+  '.claude/mission-control/', // estado de missão e índices
+  '.claude/trash/',           // o que o dono mandou para a lixeira
+  'workspace/',               // o negócio do dono
+  'knowledge/business/', 'knowledge/personal/',
+  'knowledge/external/inbox/', // o material que o DONO ingere
+  'logs/', '.data/', 'artifacts/', 'processing/',
+  'outputs/', 'research/',    // L3 no directory-contract: produção do dono
+];
+
+/**
+ * Sufixos protegidos DENTRO de área do sistema.
+ *
+ * `agents/` é do pacote — AGENT.md, DNA-CONFIG.yaml e ACTIVATION.yaml vêm daqui
+ * e devem receber correção. Mas MEMORY.md e SOUL.md são a memória que o agente
+ * ACUMULA conversando com o dono: sobrescrevê-los apaga meses de uso.
+ *
+ * Medido no pacote 1.1.24: 91 arquivos nessa condição. Sem esta lista, um
+ * `npx jarvis update` os zeraria em silêncio — o dono só descobriria quando o
+ * agente esquecesse tudo o que sabia sobre ele.
+ */
+const SUFIXOS_DO_DONO = ['/MEMORY.md', '/SOUL.md'];
+
+/**
+ * Exceções DENTRO de pasta protegida: arquivos que o sistema mantém e o dono
+ * não escreve. Sem esta lista, `.claude/jarvis/` inteiro fica congelado — e o
+ * manifesto nunca se renova, então uma instalação antiga seguiria para sempre
+ * sem saber o que o dono alterou.
+ */
+const SEMPRE_ATUALIZA = ['VERSION', 'MANIFESTO-PACOTE.json', 'LICENSE'];
+
+const EXCECOES = [
+  '.claude/jarvis/instalacao-original.json',
+];
+
+function ehIntocavel(rel) {
+  const n = rel.split('\\').join('/');
+  if (EXCECOES.includes(n)) return false;
+  if (SUFIXOS_DO_DONO.some(s => n.endsWith(s))) return true;
+  return INTOCAVEIS.some(i => i.endsWith('/') ? n.startsWith(i) : n === i);
+}
+
+function listar(dir, base = dir, saida = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.name === 'node_modules' || e.name === '.git' ||
+        e.name === '__pycache__' || e.name === '.venv') continue;
+    const cheio = join(dir, e.name);
+    const rel = cheio.slice(base.length + 1).split('\\').join('/');
+    if (e.isDirectory()) listar(cheio, base, saida);
+    else saida.push(rel);
+  }
+  return saida;
+}
+
+/**
+ * Compara a instalação atual com o pacote novo e classifica cada arquivo.
+ *
+ * Os quatro casos, e por que cada um se resolve assim:
+ *
+ *   novo       — não existe aqui: entra.
+ *   igual      — o dono não mexeu E o pacote não mudou: nada a fazer.
+ *   atualiza   — o dono não mexeu e o pacote mudou: entra (é a correção).
+ *   preserva   — o dono MEXEU: fica o dele. É o ponto todo do manifesto;
+ *                sem ele, "atualizar" seria apagar o trabalho de alguém.
+ */
+/**
+ * O "motor": o que VEM DO PACOTE, por oposição ao que o dono produz.
+ *
+ * Numa instalação sem manifesto é a única forma de distinguir a correção
+ * chegando de uma edição do dono — e a chance de alguém ter editado um
+ * arquivo do sistema à mão é muito menor que a de ficar sem o conserto.
+ *
+ * A fronteira já foi estreita demais: cobria só hooks, scripts e core, e
+ * medido no pacote 1.1.24 isso deixava **4.642 arquivos sem correção** —
+ * 2.118 skills, 1.897 de conhecimento curado, 266 agentes, 73 rules. Uma
+ * instalação antiga atualizava e recebia quase nada: um update que parece
+ * seguro por não fazer nada.
+ *
+ * O que torna a fronteira larga SEGURA é o backup: tudo que entra por aqui
+ * e difere ganha `.antigo` ao lado (ver `aplicar`). Nada se perde sem volta.
+ *
+ * O que o dono produz nunca chega aqui — `ehIntocavel` roda antes e já tirou
+ * workspace, buckets business/personal, o inbox dele, outputs, research,
+ * estado, sessões, credenciais, e MEMORY.md/SOUL.md dos agentes.
+ */
+function ehDoMotor(rel) {
+  const n = rel.split('\\').join('/');
+  return n.startsWith('.claude/hooks/') ||
+         n.startsWith('.claude/scripts/') ||
+         n.startsWith('.claude/skills/') ||    // 2.118 arquivos
+         n.startsWith('.claude/rules/') ||     //    73
+         n.startsWith('.claude/commands/') ||
+         n.startsWith('.claude/get-shit-done/') ||
+         n.startsWith('core/') ||
+         n.startsWith('bin/') ||
+         n.startsWith('reference/') ||
+         n.startsWith('system/') ||
+         // conhecimento CURADO (L2): dna, dossiers, playbooks, sources, mmos.
+         // O inbox do dono já saiu antes, por ehIntocavel.
+         n.startsWith('knowledge/external/') ||
+         // definição do agente vem do pacote; MEMORY.md e SOUL.md dele não
+         // chegam aqui — ehIntocavel os barra antes.
+         n.startsWith('agents/') ||
+         n === 'install.py' ||
+         n === 'requirements.txt' ||
+         n === 'requirements-opcional.txt';
+}
+
+function planejar(raizAtual, raizNova, manifesto) {
+  const orig = manifesto ? manifesto.arquivos : null;
+  const plano = { novo: [], atualiza: [], preserva: [], igual: [], protegido: [] };
+
+  for (const rel of listar(raizNova)) {
+    if (ehIntocavel(rel)) { plano.protegido.push(rel); continue; }
+
+    const aqui = join(raizAtual, rel);
+    if (!existsSync(aqui)) { plano.novo.push(rel); continue; }
+
+    const hAqui = hashDe(aqui);
+    const hNovo = hashDe(join(raizNova, rel));
+    if (hAqui === hNovo) { plano.igual.push(rel); continue; }
+
+    // difere do pacote novo. Foi o dono que mexeu, ou é a correção chegando?
+    // Metadados do pacote são do sistema por definição — o dono nunca os
+    // edita. Preservar o VERSION deixaria o update dizendo "já está na versão
+    // mais recente" para sempre numa instalação sem manifesto.
+    if (SEMPRE_ATUALIZA.includes(rel)) { plano.atualiza.push(rel); continue; }
+
+    if (orig) {
+      const hOrig = orig[rel];
+      // sem registro de origem = arquivo que o dono criou depois: preserva
+      if (!hOrig) { plano.preserva.push(rel); continue; }
+      // igual ao que foi instalado = intocado pelo dono: pode atualizar
+      if (hAqui === hOrig) { plano.atualiza.push(rel); continue; }
+      plano.preserva.push(rel);
+    } else {
+      // Sem manifesto não dá para saber quem alterou o quê. Preservar TUDO
+      // parece seguro, mas trava o update onde ele mais importa: numa
+      // instalação antiga, os arquivos do MOTOR (scripts, hooks, instalador)
+      // são exatamente os que carregam a correção — e quase nunca são
+      // editados pelo dono. Preservá-los entregaria um update que não
+      // atualiza nada, com um .novo inerte ao lado.
+      //
+      // Então: motor atualiza, conteúdo preserva. E o que for sobrescrito
+      // ganha backup .antigo, para nada ser perdido sem volta.
+      plano[ehDoMotor(rel) ? 'atualiza' : 'preserva'].push(rel);
+    }
+  }
+  return plano;
+}
+
+function mostrarPlano(plano, semManifesto) {
+  const l = (rot, arr, cor) => {
+    if (!arr.length) return;
+    console.log(`  ${cor(String(arr.length).padStart(5))}  ${branco(rot)}`);
+  };
+  console.log();
+  console.log(`  ${branco(neg('O que vai acontecer'))}`);
+  console.log();
+  l('arquivos novos', plano.novo, verde);
+  l('atualizados', plano.atualiza, verde);
+  l('preservados (você alterou)', plano.preserva, laranja);
+  l('já estavam iguais', plano.igual, fraco);
+  l('protegidos (memória, workspace, .env)', plano.protegido, cinza);
+  console.log();
+
+  if (plano.preserva.length) {
+    const amostra = plano.preserva.slice(0, 6);
+    console.log(`  ${laranja('Preservados')} ${fraco('— fica a SUA versão, e guardo a nova ao lado como .novo')}`);
+    for (const a of amostra) console.log(`    ${fraco('·')} ${cinza(a)}`);
+    if (plano.preserva.length > amostra.length) {
+      console.log(`    ${fraco(`· e mais ${plano.preserva.length - amostra.length}`)}`);
+    }
+    console.log();
+  }
+
+  if (semManifesto) {
+    console.log(`  ${laranja('!')}  ${cinza('Sua instalação é anterior ao registro de arquivos.')}`);
+    console.log(`     ${fraco('Sem ele não sei o que você alterou. Então atualizo o motor do sistema')}`);
+    console.log(`     ${fraco('(hooks, scripts, instalador) — é onde a correção vem — e preservo o')}`);
+    console.log(`     ${fraco('resto. O que for sobrescrito fica salvo como .antigo, e dá para voltar.')}`);
+    console.log(`     ${fraco('A partir desta atualização, o registro passa a existir.')}`);
+    console.log();
+  }
+}
+
+function aplicar(raizAtual, raizNova, plano) {
+  let n = 0;
+  for (const rel of [...plano.novo, ...plano.atualiza]) {
+    const destino = join(raizAtual, rel);
+    mkdirSync(join(destino, '..'), { recursive: true });
+    // guarda o anterior quando o conteúdo difere: sem manifesto a decisão de
+    // atualizar é uma aposta informada, e aposta precisa ter volta.
+    if (existsSync(destino) && hashDe(destino) !== hashDe(join(raizNova, rel))) {
+      try { copyFileSync(destino, destino + '.antigo'); } catch {}
+    }
+    copyFileSync(join(raizNova, rel), destino);
+    n++;
+  }
+  // o que o dono alterou fica intacto; a versão nova vai ao lado, para ele ver
+  for (const rel of plano.preserva) {
+    copyFileSync(join(raizNova, rel), join(raizAtual, rel + '.novo'));
+  }
+  return n;
+}
+
+async function atualizar(args) {
+  abertura();
+
+  const raiz = resolve(process.cwd(), args[0] || '.');
+  const marca = join(raiz, '.claude', 'hooks');
+  if (!existsSync(marca)) {
+    console.log(`  ${vermelho(neg('Não encontrei um JARVIS aqui.'))}`);
+    console.log(`  ${cinza('Rode este comando DENTRO da pasta do JARVIS, ou passe o caminho:')}`);
+    console.log(`      ${fraco('npx @fefsbenson/jarvis update C:\\Users\\voce\\jarvis')}`);
+    console.log();
+    return 1;
+  }
+
+  const versaoAtual = existsSync(join(raiz, 'VERSION'))
+    ? readFileSync(join(raiz, 'VERSION'), 'utf8').trim() : '?';
+
+  const py = acharPython();
+  const plataforma = existsSync(join(raiz, '.claude', 'hooks', 'pyrun.py'))
+    ? 'windows' : 'linux';
+
+  console.log(`  ${verde('✓')}  ${branco('JARVIS encontrado')}  ${fraco(raiz)}`);
+  console.log(`  ${verde('✓')}  ${branco('Versão atual')}  ${cinza('v' + versaoAtual)}` +
+              `   ${fraco('edição ' + PLATAFORMAS[plataforma].rotulo)}`);
+  console.log();
+  console.log(`  ${cinza('Vou baixar a versão mais recente e trazer só o que mudou.')}`);
+  console.log(`  ${cinza('O que você alterou fica como está — nada seu é sobrescrito.')}`);
+  console.log();
+
+  // Pacote já em disco: pula o download. Serve a dois casos reais — o dono que
+  // recebeu o pacote por outro meio (rede local, pen drive), e o TESTE, que
+  // precisa exercitar este caminho sem rede nem token. Sem esta porta, a única
+  // forma de provar o update é baixando de verdade, e o que não se testa não
+  // se garante.
+  const localIdx = args.indexOf('--de');
+  const pacoteLocal = localIdx >= 0 ? resolve(args[localIdx + 1] || '') : null;
+
+  let tmp;
+  if (pacoteLocal) {
+    if (!existsSync(join(pacoteLocal, 'VERSION'))) {
+      console.log(`\n  ${vermelho(neg('Isso não parece um pacote do JARVIS.'))}`);
+      console.log(`  ${cinza(pacoteLocal + ' — não tem VERSION')}\n`);
+      return 1;
+    }
+    tmp = pacoteLocal;
+    console.log(`  ${verde('✓')}  ${branco('Usando o pacote local')}  ${fraco(tmp)}`);
+  } else {
+    const token = process.env.JARVIS_TOKEN || await perguntar('Token:', true);
+    if (!token) {
+      console.log(`\n  ${fraco('Sem token, não há o que baixar. Cancelado.')}\n`);
+      return 130;
+    }
+
+    tmp = join(tmpdir(), `jarvis-update-${Date.now()}`);
+    console.log();
+    try {
+      await baixar(token, tmp, plataforma);
+    } catch (e) {
+      if (e.message === 'TOKEN_INVALIDO' || e.message === 'SEM_ACESSO') erroDeAcesso(e.message);
+      else {
+        console.log(`\n  ${vermelho(neg('Não consegui baixar.'))}`);
+        console.log(`  ${cinza(e.message)}\n`);
+      }
+      return 1;
+    }
+  }
+
+  // NUNCA apagar um diretório que o dono nos deu. Com `--de`, `tmp` É o pacote
+  // dele — removê-lo seria destruir a origem no meio de uma operação cujo
+  // propósito inteiro é não destruir nada.
+  const limparTmp = () => {
+    if (!pacoteLocal) rmSync(tmp, { recursive: true, force: true });
+  };
+
+  const versaoNova = existsSync(join(tmp, 'VERSION'))
+    ? readFileSync(join(tmp, 'VERSION'), 'utf8').trim() : '?';
+
+  if (versaoNova === versaoAtual) {
+    console.log();
+    console.log(`  ${verde('✓')}  ${branco('Você já está na versão mais recente')} ${cinza('(v' + versaoNova + ')')}`);
+    console.log();
+    limparTmp();
+    return 0;
+  }
+
+  // Sanidade do que foi baixado, ANTES de encostar na pasta do dono.
+  // Um pacote que extrai pela metade (rede caindo, disco cheio) não faz o tar
+  // falhar necessariamente — e aplicar um pacote incompleto por cima de uma
+  // instalação boa é exatamente o estrago que este comando não pode causar.
+  const marcasEsperadas = ['.claude/hooks', '.claude/scripts', 'VERSION', 'install.py'];
+  const faltando = marcasEsperadas.filter(m => !existsSync(join(tmp, m)));
+  const totalBaixado = listar(tmp).length;
+  if (faltando.length || totalBaixado < 500) {
+    console.log();
+    console.log(`  ${vermelho(neg('O pacote baixado veio incompleto.'))}`);
+    console.log(`  ${cinza(faltando.length ? 'falta: ' + faltando.join(', ')
+                                            : `só ${totalBaixado} arquivos`)}`);
+    console.log();
+    console.log(`  ${branco('Sua instalação NÃO foi tocada.')} ${fraco('Tente de novo.')}`);
+    console.log();
+    limparTmp();
+    return 1;
+  }
+
+  const manifesto = lerManifesto(raiz);
+  const plano = planejar(raiz, tmp, manifesto);
+
+  console.log();
+  console.log(`  ${branco(neg(`v${versaoAtual}`))} ${fraco('→')} ${verde(neg(`v${versaoNova}`))}`);
+  mostrarPlano(plano, !manifesto);
+
+  if (!plano.novo.length && !plano.atualiza.length) {
+    console.log(`  ${verde('✓')}  ${branco('Nada a mudar nos arquivos do sistema.')}`);
+    console.log();
+    limparTmp();
+    return 0;
+  }
+
+  // `--seco`: mostra o plano e para. É o "ver antes de aplicar" que o dono
+  // deve usar sempre na primeira vez — e o único modo em que este comando
+  // não escreve nada, por construção.
+  if (args.includes('--seco')) {
+    console.log(`  ${fraco('(--seco: nada foi escrito)')}\n`);
+    limparTmp();
+    return 0;
+  }
+
+  // `--sim` pula a confirmação. Existe para automação e teste; o caminho
+  // normal do dono continua perguntando, porque a decisão é dele.
+  if (!args.includes('--sim')) {
+    const ok = (await perguntar(`Aplicar? ${fraco('(enter = sim, n = cancelar)')}`)).trim().toLowerCase();
+    if (ok === 'n' || ok === 'nao' || ok === 'não') {
+      console.log(`\n  ${fraco('Cancelado. Nada foi alterado.')}\n`);
+      limparTmp();
+      return 130;
+    }
+  }
+
+  console.log();
+  const n = aplicar(raiz, tmp, plano);
+  console.log(`  ${verde('✓')}  ${branco('Aplicado')}  ${fraco(n.toLocaleString('pt-BR') + ' arquivo(s)')}`);
+  limparTmp();
+
+  // O settings.json que veio no pacote traz o caminho como `$CLAUDE_PROJECT_DIR`
+  // — sintaxe POSIX. Precisa virar o caminho ABSOLUTO desta máquina, senão no
+  // Windows os 105 hooks morrem (foi o defeito que quebrou a instalação de um
+  // aluno em 24/08).
+  //
+  // Chamar o médico com --fix NÃO basta: em Linux o exame passa (lá a variável
+  // expande), então o conserto nem é acionado e o marcador fica. Por isso a
+  // regravação é INCONDICIONAL — o install.py sabe fazê-la, e é a mesma função
+  // que roda em toda instalação.
+  if (py) {
+    console.log();
+    console.log(`  ${cinza('Ajustando os caminhos para esta máquina...')}`);
+    const fix = spawnSync(py.cmd, [...(py.args || []), '-c',
+      'import sys;sys.path.insert(0,sys.argv[1]);import install;' +
+      'r=install.fixar_launcher_dos_hooks();print(r[0],r[1])', raiz],
+      { encoding: 'utf8', cwd: raiz });
+    if (fix.status === 0) {
+      console.log(`  ${verde('✓')}  ${branco('Caminhos e launcher gravados')} ${fraco((fix.stdout || '').trim())}`);
+    } else {
+      console.log(`  ${laranja('!')}  ${cinza('Não consegui regravar os caminhos automaticamente.')}`);
+      console.log(`     ${fraco('Rode: ' + py.cmd + ' .claude/scripts/jarvis_doctor.py --fix')}`);
+    }
+
+    // e o registro de arquivos precisa refletir a versão que acabou de entrar,
+    // senão a PRÓXIMA atualização compara contra a versão errada
+    spawnSync(py.cmd, [...(py.args || []), '-c',
+      'import sys;sys.path.insert(0,sys.argv[1]);import install;install.gravar_impressao_digital()', raiz],
+      { encoding: 'utf8', cwd: raiz });
+
+    console.log();
+    console.log(`  ${cinza('Conferindo a instalação...')}`);
+    console.log();
+    const r = spawnSync(py.cmd, [...(py.args || []),
+                                 join(raiz, '.claude', 'scripts', 'jarvis_doctor.py')],
+                        { stdio: 'inherit', cwd: raiz });
+    if (r.status !== 0) {
+      console.log();
+      console.log(`  ${laranja('!')}  ${cinza('O médico apontou algo. Veja acima o que ficou pendente.')}`);
+    }
+  }
+
+  console.log();
+  console.log(`  ${verde(neg('Atualizado para v' + versaoNova + '.'))}`);
+  if (plano.preserva.length) {
+    console.log(`  ${fraco('Seus arquivos alterados continuam lá; a versão nova de cada um está como *.novo')}`);
+  }
+  console.log();
+  return 0;
+}
+
 function ajuda() {
   abertura();
   console.log(`  ${branco('npx @fefsbenson/jarvis install')}          ${fraco('baixa e instala em ./jarvis')}`);
   console.log(`  ${branco('npx @fefsbenson/jarvis install PASTA')}    ${fraco('instala na pasta que você escolher')}`);
   console.log();
+  console.log(`  ${branco('npx @fefsbenson/jarvis update')}           ${fraco('atualiza o JARVIS desta pasta')}`);
+  console.log(`  ${branco('npx @fefsbenson/jarvis update PASTA')}     ${fraco('atualiza o de outra pasta')}`);
+  console.log(`  ${fraco('       o update preserva o que você alterou — nada seu é sobrescrito')}`);
+  console.log(`  ${branco('npx @fefsbenson/jarvis update --seco')}     ${fraco('mostra o que mudaria, sem escrever nada')}`);
+  console.log();
   console.log(`  ${fraco('Precisa de: Node 18+, Python 3.10+ e o token de acesso.')}`);
   console.log(`  ${fraco('O token também pode vir da variável JARVIS_TOKEN.')}`);
   console.log();
@@ -336,6 +779,8 @@ function ajuda() {
 const [, , comando, ...resto] = process.argv;
 if (comando === 'install') {
   instalar(resto).then(cod => process.exit(cod));
+} else if (comando === 'update' || comando === 'atualizar') {
+  atualizar(resto).then(cod => process.exit(cod));
 } else {
   ajuda();
   process.exit(comando ? 1 : 0);

package/bin/teste-preservacao.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * O update do cli.js preserva o que é do dono?
+ *
+ * Existe porque a política de preservação vive em DOIS lugares — aqui e no
+ * `atualizar.py` da instalação. Divergir significa que o mesmo arquivo é
+ * sagrado num caminho e apagado no outro, e ninguém percebe até um cliente
+ * perder trabalho.
+ *
+ * Rodar:  node bin/teste-preservacao.mjs
+ */
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const cli = readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'cli.js'), 'utf8');
+const trecho = cli.slice(cli.indexOf('const INTOCAVEIS'), cli.indexOf('function listar('));
+const { ehIntocavel } = await import(
+  'data:text/javascript,' + encodeURIComponent(trecho + '\nexport { ehIntocavel };'));
+
+// [caminho, protegido?, por quê]
+const CASOS = [
+  ['.env',                                    true,  'credencial'],
+  ['jarvis.config.yaml',                      true,  'config do dono'],
+  ['.claude/settings.local.json',             true,  'overrides da máquina dele'],
+  ['.claude/jarvis/STATE.json',               true,  'estado'],
+  ['.claude/sessions/s.md',                   true,  'histórico'],
+  ['.claude/mission-control/S.json',          true,  'estado de missão'],
+  ['.claude/trash/x.md',                      true,  'lixeira dele'],
+  ['workspace/businesses/x/brand.md',         true,  'o negócio dele'],
+  ['knowledge/business/insights/r.md',        true,  'bucket dele'],
+  ['knowledge/personal/cognitive/d.md',       true,  'bucket dele'],
+  ['knowledge/external/inbox/CURSO/a.txt',    true,  'material que ELE ingeriu'],
+  ['outputs/relatorio.md',                    true,  'produção dele (L3)'],
+  ['research/analise.md',                     true,  'produção dele (L3)'],
+  ['logs/x.jsonl',                            true,  'registro'],
+  ['.data/rag/x.db',                          true,  'índice'],
+  ['artifacts/x.json',                        true,  'saída de pipeline'],
+  ['processing/x.json',                       true,  'artefato de pipeline'],
+  ['agents/external/ah/MEMORY.md',            true,  'memória acumulada do agente'],
+  ['agents/external/ah/SOUL.md',              true,  'voz calibrada do agente'],
+  // do sistema — DEVEM receber a correção
+  ['agents/external/ah/AGENT.md',             false, 'definição vem do pacote'],
+  ['agents/external/ah/DNA-CONFIG.yaml',      false, 'ponteiro vem do pacote'],
+  ['knowledge/external/dna/persons/ah/H.yaml',false, 'DNA curado — L2'],
+  ['knowledge/external/dossiers/d.md',        false, 'dossiê curado — L2'],
+  ['knowledge/external/playbooks/p.md',       false, 'playbook curado — L2'],
+  ['.claude/rules/goal-mindset.md',           false, 'rule do sistema'],
+  ['.claude/hooks/x.py',                      false, 'hook do sistema'],
+  ['.claude/skills/jarvis/SKILL.md',          false, 'skill do sistema'],
+  ['core/paths.py',                           false, 'motor'],
+  ['install.py',                              false, 'instalador'],
+  ['VERSION',                                 false, 'metadado — atualiza'],
+  ['.claude/jarvis/instalacao-original.json', false, 'baseline — precisa renovar'],
+];
+
+let falhas = 0;
+for (const [rel, esperado, porque] of CASOS) {
+  const got = ehIntocavel(rel);
+  const ok = got === esperado;
+  if (!ok) falhas++;
+  console.log(`  ${ok ? 'PASS' : 'FALHA'}  protegido=${String(got).padEnd(5)} ${rel.padEnd(44)} ${porque}`);
+}
+console.log(`\n  ${falhas ? `${falhas} FALHA(S)` : `${CASOS.length}/${CASOS.length} PASSARAM`}`);
+process.exit(falhas ? 1 : 0);

package/bin/teste-update-backup.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""BATERIA 6 — o risco que a fronteira larga criou.
+
+Ampliar `ehDoMotor` para skills/rules/agents significa que, SEM manifesto, um
+arquivo desses que o dono editou é sobrescrito. Isso só é aceitável porque o
+`.antigo` existe. Esta bateria prova que ele existe SEMPRE, e que o conteúdo
+do dono está lá dentro — recuperável com um `mv`.
+"""
+import hashlib, json, shutil, subprocess, sys, tempfile
+from pathlib import Path
+
+PAC = Path.home()/"jarvis-dist"
+CLI = Path.home()/"jarvis-npx/bin/cli.js"
+
+
+def h(p): return hashlib.sha256(p.read_bytes()).hexdigest()
+
+
+# O dono editou arquivos do SISTEMA — cada família que a fronteira agora cobre
+EDITADOS = {
+    ".claude/rules/goal-mindset.md":        "# regra do sistema COM MINHA ANOTACAO\n",
+    ".claude/skills/jarvis/SKILL.md":       "# skill do sistema QUE EU AJUSTEI\n",
+    ".claude/hooks/hook_output.py":         "# hook QUE EU MEXI\n",
+    "agents/system/decisor/AGENT.md":       "# agente QUE EU CUSTOMIZEI\n",
+    "core/intelligence/agents/activation_generator.py": "# core QUE EU MUDEI\n",
+}
+
+
+def montar(com_manifesto):
+    B = Path(tempfile.gettempdir())/f"bkp-{'m' if com_manifesto else 's'}"
+    if B.exists(): shutil.rmtree(B, ignore_errors=True)
+    inst = B/"inst"
+    for a in (".claude/hooks", ".claude/rules", ".claude/skills/jarvis",
+              "agents/system", "core/intelligence/agents"):
+        shutil.copytree(PAC/a, inst/a, dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns("__pycache__"))
+    for f in ("VERSION", ".claude/settings.json", "install.py"):
+        (inst/f).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(PAC/f, inst/f)
+    (inst/"VERSION").write_text("1.1.23\n")
+    if com_manifesto:
+        # manifesto do estado LIMPO (antes das edições do dono)
+        arq = {str(f.relative_to(inst)).replace("\\","/"): h(f)
+               for f in inst.rglob("*") if f.is_file() and "__pycache__" not in str(f)}
+        mp = inst/".claude/jarvis/instalacao-original.json"
+        mp.parent.mkdir(parents=True, exist_ok=True)
+        mp.write_text(json.dumps({"versao":"1.1.23","arquivos":arq}, indent=2))
+    for rel, txt in EDITADOS.items():
+        (inst/rel).write_text(txt, encoding="utf-8")
+    return inst
+
+
+falhas = 0
+for com_man in (True, False):
+    rot = "COM manifesto (deve PRESERVAR)" if com_man else "SEM manifesto (sobrescreve COM backup)"
+    print(f"\n  ── {rot} ──")
+    inst = montar(com_man)
+    subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+                   capture_output=True, text=True, timeout=600)
+    for rel, meu in EDITADOS.items():
+        p = inst/rel
+        atual = p.read_text(encoding="utf-8", errors="replace")
+        marca = meu.strip()
+        no_lugar = marca in atual
+        bkp = inst/(rel + ".antigo")
+        no_backup = bkp.is_file() and marca in bkp.read_text(encoding="utf-8", errors="replace")
+        novo = inst/(rel + ".novo")
+
+        if com_man:
+            # com manifesto: o arquivo do dono FICA, e a versão nova vai .novo
+            ok = no_lugar and novo.is_file()
+            detalhe = f"no_lugar={no_lugar} tem_.novo={novo.is_file()}"
+        else:
+            # sem manifesto: é sobrescrito, MAS o dele tem que estar no .antigo
+            ok = no_backup
+            detalhe = f"no_lugar={no_lugar} no_backup={no_backup}"
+        falhas += not ok
+        print(f"    {'PASS' if ok else 'FALHA'}  {rel}" + ("" if ok else f"  -> {detalhe}"))
+
+    # recuperável com um comando? (o teste que prova que o backup SERVE)
+    if not com_man:
+        rel = ".claude/rules/goal-mindset.md"
+        shutil.move(inst/(rel + ".antigo"), inst/rel)
+        ok = EDITADOS[rel].strip() in (inst/rel).read_text(encoding="utf-8")
+        falhas += not ok
+        print(f"    {'PASS' if ok else 'FALHA'}  recuperável com um `mv arquivo.antigo arquivo`")
+
+print(f"\n  BATERIA 6: {'TODOS PASSARAM' if not falhas else f'{falhas} FALHA(S)'}")
+sys.exit(1 if falhas else 0)