v0.10.0: análise/prova/teste das críticas de engenharia Qwen3.8 lote 3 (r-35) — divisão SRP dos monólitos jepa/pensamento/moe/python em 26 submódulos (API estável via re-exports; 'Amdahl de compilação' refutada por experimento controlado, builds frios neutros), checkpoints atômicos SHA-256 puro FIPS 180-4 + fsync + rename + manifesto (CP-1..CP-3; correções da proposta: sem destruir estado anterior, manifesto com barreira, sem bincode/unwrap), TemperaturaInversa T-V3 (fronteira tipada da convexidade N-2; alegação compile-time corrigida), trait CamadaKhtst+CamadaHomeostatica (premissa do controlador refutada no fonte; Vec<Var>; adaptador MoeComPapel bit-a-bit), CLI Typer 75 (fachada aditiva com resume verificado por hash) — 123/123 cargo, 107/107 gates, treino real Wikipédia PT-BR com checkpoints íntegros
06e4b6f verified | #!/usr/bin/env python3 | |
| """77_suite_v010.py — v0.10.0: VEREDITO CONSOLIDADO das críticas Qwen3.8 | |
| (lote 3 — análise/prova/teste em r-35). | |
| Herda os gates da v0.9.0 (suite_v090_final.json) e adiciona: | |
| s1 divisão SRP: nenhum arquivo-fonte > 60 kB; subdiretórios presentes; | |
| testes herdados verdes (preservação de comportamento); | |
| s2 checkpoint atômico: manifestos SHA-256 presentes e válidos nos | |
| checkpoints do treino REAL; overhead de armazenamento ≈ 141 B; | |
| s3 tipos de domínio: cargo inclui os testes T-V3 (contados em 76); | |
| s4 polimorfismo de camadas: testes CK no cargo (idem); | |
| s5 treino real: fases A/B com perda decrescente; C com CE decrescente; | |
| δ_ort < 1e-5 (ortogonalidade exata em treino real); | |
| s6 CLI: comandos versao/estados/verificar-checkpoints executam. | |
| Saída: resultados/suite_v010_final.json | |
| """ | |
| import json, os, subprocess, sys | |
| PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) | |
| R = os.path.join(PASTA, "resultados") | |
| def main(): | |
| rel = {"versao": "0.10.0", "blocos": {}, "gates": {}, "medicoes": {}} | |
| def carrega(arq): | |
| p = os.path.join(R, arq) | |
| return json.load(open(p)) if os.path.exists(p) else None | |
| # ---- legado v0.9.0 | |
| legado = carrega("suite_v090_final.json") | |
| if legado: | |
| g_legado = legado.get("gates", legado) | |
| ok = sum(1 for v in g_legado.values() if v is True) | |
| rel["blocos"]["legado_v090"] = f"{ok}/{len(g_legado)}" | |
| for k, v in g_legado.items(): | |
| rel["gates"][f"legado_{k}"] = v | |
| # ---- s1: divisão SRP | |
| arquivos = [] | |
| for raiz, _, nfs in os.walk(os.path.join(PASTA, "src")): | |
| for n in nfs: | |
| if n.endswith(".rs"): | |
| p = os.path.join(raiz, n) | |
| arquivos.append((os.path.relpath(p, PASTA), os.path.getsize(p))) | |
| maior = max(arquivos, key=lambda x: x[1]) | |
| rel["medicoes"]["maior_arquivo"] = {"caminho": maior[0], "kB": round(maior[1] / 1e3, 1)} | |
| rel["gates"]["s1_nenhum_arquivo_acima_60kB"] = maior[1] < 60_000 | |
| subs = {os.path.dirname(a) for a, _ in arquivos} - {"src"} | |
| rel["gates"]["s1_monolitos_dissolvidos"] = all( | |
| d in subs for d in ("src/jepa", "src/pensamento", | |
| "src/moe_redirecionavel", "src/python")) | |
| # testes herdados: 107 da v0.9.0 continuam verdes (123/123 total) | |
| r = subprocess.run(["cargo", "test", "--all-features", "--quiet"], | |
| capture_output=True, text=True, cwd=PASTA) | |
| import re as _re | |
| m = _re.findall(r"test result: ok\. (\d+) passed", r.stdout) | |
| total = sum(int(x) for x in m) | |
| rel["medicoes"]["cargo_total"] = total | |
| rel["gates"]["s1_testes_herdados_preservados"] = (total >= 123 and r.returncode == 0) | |
| rel["blocos"]["s1_divisao_srp"] = "3/3" if all( | |
| rel["gates"][g] for g in list(rel["gates"]) if g.startswith("s1_")) else "?" | |
| # ---- s2: checkpoints atômicos no treino real | |
| import khtst_rust as k | |
| cks_ok, cks = 0, {} | |
| for nome in ("tokenizador_conceitos.json", "gerador_conceitos.json"): | |
| p = os.path.join(R, nome) | |
| okc = os.path.exists(p) and k.checkpoint_valido(p) | |
| cks_ok += int(okc) | |
| man = k.checkpoint_manifesto(p) if os.path.exists(p) else None | |
| cks[nome] = {"valido": okc, | |
| "manifesto_bytes": len(man) if man else 0} | |
| rel["gates"]["s2_checkpoints_sha256_validos"] = (cks_ok == 2) | |
| rel["medicoes"]["checkpoints"] = cks | |
| rel["blocos"]["s2_checkpoint_atomico"] = f"{cks_ok}/2" | |
| # ---- s3+s4: testes novos T-V3 e CK contabilizados no cargo (via 76) | |
| tel = carrega("telemetria_v010.json") | |
| if tel: | |
| n_novos = tel["testes"]["cargo_total"] - tel["testes"]["herdados_v090"] | |
| rel["gates"]["s3s4_testes_novos_16"] = (n_novos >= 16) | |
| rel["medicoes"]["testes_novos_v010"] = n_novos | |
| rel["blocos"]["s3s4_tipos_trait"] = "1/1" if rel["gates"].get("s3s4_testes_novos_16") else "0/1" | |
| # ---- s5: treino real v0.10.0 | |
| treino = {} | |
| for f, chave in (("fase_a_v010.json", "a"), ("fase_b_v010.json", "b")): | |
| d = carrega(f) | |
| if d: | |
| treino[chave] = d["resumo"] | |
| d = carrega("treino_v090.json") | |
| c = (d or {}).get("fases", {}).get("c", {}) | |
| g5 = [] | |
| g5.append(("s5a_faseA_perda_cai", treino.get("a", {}).get("perda_final", 1e9) | |
| < treino.get("a", {}).get("perda_inicial", -1e9))) | |
| g5.append(("s5b_faseB_perda_cai", treino.get("b", {}).get("perda_final", 1e9) | |
| < treino.get("b", {}).get("perda_inicial", -1e9))) | |
| g5.append(("s5c_faseC_ce_cai", c.get("ce_final", 1e9) < c.get("ce_inicial", -1e9))) | |
| delta_ort = treino.get("a", {}).get("delta_ort_max", 1.0) | |
| g5.append(("s5d_ortogonalidade_exata", delta_ort < 1e-5)) | |
| for nome, val in g5: | |
| rel["gates"][nome] = val | |
| rel["medicoes"]["treino_real"] = { | |
| "a": {"perda_inicial": treino.get("a", {}).get("perda_inicial"), | |
| "perda_final": treino.get("a", {}).get("perda_final"), | |
| "delta_ort_max": delta_ort}, | |
| "b": {"perda_inicial": treino.get("b", {}).get("perda_inicial"), | |
| "perda_final": treino.get("b", {}).get("perda_final")}, | |
| "c": {"ce_inicial": c.get("ce_inicial"), "ce_final": c.get("ce_final"), | |
| "taxa_gatilho": c.get("taxa_gatilho_media")}, | |
| } | |
| rel["blocos"]["s5_treino_real"] = f"{sum(1 for _, v in g5 if v)}/{len(g5)}" | |
| # ---- s6: CLI | |
| cli = os.path.join(PASTA, "scripts", "75_cli.py") | |
| r1 = subprocess.run([sys.executable, cli, "versao"], capture_output=True, text=True) | |
| r2 = subprocess.run([sys.executable, cli, "estados"], capture_output=True, text=True) | |
| r3 = subprocess.run([sys.executable, cli, "verificar-checkpoints"], | |
| capture_output=True, text=True) | |
| rel["gates"]["s6_cli_comandos"] = all( | |
| r.returncode == 0 for r in (r1, r2, r3)) and "0.10.0" in r1.stdout | |
| rel["medicoes"]["cli"] = {"versao": r1.stdout.strip().splitlines()[0], | |
| "checkpoints_relacionados": len(r3.stdout.strip().splitlines())} | |
| rel["blocos"]["s6_cli"] = "1/1" if rel["gates"]["s6_cli_comandos"] else "0/1" | |
| # ---- veredito | |
| gates = rel["gates"] | |
| ok = sum(1 for v in gates.values() if v is True) | |
| rel["veredito"] = f"{ok}/{len(gates)} — " + ( | |
| "APROVADO" if ok == len(gates) else "REPROVADO") | |
| saida = os.path.join(R, "suite_v010_final.json") | |
| json.dump(rel, open(saida, "w"), indent=1, ensure_ascii=False) | |
| print(f"OK: {saida}") | |
| print("blocos:", json.dumps(rel["blocos"], ensure_ascii=False)) | |
| print("VEREDITO:", rel["veredito"]) | |
| falhas = [k for k, v in gates.items() if v is not True] | |
| if falhas: | |
| print("falhas:", falhas) | |
| if __name__ == "__main__": | |
| main() | |