@fefsbenson/jarvis 1.1.0 → 1.3.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.1.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"
+  }
 }