@fefsbenson/jarvis 1.2.0 → 1.3.0

package/bin/cli.js

@@ -364,11 +364,28 @@ const INTOCAVEIS = [
   '.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
@@ -384,6 +401,7 @@ const EXCECOES = [
 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);
 }
 
@@ -411,17 +429,43 @@ function listar(dir, base = dir, saida = []) {
  *                sem ele, "atualizar" seria apagar o trabalho de alguém.
  */
 /**
- * O "motor": o que faz o sistema funcionar, por oposição ao que ele guarda.
+ * 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 hook
- * à mão é muito menor que a de ficar sem o conserto.
+ * 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';
@@ -553,25 +597,51 @@ async function atualizar(args) {
   console.log(`  ${cinza('O que você alterou fica como está — nada seu é sobrescrito.')}`);
   console.log();
 
-  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;
-  }
+  // 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;
+    }
 
-  const 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`);
+    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;
     }
-    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() : '?';
 
@@ -579,7 +649,7 @@ async function atualizar(args) {
     console.log();
     console.log(`  ${verde('✓')}  ${branco('Você já está na versão mais recente')} ${cinza('(v' + versaoNova + ')')}`);
     console.log();
-    rmSync(tmp, { recursive: true, force: true });
+    limparTmp();
     return 0;
   }
 
@@ -598,7 +668,7 @@ async function atualizar(args) {
     console.log();
     console.log(`  ${branco('Sua instalação NÃO foi tocada.')} ${fraco('Tente de novo.')}`);
     console.log();
-    rmSync(tmp, { recursive: true, force: true });
+    limparTmp();
     return 1;
   }
 
@@ -612,21 +682,34 @@ async function atualizar(args) {
   if (!plano.novo.length && !plano.atualiza.length) {
     console.log(`  ${verde('✓')}  ${branco('Nada a mudar nos arquivos do sistema.')}`);
     console.log();
-    rmSync(tmp, { recursive: true, force: true });
+    limparTmp();
     return 0;
   }
 
-  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`);
-    rmSync(tmp, { recursive: true, force: true });
-    return 130;
+  // `--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)')}`);
-  rmSync(tmp, { recursive: true, force: true });
+  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
@@ -686,6 +769,7 @@ function ajuda() {
   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.')}`);

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)

package/bin/teste-update-cliente.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""BATERIA 4 — o cliente que usou o JARVIS por meses, e atualiza.
+
+Não são casos isolados: é UMA instalação com 60+ artefatos espalhados por todas
+as áreas onde um dono real trabalha. Depois do update, TUDO tem que estar lá.
+E roda a cadeia inteira de versões (1.1.20 -> 1.1.23 -> 1.1.24) para provar que
+o update repetido não acumula estrago.
+"""
+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()
+
+
+# 60+ artefatos: tudo que um dono acumula em meses de uso
+TRABALHO = {}
+for i in range(8):
+    TRABALHO[f"workspace/businesses/acme/copy/pagina-{i}.md"] = f"copy de venda {i}"
+    TRABALHO[f"workspace/ops/sprints/sprint-{i}.md"] = f"sprint {i}"
+for i in range(6):
+    TRABALHO[f"knowledge/business/insights/reuniao-{i}.md"] = f"ata {i} CONFIDENCIAL"
+    TRABALHO[f"knowledge/personal/cognitive/diario-{i}.md"] = f"reflexao {i}"
+    TRABALHO[f"outputs/entrega-cliente-{i}.md"] = f"entrega paga {i}"
+for i in range(5):
+    TRABALHO[f"knowledge/external/inbox/CURSO-{i}/aula.txt"] = f"material comprado {i}"
+    TRABALHO[f"research/analise-{i}.md"] = f"pesquisa {i}"
+    TRABALHO[f"logs/batches/b-{i}.jsonl"] = '{"batch":%d}' % i
+for ag in ("decisor", "conclave/sintetizador"):
+    TRABALHO[f"agents/system/{ag}/MEMORY.md"] = f"MEMORIA ACUMULADA de {ag}"
+    TRABALHO[f"agents/system/{ag}/SOUL.md"] = f"voz calibrada de {ag}"
+TRABALHO.update({
+    ".env": "OPENAI_API_KEY=sk-real\nVOYAGE_API_KEY=vk-real",
+    "jarvis.config.yaml": "voz: onyx\ntratamento: chefe",
+    ".claude/settings.local.json": '{"hooks":{"Stop":[]}}',
+    ".claude/jarvis/JARVIS-MEMORY.md": "memoria relacional de 6 meses",
+    ".claude/jarvis/PENDING.md": "- pendencia do dono",
+    ".claude/sessions/SESSION-antiga.md": "sessao de marco",
+    ".claude/mission-control/MISSION-STATE.json": '{"fase":4}',
+    ".claude/trash/apagado.md": "mandei pra lixeira",
+    ".claude/rules/minha-regra-propria.md": "regra que EU escrevi",
+    ".claude/hooks/meu_hook_proprio.py": "# hook que EU escrevi",
+    ".claude/skills/minha-skill/SKILL.md": "skill que EU criei",
+    "artifacts/audit/relatorio.json": '{"ok":true}',
+    "processing/speakers.json": '{"s":1}',
+    ".data/rag_expert/vectors.json": '{"dim":1024}',
+})
+
+def montar(versao, com_manifesto=True):
+    B = Path(tempfile.gettempdir())/"cliente-real"
+    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",
+              "knowledge/external/dna"):
+        if (PAC/a).is_dir():
+            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(versao + "\n")
+    if com_manifesto:
+        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": versao, "arquivos": arq}, indent=2))
+    for rel, txt in TRABALHO.items():
+        p = inst/rel; p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(txt, encoding="utf-8")
+    return inst
+
+
+def conferir(inst, rot):
+    perdidos = []
+    for rel, esperado in TRABALHO.items():
+        p = inst/rel
+        if not p.is_file():
+            perdidos.append(f"{rel}(SUMIU)"); continue
+        atual = p.read_text(encoding="utf-8", errors="replace")
+        if esperado in atual:
+            continue
+        if rel.endswith(".json"):
+            try:
+                if all(json.loads(atual).get(k) == v
+                       for k, v in json.loads(esperado).items()):
+                    continue
+            except Exception: pass
+        if (inst/(rel+".antigo")).is_file() and \
+           esperado in (inst/(rel+".antigo")).read_text(encoding="utf-8", errors="replace"):
+            continue
+        perdidos.append(f"{rel}(PERDIDO)")
+    ok = not perdidos
+    print(f"  {'PASS' if ok else 'FALHA'}  [{rot}] {len(TRABALHO)} artefatos do dono"
+          + ("" if ok else f"  -> {len(perdidos)} perdidos: {perdidos[:6]}"))
+    return ok
+
+
+falhas = 0
+print(f"  simulando um cliente com {len(TRABALHO)} artefatos acumulados\n")
+
+# A — com manifesto, uma atualização
+inst = montar("1.1.23")
+subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+               capture_output=True, text=True, timeout=600)
+falhas += not conferir(inst, "1.1.23 -> 1.1.24, com manifesto")
+
+# B — sem manifesto (instalação antiga, o caso do Fábio)
+inst = montar("1.1.20", com_manifesto=False)
+subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+               capture_output=True, text=True, timeout=600)
+falhas += not conferir(inst, "1.1.20 -> 1.1.24, SEM manifesto")
+
+# C — três updates seguidos: o estrago não pode acumular
+inst = montar("1.1.23")
+for n in range(3):
+    subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+                   capture_output=True, text=True, timeout=600)
+falhas += not conferir(inst, "três updates seguidos")
+
+# D — o caminho Python, sobre a mesma instalação
+inst = montar("1.1.23")
+subprocess.run([sys.executable, str(PAC/".claude/scripts/atualizar.py"),
+                "--novo", str(PAC), "--destino", str(inst), "--sim"],
+               capture_output=True, text=True, timeout=600)
+falhas += not conferir(inst, "caminho Python (atualizar.py)")
+
+print(f"\n  BATERIA 4: {'TODOS PASSARAM' if not falhas else f'{falhas} FALHA(S)'}")
+sys.exit(1 if falhas else 0)

package/bin/teste-update-entrega.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""BATERIA 5 — o update ENTREGA a correção?
+
+Preservar tudo é trivial se você não atualiza nada. Esta bateria prova o outro
+lado: o que é do sistema e o dono não tocou TEM que receber a versão nova.
+Um update que só preserva é um update quebrado que parece seguro.
+"""
+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()
+
+
+def montar(nome, envelhecer: dict, com_manifesto=True):
+    """Instala e depois 'envelhece' arquivos do sistema (simula versão antiga)."""
+    B = Path(tempfile.gettempdir())/f"entrega-{nome}"
+    if B.exists(): shutil.rmtree(B, ignore_errors=True)
+    inst = B/"inst"
+    for a in (".claude/hooks", ".claude/rules", ".claude/scripts",
+              ".claude/skills/jarvis", "agents/system", "core/intelligence/agents",
+              "knowledge/external/dna"):
+        if (PAC/a).is_dir():
+            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")
+    # ENVELHECE: escreve a "versão antiga" nesses arquivos do sistema
+    for rel, txt in envelhecer.items():
+        p = inst/rel; p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(txt, encoding="utf-8")
+    # manifesto reflete o estado ENVELHECIDO (o dono não tocou nesses arquivos)
+    if com_manifesto:
+        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))
+    return inst
+
+
+# Arquivos do SISTEMA "na versão antiga" — o dono nunca os tocou.
+# Cada um representa uma família: hook, rule, script, skill, agente, DNA.
+ANTIGOS = {
+    ".claude/hooks/hook_output.py":            "# VERSAO ANTIGA COM BUG\n",
+    ".claude/rules/goal-mindset.md":           "# regra desatualizada\n",
+    ".claude/scripts/jarvis_doctor.py":        "# doctor antigo\n",
+    ".claude/skills/jarvis/SKILL.md":          "# skill antiga\n",
+    "agents/system/decisor/AGENT.md":          "# agente desatualizado\n",
+    "core/intelligence/agents/activation_generator.py": "# gerador antigo\n",
+}
+
+falhas = 0
+for com_man in (True, False):
+    rot = "com manifesto" if com_man else "SEM manifesto"
+    print(f"\n  ── {rot} ──")
+    inst = montar("m" if com_man else "s", ANTIGOS, com_man)
+    r = subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+                       capture_output=True, text=True, timeout=600)
+    for rel, antigo in ANTIGOS.items():
+        p, orig = inst/rel, PAC/rel
+        if not orig.is_file():
+            print(f"    ---   {rel} não existe no pacote (pulando)"); continue
+        atual = p.read_text(encoding="utf-8", errors="replace") if p.is_file() else ""
+        recebeu = h(p) == h(orig) if p.is_file() else False
+        ainda_antigo = antigo.strip() in atual
+        ok = recebeu and not ainda_antigo
+        falhas += not ok
+        print(f"    {'PASS' if ok else 'FALHA'}  {rel}"
+              + ("" if ok else f"  -> recebeu_versao_nova={recebeu} ainda_antigo={ainda_antigo}"))
+    # e a versão tem que ter subido
+    v = (inst/"VERSION").read_text().strip()
+    ok = v == "1.1.24"; falhas += not ok
+    print(f"    {'PASS' if ok else 'FALHA'}  VERSION -> {v}")
+    # e os arquivos NOVOS da 1.1.24 têm que ter chegado
+    for rel in (".claude/skills/jarvis-update/SKILL.md",
+                ".claude/rules/design-por-publico.md",
+                ".claude/scripts/atualizar.py"):
+        ok = (inst/rel).is_file(); falhas += not ok
+        print(f"    {'PASS' if ok else 'FALHA'}  novo da 1.1.24: {rel}")
+
+print(f"\n  BATERIA 5: {'TODOS PASSARAM' if not falhas else f'{falhas} FALHA(S)'}")
+sys.exit(1 if falhas else 0)

package/bin/teste-update-hostil.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""BATERIA 3 — casos hostis: o que quebra um update no mundo real.
+
+Cada caso é uma situação que existe na máquina de gente de verdade e que um
+update ingênuo trata mal: rodar duas vezes, arquivo somente-leitura, nome com
+acento e espaço, link simbólico, arquivo enorme, pasta que não é JARVIS,
+pacote inválido, e interrupção no meio.
+"""
+import hashlib, json, os, shutil, stat, subprocess, sys, tempfile
+from pathlib import Path
+
+PAC = Path.home()/"jarvis-dist"
+CLI = Path.home()/"jarvis-npx/bin/cli.js"
+UPD = PAC/".claude/scripts/atualizar.py"
+
+
+def h(p): return hashlib.sha256(p.read_bytes()).hexdigest()
+
+
+def base(nome, com_manifesto=True):
+    B = Path(tempfile.gettempdir())/f"host-{nome}"
+    if B.exists():
+        shutil.rmtree(B, ignore_errors=True)
+    inst = B/"inst"
+    for a in (".claude/hooks", ".claude/rules"):
+        shutil.copytree(PAC/a, inst/a, dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns("__pycache__"))
+    (inst/"VERSION").write_text("1.1.23\n")
+    if com_manifesto:
+        arq = {str(f.relative_to(inst)).replace("\\","/"): h(f)
+               for f in inst.rglob("*") if f.is_file()}
+        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))
+    return inst
+
+
+def upd(inst, *extra, pacote=None):
+    return subprocess.run(
+        ["node", str(CLI), "update", str(inst), "--de", str(pacote or PAC), "--sim", *extra],
+        capture_output=True, text=True, timeout=600)
+
+
+resultados = []
+def caso(nome, ok, detalhe=""):
+    resultados.append((nome, ok, detalhe))
+    print(f"  {'PASS' if ok else 'FALHA'}  {nome}" + (f"  -> {detalhe}" if not ok else ""))
+
+
+# 1 — IDEMPOTÊNCIA: rodar duas vezes seguidas não pode mudar nada na segunda
+inst = base("idem")
+(inst/"workspace").mkdir(exist_ok=True); (inst/"workspace/x.md").write_text("do dono")
+upd(inst)
+estado1 = {str(f.relative_to(inst)): h(f) for f in inst.rglob("*")
+           if f.is_file() and ".claude/jarvis" not in str(f) and "sessions" not in str(f)}
+r2 = upd(inst)
+estado2 = {str(f.relative_to(inst)): h(f) for f in inst.rglob("*")
+           if f.is_file() and ".claude/jarvis" not in str(f) and "sessions" not in str(f)}
+dif = [k for k in estado2 if estado1.get(k) != estado2[k]]
+caso("idempotente (2a rodada não muda nada)", not dif, f"{len(dif)} mudaram: {dif[:3]}")
+
+# 2 — a 2a rodada deve dizer "já está na versão mais recente"
+caso("2a rodada reconhece que já está atualizado",
+     "mais recente" in r2.stdout or "Nada a mudar" in r2.stdout,
+     r2.stdout[-200:])
+
+# 3 — NOME COM ACENTO E ESPAÇO (Windows/pt-BR é cheio disso)
+inst = base("acento")
+d = inst/"workspace/Relatórios do Cliente"
+d.mkdir(parents=True); (d/"análise final.md").write_text("conteúdo com acento")
+r = upd(inst)
+caso("nome com acento e espaço preservado",
+     r.returncode == 0 and (d/"análise final.md").read_text() == "conteúdo com acento",
+     f"rc={r.returncode}")
+
+# 4 — ARQUIVO SOMENTE-LEITURA do dono
+inst = base("readonly")
+f = inst/"workspace/protegido.md"
+f.parent.mkdir(parents=True, exist_ok=True); f.write_text("read-only do dono")
+os.chmod(f, stat.S_IRUSR)
+r = upd(inst)
+ok = r.returncode == 0 and f.read_text() == "read-only do dono"
+os.chmod(f, stat.S_IRUSR | stat.S_IWUSR)
+caso("arquivo somente-leitura do dono intacto", ok, f"rc={r.returncode}")
+
+# 5 — LINK SIMBÓLICO (quem move o workspace para outro disco faz isso)
+inst = base("symlink")
+alvo = inst.parent/"fora"; alvo.mkdir()
+(alvo/"real.md").write_text("mora fora do JARVIS")
+(inst/"workspace").mkdir(exist_ok=True)
+os.symlink(alvo/"real.md", inst/"workspace/link.md")
+r = upd(inst)
+caso("link simbólico não é seguido nem quebrado",
+     r.returncode == 0 and (alvo/"real.md").read_text() == "mora fora do JARVIS",
+     f"rc={r.returncode}")
+
+# 6 — PASTA QUE NÃO É JARVIS: tem que recusar, não estragar
+vazio = Path(tempfile.gettempdir())/"host-naojarvis"
+if vazio.exists(): shutil.rmtree(vazio)
+vazio.mkdir(); (vazio/"documento-importante.docx").write_text("nada a ver")
+r = upd(vazio)
+caso("recusa pasta que não é JARVIS",
+     r.returncode != 0 and (vazio/"documento-importante.docx").is_file(),
+     f"rc={r.returncode}")
+
+# 7 — PACOTE INVÁLIDO: recusa sem tocar na instalação
+inst = base("pacinval")
+(inst/"workspace").mkdir(exist_ok=True); (inst/"workspace/x.md").write_text("do dono")
+lixo = Path(tempfile.gettempdir())/"host-pacote-lixo"
+if lixo.exists(): shutil.rmtree(lixo)
+lixo.mkdir(); (lixo/"README").write_text("não sou um pacote")
+antes = h(inst/"workspace/x.md")
+r = upd(inst, pacote=lixo)
+caso("recusa pacote inválido sem tocar na instalação",
+     r.returncode != 0 and h(inst/"workspace/x.md") == antes,
+     f"rc={r.returncode}")
+
+# 8 — --seco NÃO ESCREVE NADA (a promessa mais importante)
+inst = base("seco")
+antes = {str(f.relative_to(inst)): h(f) for f in inst.rglob("*") if f.is_file()}
+r = upd(inst, "--seco")
+depois = {str(f.relative_to(inst)): h(f) for f in inst.rglob("*") if f.is_file()}
+caso("--seco não escreve absolutamente nada",
+     r.returncode == 0 and antes == depois,
+     f"rc={r.returncode} · {len(set(depois)-set(antes))} novos")
+
+# 9 — o PACOTE DE ORIGEM nunca é modificado nem apagado
+inst = base("origem")
+pac_v, pac_n = (PAC/"VERSION").read_text(), sum(1 for _ in (PAC/".claude/scripts").iterdir())
+upd(inst)
+caso("pacote de origem intacto após o update",
+     (PAC/"VERSION").read_text() == pac_v
+     and sum(1 for _ in (PAC/".claude/scripts").iterdir()) == pac_n)
+
+# 10 — arquivo GRANDE do dono não é corrompido
+inst = base("grande")
+g = inst/"workspace/base.csv"
+g.parent.mkdir(parents=True, exist_ok=True)
+g.write_text("col\n" + "\n".join(str(i) for i in range(200_000)))
+antes = h(g)
+r = upd(inst)
+caso("arquivo grande do dono intacto", r.returncode == 0 and h(g) == antes)
+
+falhas = sum(1 for _, ok, _ in resultados if not ok)
+print(f"\n  BATERIA 3: {len(resultados)-falhas}/{len(resultados)}"
+      + (" TODOS PASSARAM" if not falhas else f" — {falhas} FALHA(S)"))
+sys.exit(1 if falhas else 0)

package/bin/teste-update-preserva.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""BATERIA 2 — o comando REAL (`npx jarvis update`), adversarial.
+
+Roda `node cli.js update <inst> --de <pacote>` e confere o DISCO depois.
+É o caminho que o cliente usa; testar a função extraída seria aproximação.
+"""
+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()
+
+
+def montar(nome, trabalho, com_manifesto=True):
+    B = Path(tempfile.gettempdir())/f"real-{nome}"
+    if B.exists(): shutil.rmtree(B)
+    inst = B/"inst"
+    for a in (".claude/hooks", ".claude/rules", ".claude/skills/jarvis",
+              "agents/system", "core/intelligence/agents"):
+        if (PAC/a).is_dir():
+            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:
+        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 trabalho.items():
+        p = inst/rel; p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(txt, encoding="utf-8")
+    return inst
+
+
+CASOS = [
+ ("workspace",   {"workspace/businesses/acme/brand.md": "marca do cliente",
+                  "workspace/gestao/cockpit.yaml": "receita: 1000000"}),
+ ("memoria",     {"agents/system/decisor/MEMORY.md": "SEIS MESES DE USO",
+                  "agents/system/decisor/SOUL.md": "voz calibrada"}),
+ ("credenciais", {".env": "OPENAI_API_KEY=sk-real", "jarvis.config.yaml": "voz: onyx"}),
+ ("conhecimento",{"knowledge/business/i.md": "ata confidencial",
+                  "knowledge/personal/d.md": "diario",
+                  "knowledge/external/inbox/CURSO/a.txt": "material comprado"}),
+ ("producao",    {"outputs/entrega.md": "trabalho pago",
+                  "research/analise.md": "pesquisa", "logs/s.jsonl": "{}"}),
+ ("estado",      {".claude/jarvis/STATE.json": '{"fase":9}',
+                  ".claude/sessions/L.md": "sessao",
+                  ".claude/settings.local.json": '{"hooks":{}}'}),
+ ("hook-editado",{".claude/hooks/hook_output.py": "# EU EDITEI ESTE\n"}),
+]
+
+falhas = 0
+for com_man in (True, False):
+    rot = "COM manifesto" if com_man else "SEM manifesto (instalação antiga)"
+    print(f"\n  ── {rot} ──")
+    for nome, trabalho in CASOS:
+        inst = montar(nome, trabalho, com_man)
+        antes = {r: h(inst/r) for r in trabalho}
+        pac_antes = (PAC/"VERSION").read_text(), len(list((PAC/".claude/scripts").iterdir()))
+        r = subprocess.run(["node", str(CLI), "update", str(inst), "--de", str(PAC), "--sim"],
+                           capture_output=True, text=True, timeout=600)
+        perdidos = []
+        for rel, conteudo_dono in trabalho.items():
+            p = inst/rel
+            if not p.is_file():
+                perdidos.append(f"{rel}(SUMIU)")
+                continue
+            if h(p) == antes[rel]:
+                continue                       # intacto byte-a-byte
+            # Mudou. Duas razões legítimas, e nenhuma perde o dado do dono:
+            #   1. o doctor roda ao final e atualiza arquivos de ESTADO
+            #      (STATE.json ganha session/mis) — o dado do dono continua lá;
+            #   2. sem manifesto, o motor atualiza COM backup .antigo — e a
+            #      versão do dono está recuperável ao lado.
+            # Perda de verdade = o conteúdo dele sumiu E não há backup.
+            atual = p.read_text(encoding="utf-8", errors="replace")
+            marca = conteudo_dono.strip().splitlines()[0] if conteudo_dono.strip() else ""
+            if marca and marca in atual:
+                continue                       # o dado do dono sobreviveu
+            # JSON: o doctor reformata e ACRESCENTA chaves de estado. Comparar
+            # texto acusaria perda onde não houve — o que importa é se cada
+            # chave do dono continua lá, com o mesmo valor.
+            if rel.endswith(".json"):
+                try:
+                    meu, agora = json.loads(conteudo_dono), json.loads(atual)
+                    if all(agora.get(k) == v for k, v in meu.items()):
+                        continue
+                except (json.JSONDecodeError, AttributeError):
+                    pass
+            if (inst/(rel + ".antigo")).is_file():
+                bkp = (inst/(rel + ".antigo")).read_text(encoding="utf-8", errors="replace")
+                if marca and marca in bkp:
+                    continue                   # preservado no backup
+            perdidos.append(f"{rel}(PERDIDO — sem backup)")
+        # o pacote de origem NÃO pode ter sido tocado
+        pac_depois = (PAC/"VERSION").read_text(), len(list((PAC/".claude/scripts").iterdir()))
+        if pac_antes != pac_depois:
+            perdidos.append(f"PACOTE DE ORIGEM MUDOU ({pac_antes}->{pac_depois})")
+        ok = not perdidos and r.returncode == 0
+        falhas += not ok
+        print(f"    {'PASS' if ok else 'FALHA'}  [{nome}] rc={r.returncode}"
+              + ("" if ok else f"  -> {perdidos} {r.stderr[:150]}"))
+
+print(f"\n  BATERIA 2: {'TODOS PASSARAM' if not falhas else f'{falhas} FALHA(S)'}")
+sys.exit(1 if falhas else 0)

package/bin/testes.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Toda a bateria do update, de uma vez.
+#
+# Um update que apaga trabalho de cliente é o pior defeito que este pacote pode
+# ter — pior que não atualizar, porque não tem volta e ninguém percebe na hora.
+# Por isso a bateria é grande e roda contra o comando REAL, não contra funções
+# extraídas: aproximação do comando mede outra coisa.
+#
+# Precisa de um pacote em ~/jarvis-dist para comparar.
+set -u
+cd "$(dirname "$0")"
+falhas=0
+echo
+for t in teste-preservacao.mjs teste-update-preserva.py teste-update-hostil.py \
+         teste-update-entrega.py teste-update-backup.py teste-update-cliente.py; do
+  echo "── $t ──"
+  case "$t" in
+    *.mjs) node "$t" | tail -2 ;;
+    *.py)  python3 "$t" | tail -2 ;;
+  esac
+  [ "${PIPESTATUS[0]}" -eq 0 ] || { falhas=$((falhas+1)); echo "  ^^ FALHOU"; }
+  echo
+done
+if [ "$falhas" -eq 0 ]; then
+  echo "  TODAS AS BATERIAS PASSARAM"
+else
+  echo "  $falhas BATERIA(S) COM FALHA — não publique"
+fi
+exit "$falhas"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fefsbenson/jarvis",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "JARVIS — sistema operacional de conhecimento e agentes para Claude Code (Windows e Linux)",
   "bin": {
     "jarvis": "bin/cli.js"
@@ -26,5 +26,8 @@
     "agents",
     "knowledge-management",
     "pragma"
-  ]
+  ],
+  "scripts": {
+    "test": "bash bin/testes.sh"
+  }
 }