KHTST_RUST v0.3.0 — correções M1-M17 (vazamento do prefixo, paridade treino/inferência, SSD-Δ, STE, PCGrad, telemetria JSONL) + aprimoramentos com prova: mistura de planos, SSD-Δ (inteiros/floats), verificador algébrico, ADBA por (nível, cabeça); gates G1-G12; treino real Wikipédia PT-BR

Cargo.lock

@@ -31,12 +31,6 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
-[[package]]
-name = "anyhow"
-version = "1.0.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
-
 [[package]]
 name = "arc-swap"
 version = "1.9.3"
@@ -302,17 +296,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "dict_derive"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "846a520b3b7937dcfe564d9674d2d26da9e3cd0f8f1bbef51ca42fd6b7bb4f4a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "dyn-stack"
 version = "0.13.2"
@@ -734,16 +717,13 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "khtst-rust"
-version = "0.1.11"
+version = "0.3.0"
 dependencies = [
- "anyhow",
  "built",
  "candle-core",
  "candle-nn",
  "crossbeam-channel",
- "dict_derive",
  "log",
- "numpy",
  "pyo3",
  "pyo3-async-runtimes",
  "pyo3-built",
@@ -753,7 +733,6 @@ dependencies = [
  "rayon",
  "serde",
  "serde_json",
- "thiserror 2.0.21",
  "tokio",
 ]
 
@@ -797,16 +776,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
 
-[[package]]
-name = "matrixmultiply"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
-dependencies = [
- "autocfg",
- "rawpointer",
-]
-
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -860,21 +829,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "ndarray"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
-dependencies = [
- "matrixmultiply",
- "num-complex",
- "num-integer",
- "num-traits",
- "portable-atomic",
- "portable-atomic-util",
- "rawpointer",
-]
-
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -895,15 +849,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "num-integer"
-version = "0.1.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -924,21 +869,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "numpy"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78"
-dependencies = [
- "libc",
- "ndarray",
- "num-complex",
- "num-integer",
- "num-traits",
- "pyo3",
- "rustc-hash",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -997,15 +927,6 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 
-[[package]]
-name = "portable-atomic-util"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
-dependencies = [
- "portable-atomic",
-]
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1249,12 +1170,6 @@ dependencies = [
  "bitflags",
 ]
 
-[[package]]
-name = "rawpointer"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
-
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -1321,12 +1236,6 @@ version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
-[[package]]
-name = "rustc-hash"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
-
 [[package]]
 name = "rustix"
 version = "1.1.5"
@@ -1471,17 +1380,6 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.119"

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "khtst-rust"
-version = "0.1.11"
+version = "0.3.0"
 edition = "2021"
-description = "KHTST_RUST — refatoração Rust/PyO3 do KHTST com NCM (Next-Concept Modeling), provas integradas, atenção ADBA e ponte duplex"
+description = "KHTST_RUST — refatoração Rust/PyO3 do KHTST com NCM (Next-Concept Modeling), provas integradas, ADBA por (nível, cabeça), ponte duplex, cabeça de mistura de planos, SSD-Δ (percepção de inteiros/floats) e verificador algébrico"
 license = "Apache-2.0"
 
 [lib]
@@ -11,23 +11,24 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 pyo3 = { version = "0.23", features = ["abi3-py310"] }
-numpy = "0.23"
 pythonize = "0.23"
 pyo3-log = "0.12"
-dict_derive = "0.5"
 pyo3-built = "0.5"
 pyo3-async-runtimes = { version = "0.23", optional = true, features = ["tokio-runtime"] }
 tokio = { version = "1", features = ["rt-multi-thread"], optional = true }
 candle-core = "0.11"
 candle-nn = "0.11"
 crossbeam-channel = "0.5"
+# rayon: paralelismo real (scan SSD por lote, AdamW por variável — A35/M17).
 rayon = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-anyhow = "1"
-thiserror = "2"
 log = "0.4"
 rand = "0.8"
+# v0.3.0 (A14/decisão do usuário): REMOVIDAS as dependências não usadas —
+# `numpy` (rust-numpy), `dict_derive`, `anyhow`, `thiserror`. O binding de
+# sequências permanece Vec<Vec<u32>> (2,4 MB para 2 394×256 — cópia
+# desprezível; rust-numpy seria peso morto aqui).
 
 [build-dependencies]
 built = "0.8"

README.md

@@ -1,19 +1,30 @@
 # KHTST_RUST — Next-Concept Modeling em Rust/PyO3
 
-Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`, e dois aprimoramentos novos: **ADBA** (atenção adaptativa no processamento paralelo) e **Ponte Duplex** (comunicação bidirecional simultânea entre modelos).
+Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`.
+
+## v0.3.0 — correções auditadas + aprimoramentos com prova
+
+A v0.1.11 foi auditada por agente independente (r-08: **17 defeitos M1–M17**, ~40 afirmações documentais refutadas — o central: a máscara deixava o prefixo 100% bloqueado ⇒ softmax uniforme ⇒ **vazamento do futuro**, quebrando a fatoração next-concept em todas as passadas de treino, invisível ao V4 que contava a matriz). A v0.3.0 corrige tudo e adiciona três aprimoramentos com demonstrações:
+
+1. **Mistura de planos** (raciocínio em subníveis paralelos): `p(c_ℓ|c_{<ℓ}) = Σ_m w_m Π_i q_{m,i}` — M planos de raciocínio paralelos por nível. **Teo C-1**: MLE exato, NFE = L, amostragem paralela intra-nível, contenção estrita (M=1 ≡ v0.1.11 bit-a-bit — gate G9), normalização Σ_c p(c)=1 por enumeração exausta (gate G12).
+2. **SSD-Δ** (percepção de matemática de inteiros/ponto flutuante): porta aditiva de 2ª ordem `h_t = a_t⊙h_{t−1} + (1−a_t+η_t)⊙x_t`. **Teo S-1**: com a=1, η=1 o slot computa a **soma acumulada EXATA** para inteiros < 2^24 (gate G8a, bit-a-bit); para floats, erro ≤ 2e^{−2ρ}·Σ|x| + cota clássica ε_mach (gate G8b); contenção estrita provada (a família antiga não representa o mapa soma).
+3. **Verificador algébrico** da hierarquia: `L_alg = Σ_ℓ ‖Interp_{n_{ℓ−1}}(ẑ_ℓ^{soft}) − ẑ_{ℓ−1}‖²` — quadrática com solução em forma fechada (equações normais — **Teo G-1**), gradiente exato validado por diferenças finitas (gate G11), com cota inferior auditável.
+
+Também: **ADBA por (nível, cabeça)** com parametrização limitada tanh (Teo A-1 — sem dead-gradient, τ ∈ [e⁻¹,e], w ∈ [e⁻²,e²], nascimento neutro), estado do SSD transportado entre níveis (M4), paridade treino↔inferência estrutural (M2 — âncora do buffer pós-bloco-0, gate G2: Δ ≤ 2e-6), reprodutibilidade bit-a-bit por semente (A19, gate G7), checkpoint com manifesto+fsync (A20/A21), **retomada** de treino (estado do otimizador serializado — proteção contra encerramento em background).
 
 ## O que é
 
-- **Tokenizador de conceitos** (Estágio A): VQ-VAE residual multiscale com codebooks **Stiefel/RCO** e quantização **GSQ** (Gumbel-Softmax com gradiente exato) — contração geométrica (1−1/K) por nível (Teo A.1/D.4), nested dropout (prefixos anytime, Teo A.2).
-- **Gerador next-concept** (Estágio B): fatoração `p(c) = Π_ℓ p(c_ℓ|c_{<ℓ})` com predição **paralela** intra-nível — **MLE exato sem ELBO** (Teo B.1), **NFE = L** (7 ≪ 256; Teo B.2), corrupção de condicionamento como DRO (Teo C.3), MTP ⊂ NCM (Teo D.6), PCGrad (Teo D.7).
-- **Tronco híbrido 5:1**: 5 camadas **ADBA** + 1 slot **Mamba-3 SSD** (scan diagonal com adjunto exato) — máscara block-causal com 0 vazamentos (Teo D.1, V4).
-- **Ponte Duplex**: A↔B com canais limitados, rodadas com timeout — sem deadlock estrutural (Teo P.1), direções simultâneas medidas (P.2).
-- **Telemetria completa**: séries JSONL, escore de aprendizado, **ajuste automático auditado** de LR/clip/ε/λ/τ, diagnóstico de erros comuns de refatoração (Levenshtein/taxonomia).
+- **Tokenizador de conceitos** (Estágio A): VQ-VAE residual multiscale com codebooks **Stiefel/RCO** e quantização **GSQ** (gradiente exato) — contração (1−1/K)^ℓ por nível, nested dropout (prefixos anytime).
+- **Gerador next-concept** (Estágio B): fatoração `p(c) = Π_ℓ p(c_ℓ|c_{<ℓ})` com predição **paralela** intra-nível — MLE exato sem ELBO, NFE = L, corrupção κ como DRO, MTP ⊂ NCM, PCGrad (contra os gradientes ORIGINAIS — M8), JEPA com λ por hipergradiente exato (S-09).
+- **Tronco híbrido 5:1**: 5 camadas ADBA + 1 slot Mamba-3 **SSD-Δ** (adjunto exato incl. ∂L/∂h₀ e ∂L/∂η — gate G10); máscara block-causal com prefixo causal (M1) e **vazamento efetivo zero** (gate G1).
+- **Ponte Duplex**: A↔B com canais limitados, `send_timeout` em threads separadas (M13), sobreposição medida por interseção real de janelas (M14), GIL liberado.
+- **Telemetria completa**: **uma linha JSONL por passo com todas as séries** (M12 — a v0.1.11 gravava 0–1 linhas), modo append (A24), detecção de aprendizado com limiares e eventos (S-05), ajuste automático auditado de LR (multiplicador com recuperação — M9)/clip/ε/λ/τ, CE por nível, contração por nível, resíduo algébrico, entropia dos planos, diagnóstico de erros com análise de digitação (lint Levenshtein chamado pelos scripts).
 
 ## Instalação
 
 ```bash
 pip install khtst_rust-*.whl   # wheel abi3 (Python ≥ 3.10, manylinux)
+pip install ".[data,publish]"  # dependências dos scripts (A13)
 # ou do fonte: maturin build --release && pip install target/wheels/*.whl
 ```
 
@@ -22,47 +33,53 @@ pip install khtst_rust-*.whl   # wheel abi3 (Python ≥ 3.10, manylinux)
 ```python
 import khtst_rust as K
 
-cfg = K.Config("configs/base_rust.json")          # valida + orçamento de cache
-bpe = K.Bpe.treinar(textos, 16384)                # BPE byte-level próprio
+cfg = K.Config("configs/base_rust.json")          # valida + orçamento de cache (516)
+bpe = K.Bpe.treinar(textos, 16384)                # BPE byte-level (roundtrip exato)
 
 # Fase A: tokenizador (nested dropout + GSQ/RCO Stiefel)
 K.treinar_fase_a(cfg, sequencias, caminho_telemetria="tel_a.jsonl",
-                 caminho_checkpoint="tokenizador.json", teto_seg=430)
+                 caminho_checkpoint="tokenizador.json", teto_seg=430,
+                 callback=print, retomar=False)
 
-# Fase B: gerador (MLE exato + κ + MTP + JEPA + PCGrad)
+# Fase B: gerador (mistura de planos + SSD-Δ + L_alg + PCGrad)
 K.treinar_fase_b(cfg, sequencias, "tokenizador.json",
                  caminho_telemetria="tel_b.jsonl",
-                 caminho_checkpoint="gerador.json", teto_seg=330)
+                 caminho_checkpoint="gerador.json", teto_seg=330,
+                 retomar=True)   # continua de .estado.json se existir
 
-# Geração paralela: NFE = L; parada anytime em qualquer prefixo
-g = K.gerar_amostras(cfg, "tokenizador.json", "gerador.json", n_amostras=2)
-assert g["nfe"] == 7  # = L
+# Verificações de função (não de estrutura)
+assert K.verificar_vazamento_efetivo(cfg) == 0     # gate G1
+assert K.verificar_paridade(cfg)["dif_max"] < 1e-4 # gate G2
 
-# Ponte duplex entre modelos
-p = K.PonteDupla(capacidade=64, timeout_ms=2000)
-est = p.demo_professor_aluno(rodadas=200, dim=24)
+# Geração paralela: NFE = L; anytime; MBR opcional; semente/max_tokens livres
+g = K.gerar_amostras(cfg, "tokenizador.json", "gerador.json",
+                     n_amostras=2, semente=7, max_tokens=64, n_cand=3)
+assert g["nfe"] == 7  # = L
 ```
 
 ## Estrutura
 
 ```
-src/            19 módulos Rust (ver docs/memorias/r-02-arquitetura.md)
-configs/        base_rust.json (espelho do base.json v23 + seção ncm)
-scripts/        39_coletar_dados.py · 40_treinar.py · 41_teste.py · 42_publicar.py
-docs/memorias/  r-01..r-07 (diagnóstico, arquitetura, rastreabilidade provas→código,
-                prova ADBA, prova ponte duplex, telemetria, resultados)
-resultados/     checkpoints, telemetria JSONL, suíte V, resumo de treino
+src/            22 módulos Rust (r-02 §1 + rng.rs; ver docs/memorias/)
+tests/provas.rs gates G1–G12 (provas executáveis — regra da casa:
+                "contar a estrutura não é verificar a função")
+configs/        base_rust.json (v0.3: ssd_delta, mistura_planos=4, algebrico, semente)
+scripts/        39_coletar · 40_treinar (--retomar) · 41_teste · 42_publicar (allowlist)
+docs/memorias/  r-01..r-09 (…, r-08 auditoria v0.2.0, r-09 aprimoramentos v0.3.0)
+docs/memoria-ncm-khtst/  n-00..n-04 (teoria NCM: 20 Teos + 10 corolários + T1–T10)
+resultados/     checkpoints (manifesto khtst-ckpt-v2), telemetria JSONL, suíte V
 ```
 
-## Verificações
+## Verificações (v0.3.0)
 
-- **15/15 testes cargo** (adjuntos validados contra diferenças finitas e implementação nativa)
-- **Suíte V**: 7/7 bloqueadoras verdes (V0,V1,V4,V9,V10,V13,V14) + evidenciais
-- **Treino real** (Wikipédia PT-BR, streaming controlado): fase A perda 9,89→8,11, δ_ort ≤ 9,9e-7 durante o treino, codebook 52/64 sem colapso; fase B CE 4,19→3,98; geração NFE=7, anytime k=3
+- **37/37 testes cargo (release)**: 29 unitários + 8 gates (G1–G12; inclui adjuntos vs FD com ∂L/∂h₀ e ∂L/∂η, acumulação inteira exata e float com cota, estado SSD transportado, normalização da mistura por enumeração)
+- **Suíte V**: **9/9 bloqueadoras** (V0, V1, V4 matriz+efetivo, V2 paridade, V9 δ_ort do codebook TREINADO, CKPT manifesto, V10 NFE=7/anytime=3, V13 com limiar real, V14 ponte, V5b do config) + V16 aritmética **evidencial** com leitura honesta
+- **Treino real** (Wikipédia PT-BR, 1 200 artigos, janelas completas de 256): fase A perda 9,91→**5,17** (métrica homóloga, mesmo lote/RNG), acc_recon **31,2%**, δ_ort ≤ 9,3e-7, codebook 59,6/64, resíduo algébrico 0,0011; fase B CE 4,10→**3,84** (0,32 nats abaixo do acaso ln 64), resíduo algébrico 0,0002; geração NFE=7 (105 ms), anytime k=3
+- Dois bugs críticos encontrados e corrigidos pelos próprios gates/asserts: `softmax_last_dim` do candle-nn 0.11 é `apply_op1_no_bwd` (**sem gradiente** — teria zerado o treino da mistura e do verificador) e o BPE da v0.1.11 corrompia UTF-8 multibyte no decode (vocab com U+FFFD — escondido pelo teste tautológico A11)
 
 ## Provas e teoria
 
-Toda a fundamentação matemática (20 teoremas + 10 corolários da integração NCM×KHTST; Teos R.1–R.3 da ADBA; Teos P.1–P.3 da ponte duplex) está em `docs/memorias/` com rastreabilidade teorema→código→verificação (r-03).
+Toda a fundamentação em `docs/memorias/`: 20 teoremas + 10 corolários NCM×KHTST (n-02/n-03), Teos R.1–R.3 (ADBA), P.1–P.3 (ponte), **M-1/M-8/M-9/C-2/S-1/G-1/T-1/A-1/C-1/R-1** (v0.2/v0.3 — ver r-08/r-09) com rastreabilidade teorema→código→gate.
 
 ## Convenções herdadas do projeto
 

configs/base_rust.json

@@ -14,60 +14,46 @@
       "k_cabecas": 2,
       "beta_entropia": 0.05,
       "k_adaptativo": true
-    }
+    },
+    "ssd_delta": true
   },
   "ncm": {
     "ativo": true,
-    "niveis": [
-      4,
-      8,
-      16,
-      32,
-      64,
-      128,
-      256
-    ],
+    "niveis": [4, 8, 16, 32, 64, 128, 256],
     "d_lat": 64,
     "k_por_nivel": 64,
     "ema_codebook": 0.99,
     "beta_commit": 0.25,
-    "nested_dropout": {
-      "tipo": "uniforme"
-    },
+    "nested_dropout": { "tipo": "uniforme" },
     "corrupcao_cond": 0.15,
     "dropout_cfg": 0.1,
     "cfg_scale": 1.0,
-    "gsq": {
-      "tau0": 1.0,
-      "tau_min": 0.5,
-      "t_alvo": 400
-    },
+    "gsq": { "tau0": 1.0, "tau_min": 0.5, "t_alvo": 400 },
     "pesos_nivel": "uniforme",
     "lambdas": {
-      "conceito": 0.0,
+      "conceito": 1.0,
       "rec": 1.0,
-      "rho_ancora": 0.05
+      "rho_ancora": 0.05,
+      "algebrico": 0.05
     },
     "temperaturas": {
       "auto": true,
-      "entropia_alvo": null,
-      "limites": [
-        0.5,
-        1.5
-      ]
-    },
-    "mbr": {
-      "n_cand": 1
+      "entropia_alvo": 0.8,
+      "limites": [0.5, 1.5]
     },
+    "mbr": { "n_cand": 1 },
     "escala_r": "ema_projecao",
     "modo_quantizacao": "gsq_rco",
-    "niveis_token": false
+    "niveis_token": false,
+    "mistura_planos": 4
   },
   "adba": {
     "ativo": true,
     "gamma_ancora": 1.0,
     "reponderacao_nivel": true,
-    "temperatura_nivel": true
+    "temperatura_nivel": true,
+    "limite_log_w": 2.0,
+    "limite_tau": 1.0
   },
   "ponte": {
     "ativo": true,
@@ -83,14 +69,17 @@
     "lote": 4,
     "clip": 1.0,
     "peso_decaimento": 0.01,
-    "telemetria_a_cada": 25
+    "telemetria_a_cada": 25,
+    "semente": 317,
+    "checkpoint_a_cada": 100
   },
   "telemetria": {
     "jsonl": true,
     "deteccao_aprendizado": true,
     "ajuste_automatico": true,
     "paciencia_plateau": 120,
-    "fator_lr_plateau": 0.6
+    "fator_lr_plateau": 0.6,
+    "truncar_jsonl": false
   },
   "dados": {
     "shard_treino": "dados/shard_treino.jsonl",
@@ -103,4 +92,4 @@
     "lambda_jepa": 0.1,
     "rm_dois_tempos": true
   }
-}
+}

docs/memorias/r-08-auditoria-correcoes-v020.md

@@ -0,0 +1,133 @@
+# r-08 — AUDITORIA E CORREÇÕES v0.2.0 (memória do projeto KHTST_RUST)
+
+> **Coleção**: `memoria-khtst-rust` · **Objeto**: auditoria do repo `PowerMachine/khtst-rust`
+> (v0.1.11) e o patch set v0.2.0 · **Data**: 2026-10-24 · **Ambiente**: 2 vCPU, 3,0 GiB RAM,
+> sem GPU, Rust 1.99.1, candle 0.11, PyO3 0.23, Python 3.11.2.
+
+---
+
+## 0. TESE (uma frase)
+
+**O `khtst-rust` publicado treina um modelo que vaza o futuro.** A máscara block-causal
+deixava as 8 posições de prefixo **totalmente bloqueadas**; o softmax de uma linha
+totalmente bloqueada **não é nulo — é uniforme** (o softmax subtrai o máximo, logo
+`exp(x−max)=1` para toda entrada). O prefixo passava a enxergar a sequência inteira,
+inclusive os **níveis futuros**; e como o prefixo é visível por todos os blocos, existia o
+caminho `nível futuro → prefixo → nível ℓ`. A fatoração next-concept (Teo B.1/D.1) —
+o eixo de toda a teoria do projeto — estava quebrada em todas as passadas de treino
+publicadas, e a suíte de verificação não podia ver isso porque o V4 contava a **matriz**
+da máscara, não o **efeito**.
+
+---
+
+## 1. O GATE (a prova que faltava)
+
+A afirmação que precisa ser verificada é uma afirmação sobre **função**, não sobre
+**estrutura**:
+
+$$
+\forall m \text{ que altera só } s_{>\ell}:\quad
+\big\|F_\ell(s^{(m)}) - F_\ell(s)\big\|_\infty = 0 ,
+\qquad F_\ell := h_\ell \text{ (saída do nível ℓ)}
+$$
+
+| versão | `DIF_VAZAMENTO_NIVEL1` | veredito |
+|---|---|---|
+| 0.1.11 (publicada) | **0,10902858** | ❌ vaza |
+| 0.2.0 (patch) | **0,00000000** | ✅ não vaza |
+
+Teste: `work/tests/provas.rs::gate_vazamento_efetivo_zero` (idêntico em
+`testes_comparativos/tests/vazamento.rs`, para rodar em qualquer das duas árvores).
+
+**Generalização (regra da casa):** *contar a estrutura não é verificar a função.* O V4
+contava zeros na matriz; o defeito era um softmax degenerado. O mesmo se aplica ao V13
+(`ok: True` incondicional) e ao V5b (constante literal): são verificações que não
+verificam nada. **Regra nova para o projeto: nenhuma verificação V pode ser aceita sem
+um `assert`/comparação que falhe se o invariante quebrar** — e, quando o invariante for
+sobre *informação*, a verificação tem de medir *informação* (perturbar o futuro e medir a
+resposta), não a *representação* do invariante.
+
+---
+
+## 2. As 17 correções (M1…M17) — índice
+
+| id | defeito | arquivo:linha (0.1.11) | gravidade | correção |
+|---|---|---|---|---|
+| M1 | prefixo totalmente mascarado ⇒ softmax uniforme ⇒ vazamento | `mascaras.rs:19-33` | 🔴 | prefixo causal + `linhas_sem_visivel()` + `mascara_incremental()` |
+| M2 | âncora/FiLM só no treino | `tronco.rs:135-154` | 🔴 | âncora sobre a **entrada** (idêntica nos 2 caminhos) + gate G2 |
+| M3 | nascimento neutro falso (γ=1) | `tronco.rs:47` | 🔴 | γ=0 (como a spec `scripts.txt`) |
+| M4 | estado do scan SSD descartado | `ssd.rs:105-108`, `tronco.rs:151` | 🔴 | `CustomOp3` com `h₀` + estado transportado |
+| M5 | τ sem limite | `atencao.rs:116` | 🟠 | `τ = exp(T·tanh(log τ))`, T=1 |
+| M6 | `w` com clamp de gradiente morto | `atencao.rs:101-112` | 🟠 | `log w = L_W·tanh(ξ)`, L_W=2, + por (nível, cabeça) |
+| M7 | STE com gradiente nulo | `quantizador.rs:200-204` | 🟠 | `z + sg[r−z]` |
+| M8 | PCGrad decide com ⟨g_i,g_j⟩ obsoleto | `treino.rs:112-138` | 🟠 | recalcular a cada par |
+| M9 | LR ratchet + "rollback" inexistente | `controlador.rs:86` | 🟠 | multiplicador com recuperação |
+| M10 | passo com perda não finita aplicado | `treino.rs:284-287` | 🔴 | descartar o passo **antes** |
+| M11 | semente de RNG colidida entre níveis | `quantizador.rs:139-151` | 🟠 | semente inclui o nível |
+| M12 | telemetria "completa" inexistente | `telemetria.rs:55-63` | 🟠 | séries no JSONL + `ce_nivel_ℓ` |
+| M13 | ponte congela o interpretador (GIL + `send` sem prazo) | `lib.rs:175-179`, `ponte.rs:94,96` | 🔴 | `allow_threads` + `send_timeout` |
+| M14 | "simultaneidade" da ponte = artefato | `ponte.rs:93-116` | 🟠 | interseção real das janelas |
+| M15 | orçamento do KV-cache ignorava o prefixo | `config.rs:336-346` | 🟡 | `N_PREFIXO + Σn_ℓ` = 516 |
+| M16 | matriz de interpolação reconstruída no laço quente | `mascaras.rs:65-107` | 🟡 | memoização thread-local |
+| M17 | decoder AR O(n²) + laços por amostra | `tokenizador.rs:266-295`, `ssd.rs:110` | 🟡 | cache KV + scan batched |
+
+Detalhamento e evidência: `relatorio/APRIMORAMENTO_KHTST_RUST.md` e
+`relatorio/A_execucao.md`.
+
+---
+
+## 3. As 6 portas (gates) do patch v0.2.0
+
+`G1` vazamento efetivo · `G2` paridade treino↔inferência (nível 1) · `G3` paridade no
+nível 2 **com estado do SSD** · `G4` nenhuma linha totalmente bloqueada · `G5` nascimento
+neutro · `G6` orçamento do KV-cache com prefixo.
+
+**24/24 testes verdes** (`cargo test --release`): 15 originais + 3 unitários novos + 6 gates.
+
+---
+
+## 4. Onde a "capacidade de lógica e computação matemática" deve entrar
+
+Não na atenção. Argumento (formalizado em `relatorio/C_proposta_matematica.md` §B):
+
+$$
+\min_{p\in\mathcal M}\mathrm{KL}(q\|p) = \sum_\ell \mathbb E[\mathrm{TC}(c_\ell\mid c_{<\ell})]
+$$
+
+O gap é **invariante** a qualquer mudança na ADBA (a atenção é transporte) e no SSD
+(memória). A *forma funcional* é decidida na **cabeça de conceitos** (produto de
+softmaxes independentes ⇒ `K−1` bits independentes por posição) e num **verificador
+algébrico** da hierarquia. Métodos propostos (com prova e critério de falsificação):
+
+1. **Mistura de planos** na cabeça: `p(c_ℓ|c_{<ℓ}) = Σ_m w_m Π_i q_{m,i}` — contém
+   estritamente o produto, preserva MLE exato (B.1), NFE = L (B.2) e o paralelismo
+   intra-nível; custo `O(M·n_ℓ·K)`.
+2. **Verificação algébrica** da hierarquia: `L_recomp = Σ_ℓ ‖Interp(ẑ_{ℓ−1}) − ẑ_{ℓ−1}‖²`
+   — quadrático com solução em forma fechada (projeção), auditável.
+3. **SSD de 2ª ordem / portão dependente do estado** — o slot passa a representar
+   *diferenças* (a "derivada de conceito"); adjunto exato validado por diferenças finitas
+   (o teste FD do repo foi estendido ao novo gradiente `∂L/∂h₀`).
+4. **ADBA por (nível, cabeça)** com limite (implementado) — aumenta o poder expressivo da
+   ADBA sem tocar na fatoração.
+
+---
+
+## 5. Leitura honesta do que o gerador é
+
+Com `gerador.rs:153` (`zhat_anterior = None` no nível 1), `p(c₁)` é **incondicional**:
+o gerador é uma **prior** sobre hierarquias de conceito, e o texto entra só como fonte
+de códigos no treino. As 8 posições de prefixo são **constantes** (8 cópias do embedding
+0): não transportam condição e consomem 8/516 do orçamento de atenção. Ou lhes dá
+conteúdo (slot de condição), ou as remove. **Não é bug de codificação — é lacuna de
+projeto não declarada.**
+
+---
+
+## 6. Limites desta auditoria
+
+- Sem GPU: nada foi testado em NPU/MUSA/DCU (vale a análise estática da matriz de backends).
+- O A/B de treino (120 passos, 495 artigos PT-BR reais) demonstra **efeito mecânico**, não
+  desempenho de modelo; o que sustenta a conclusão é o **gate determinístico**.
+- λ (hipergradiente-âncora) e `ncm.ativo`/`lambdas.conceito` continuam **não integrados** —
+  declarados, não escondidos.
+- Mistura de planos e verificador algébrico: **especificados com prova, não implementados**.

docs/memorias/r-09-aprimoramentos-v030.md

@@ -0,0 +1,180 @@
+# r-09 — APRIMORAMENTOS v0.3.0: MISTURA DE PLANOS, SSD-Δ, VERIFICADOR ALGÉBRICO (memória do projeto KHTST_RUST)
+
+> **Coleção**: `memoria-khtst-rust` · **Objeto**: aplicação das correções M1–M17
+> (r-08) + aprimoramentos com prova matemática/lógica/computacional +
+> telemetria completa + treino real + publicação · **Data**: 2026-10-24 ·
+> **Ambiente**: 2 vCPU, 4,0 GiB RAM, sem GPU · Rust 1.99.1 · candle 0.11 ·
+> PyO3 0.23 · Python 3.12 (venv) · maturin 1.15.
+
+---
+
+## 0. TESE (uma frase)
+
+A v0.3.0 fecha o vazamento do prefixo e a quebra de paridade da v0.1.11
+(correções M1–M17 da auditoria r-08), adiciona **três aprimoramentos com
+demonstração** — mistura de planos (raciocínio em subníveis paralelos),
+SSD-Δ (percepção de inteiros/floats por acumulação exata) e verificador
+algébrico da hierarquia (quadrática com solução em forma fechada) — e **dois
+bugs críticos adicionais foram descobertos pelos próprios gates** (o
+`softmax_last_dim` do candle-nn 0.11 é `apply_op1_no_bwd` — sem gradiente; e
+o BPE da v0.1.11 corrompia UTF-8 multibyte no decode), validando a regra da
+casa: *verificação que não pode falhar não verifica nada*.
+
+---
+
+## 1. CORREÇÕES APLICADAS (M1–M17 da r-08 + A-série)
+
+| id | correção | onde | verificação |
+|---|---|---|---|
+| M1 | prefixo causal na máscara (softmax uniforme ⇒ vazamento do futuro) | `mascaras.rs` | **G1** (efetivo = 0), **G4** |
+| M2 | âncora/FiLM no caminho incremental (buffer pós-bloco-0) | `tronco.rs::forward_nivel` | **G2** (dif_max ≤ 2e-6, 7 níveis) |
+| M3 | γ=0 no nascimento (FiLM identidade exata) | `tronco.rs` | **G5** (bit-a-bit) |
+| M4 | estado SSD transportado entre níveis (h₀ no CustomOp3) | `ssd.rs` | **G3** (scan particionado ≡ completo) |
+| M5/M6 | τ ∈ [e⁻¹,e], log w ∈ [−2,2] por (nível, cabeça), sem clamp morto | `atencao.rs` | **Teo A-1**; vetores via index_select |
+| M7 | STE `z + sg[r−z]` (gradiente unitário) | `quantizador.rs` | teste `ste_gradiente_unitario` |
+| M8 | PCGrad contra gradientes ORIGINAIS | `treino.rs::pcgrad_achatado` | `gate_m8_pcgrad_nao_piora` |
+| M9 | LR: multiplicador com recuperação (fim do ratchet) | `controlador.rs` | teste `multiplicador_recupera` (**Teo C-2**) |
+| M10 | passo não finito descartado ANTES de aplicar | `treino.rs` | (ordem no código) |
+| M11 | semente por nível (ruído Gumbel i.i.d.) | `quantizador.rs` | teste `sementes_por_nivel_distintas` |
+| M12 | **uma linha JSONL por passo com todas as séries** | `telemetria.rs::fechar_passo` | teste `series_vao_para_o_jsonl` |
+| M13 | ponte: `send_timeout` + threads separadas + `py.allow_threads` | `ponte.rs`, `lib.rs` | V14 (200 rodadas, 0 timeouts) |
+| M14 | sobreposição = interseção REAL das janelas | `ponte.rs` | (métrica honesta) |
+| M15 | orçamento KV-cache = N_PREFIXO + Σn_ℓ = **516** | `config.rs` | V1 |
+| M16 | matriz de interpolação memoizada (thread-local) | `mascaras.rs` | teste `interp_memoizada` |
+| M17 | decoder AR com KV-cache O(n); âncora batched; scan rayon | `tokenizador.rs`, `atencao.rs`, `ssd.rs` | geração 105 ms (vs 286 ms v0.1.11) |
+| A19 | RNG global semeado — reprodutibilidade bit-a-bit | `rng.rs` (novo módulo) | **G7** |
+| A20/A21 | checkpoint com manifesto + fsync + rename atômico | `tokenizador.rs::salvar_atomico` | `CKPT_manifesto` (56+102 vars) |
+| A22 | JEPA/SOM/otimizador no `.estado.json` ⇒ **RETOMADA** | `treino.rs::EstadoTreino` | teste manual (400→403 passos) |
+| A25 | `deny_unknown_fields` em TODO o config | `config.rs` | teste `chave_errada_falha` |
+| A26 | chaves_conhecidas derivadas do serde (fonte única) | `diagnostico.rs` | — |
+| A13/A14 | deps declaradas (pyproject) + **removidas** numpy/dict_derive/anyhow/thiserror | `Cargo.toml`, `pyproject.toml` | — |
+| A01–A05 | publicação: allowlist, token com `os.environ.pop`, caminhos relativos | `scripts/42_publicar.py` | — |
+| A06–A12, A15, A27, A37 | scripts 39/40/41 corrigidos (teto passado, callback, split semeado, roundtrip estrito, janelas completas, lint primeiro, V13/V5b reais) | `scripts/` | — |
+
+---
+
+## 2. APRIMORAMENTOS COM PROVA (pedido do usuário)
+
+### 2.1 Mistura de planos — raciocínio em subníveis paralelos (Teo C-1)
+
+`p(c_ℓ|c_{<ℓ}) = Σ_{m=1}^{M} w_m(h̄_ℓ) Π_i q_{m,i}(c_{ℓ,i})`, w = softmax(U·h̄_ℓ)
+(h̄_ℓ = média do nível — função de c_{<ℓ} apenas). Implementada em
+`tronco.rs::CabecaMistura` (M=4 no config publicado; M=1 = v0.1.11).
+
+**Demonstrações** (r-09 §2 completo no código):
+- **MLE exato**: Σ_c p(c) = Σ_m w_m Π_i Σ_k q = 1 (normalização analítica) —
+  verificada por **enumeração exausta** em K^n pequeno (G12: Σ = 1 ± 1e-4);
+- **NFE = L** preservado (a cabeça não avalia o gerador);
+- **amostragem paralela intra-nível**: 1 sorteio de plano + n_ℓ sorteios
+  independentes (0 passos sequenciais — a propriedade central do NCM);
+- **contenção estrita**: M=1 ⇒ NLL/posição ≡ CE da cabeça produto (G9,
+  diferença < 1e-4 com os MESMOS pesos); com M ≥ 2 a marginal conjunta tem
+  covariância intra-nível ≠ 0 ⇒ o gap de correlação total condicional
+  (min KL) é redutível;
+- custo O(M·n_ℓ·K) como UM matmul (d, M·K).
+
+### 2.2 SSD-Δ — percepção de inteiros e ponto flutuante (Teo S-1)
+
+`h_t = a_t⊙h_{t−1} + (1−a_t+η_t)⊙x_t`, η = tanh(W_ηx̂+b_η), **nascimento
+neutro** (W_η=0, b_η=0 ⇒ η≡0 ⇒ recorrência da v0.1.11 bit-a-bit).
+
+- **inteiros**: a=1, η=1 ⇒ h_t = h_{t−1}+x_t — soma acumulada **EXATA**
+  para |Σ| < 2^24 (f32 não arredonda) — **G8a verifica bit-a-bit**;
+- **floats**: η = tanh(ρ) ⇒ erro ≤ 2e^{−2ρ}·Σ|x| + (t−1)·ε_mach·Σ|x| —
+  **G8b verifica contra a cota**;
+- **contenção estrita** (prova por contradição em t=2: exigiria 0=1);
+- adjunto exato com ∂L/∂h₀ (estado) e ∂L/∂η — **G10 vs diferenças finitas**.
+
+### 2.3 Verificador algébrico da hierarquia (Teo G-1)
+
+`L_alg = Σ_{ℓ≥2} ‖Interp_{n_{ℓ−1}}(ẑ_ℓ^{soft}) − ẑ_{ℓ−1}‖²` — o refino do
+nível ℓ, projetado de volta à granularidade ℓ−1, deve **preservar o
+conteúdo grosseiro**. Quadrática nas esperanças de código (soft, via
+`materializar_probs`), minimizador relaxado por equações normais (forma
+fechada), gradiente exato — **G11 vs FD**. Série `residuo_algebrico`
+(falsificável: deve CAIR no treino — medimos 0.0011 na fase A, 0.0002 na B).
+
+### 2.4 ADBA por (nível, cabeça) com limites (Teo A-1)
+
+logit = ⟨q,k⟩/(√d_h·τ_{h,λ(i)}) + L_W·tanh(ξ_{h,λ(j)}); ξ=ζ=0 no nascimento
+(w=1, τ=1 — neutro); |log w| ≤ 2, τ ∈ [e⁻¹,e] — sem dead-gradient (tanh tem
+gradiente sech² > 0 em todo R) e sem modo degenerado. Capacidade: R^{H(L+1)}
+= 32 parâmetros/bloco (vs 8 na v0.1.11).
+
+### 2.5 Paralelização (rayon)
+
+Scan SSD por elemento do lote (ordem de laço cache-amigável — A31), AdamW
+por variável (A35), ordem canal-interna contígua. Dependências removidas
+conforme decisão do usuário: **numpy (rust-numpy), dict_derive, anyhow,
+thiserror** — a interface `Vec<Vec<u32>>` copia 2,4 MB (desprezível) e o
+rust-numpy seria peso morto.
+
+---
+
+## 3. BUGS NOVOS DESCOBERTOS PELOS GATES (a regra da casa funcionando)
+
+1. **`softmax_last_dim` do candle-nn 0.11 é `apply_op1_no_bwd`** — SEM
+   backward. Usado em `pesos_planos` (mistura) e no verificador soft, teria
+   **zerado silenciosamente o gradiente** de w e de L_alg. Descoberto pelo
+   gate G11 (gradiente ausente); corrigido por `softmax(…, D::Minus1)`.
+2. **BPE corrompia UTF-8 multibyte**: o vocab inicial usava
+   `String::from_utf8_lossy(&[byte])` — bytes 128–255 viravam U+FFFD (3
+   bytes) e o decode produzia "c￿lulas" para "células". O teste tautológico
+   da v0.1.11 (`or len(rt) > 50`) escondia. Corrigido com mapeamento
+   reversível byte↔char (estilo GPT-2) + roundtrip ESTRITO em 3 amostras +
+   teste `roundtrip_exato_utf8`.
+3. **Offset em custom ops**: `as_slice` devolve o storage INTEIRO — layouts
+   contíguos COM OFFSET (narrow) eram lidos do início. Descoberto pelo gate
+   G3 (scan particionado ≠ completo, dif = 5,27!). Corrigido com
+   `contiguous_offsets()` no SSD e no GSQ.
+4. Máscara da primeira janela incremental: o nível 1 é **bidirecional**
+   intra-bloco no treino (Teo D.1(ii)) mas a máscara estava causal — G2
+   acustou (dif 0,164). Corrigido.
+
+---
+
+## 4. TREINO REAL (leitura honesta)
+
+Dados: Wikipédia PT-BR 20231101 (streaming, tetos do config), 1 200 artigos
+**medidos pós-limpeza** (A09 — a v0.1.11 reportava 6,03 MB medindo texto
+cru; o real pós-limpeza é ~2 MB), split embaralhado semente 1234 (A10),
+BPE 16 384 com **roundtrip exato** (A11), 5 044 janelas completas de 256
+tokens (A15).
+
+| métrica | v0.1.11 (r-07) | v0.3.0 |
+|---|---|---|
+| fase A perda (homóloga) | 9,89→8,11 (métricas INCOMPARÁVEIS na v0.1.11 — R-05) | **9,91→5,17** (mesmo lote/RNG) |
+| acc reconstrução | 17,6% | **31,2%** |
+| perplexidade codebook | 52/64 | **59,6/64** |
+| δ_ort em treino | ≤ 9,9e-7 | ≤ 9,3e-7 |
+| resíduo algébrico | (não existia) | 0,0011 (A) → **0,0002** (B) |
+| fase B CE (homóloga) | 4,19→3,98 | **4,10→3,84** (acaso ln64 = 4,16) |
+| geração | 286 ms/2 amostras | **105 ms** (M17) |
+| vazamento efetivo | 0,109 (r-08) | **0,000000** |
+| paridade treino↔inferência | Δ = 2,89 (r-08) | **Δ ≤ 2e-6** |
+| reprodutibilidade | irreproduzível (A19) | bit-a-bit por semente (G7) |
+
+Suíte V: **9/9 bloqueadoras** + V16 evidencial. Cargo: **37/37 (release)**.
+
+### V16 — prova aritmética (evidencial, leitura honesta)
+
+O MECANISMO é provado deterministicamente (G8a: acumulação inteira exata;
+G8b: float com cota). O probe empírico end-to-end (texto aritmético vs
+controle embaralhado, fine-tune com retomada) mostrou: domínio float
+aprendido (CE 3,61→1,82, −50%) mas **sensibilidade à ordem não emergiu**
+neste orçamento — diagnóstico: o encoder CONGELADO (fase A treinada em
+Wikipédia) produz códigos quase degenerados para texto numérico OOD (o
+probe de inteiros satura em CE = 0 — sem sinal para aprender). Follow-up
+especificado: exposição conjunta das fases A+B a corpora aritméticos.
+
+---
+
+## 5. LIMITES DESTE CICLO
+
+1. Sem GPU; treino de demonstração (400+400 passos, corpus 2 MB).
+2. `maior_sobreposicao_us = 0` na ponte: envios rápidos demais para a
+   resolução de µs com canais de capacidade 8 (a métrica é honesta — a
+   v0.1.11 reportava 5 µs de artefato).
+3. Sensibilidade à ordem aritmética: ver V16 acima.
+4. A retomada não restaura o RNG de lote (a ordem de lotes pós-retomada
+   difere da do run contínuo — documentado).

pyproject.toml

@@ -4,10 +4,17 @@ build-backend = "maturin"
 
 [project]
 name = "khtst-rust"
-version = "0.1.11"
-description = "KHTST_RUST — refatoração Rust/PyO3 do KHTST com NCM, provas integradas, ADBA e ponte duplex"
+version = "0.3.0"
+description = "KHTST_RUST — refatoração Rust/PyO3 do KHTST com NCM, provas integradas, ADBA, ponte duplex, mistura de planos, SSD-Δ e verificador algébrico"
 requires-python = ">=3.10"
 license = { text = "Apache-2.0" }
+# A13 (v0.3.0): dependências DECLARADAS — a v0.1.11 não declarava nenhuma
+# e `pip install .` quebrava os scripts com ModuleNotFoundError.
+dependencies = []
+
+[project.optional-dependencies]
+data = ["datasets>=2.14"]
+publish = ["huggingface_hub>=0.20"]
 
 [tool.maturin]
 python-source = "python"

resultados/resumo_treino.json

@@ -1,34 +1,20 @@
 {
  "fases": {
-  "a": {
-   "passos": 400,
-   "perda_inicial": 9.891,
-   "perda_final": 8.114,
-   "acc_recon": 0.176,
-   "delta_ort_max": 9.9e-07,
-   "perplexidade_codebook": 52.0,
-   "monotonia_prefixo": 0.5,
-   "escore_aprendizado": 0.353,
-   "tempo_s": 337,
-   "dados": "Wikipedia PT-BR 20231101 (streaming, 246 artigos treino)"
-  },
   "b": {
+   "acc_conceitos": 0.05078125,
+   "escore_aprendizado": 0.16710828471470893,
+   "estado_aprendizado": "Estagnado",
    "passos": 400,
-   "perda_inicial": 4.189,
-   "perda_final": 3.975,
-   "acc_conceitos": 0.063,
-   "escore_aprendizado": 0.197,
-   "tempo_s": 223,
-   "nota": "CE parte de ln(64)=4.16 (quase-uniforme) e cai; acc 6.3% vs 1.6% acaso"
+   "perda_final": 3.841543333871024,
+   "perda_inicial": 4.102364335741315,
+   "residuo_algebrico": 0.00021079387564289695
   }
  },
- "geracao": {
-  "nfe": 7,
-  "L": 7,
-  "nfe_anytime_k3": 3,
-  "tempo_ms_2_amostras": 286,
-  "texto": "(vazio — decoder AR com orçamento de 7 min ainda não produz texto; infraestrutura validada)"
- },
- "suite": "7/7 bloqueadoras verdes (V0,V1,V4,V9,V10,V13,V14) + V5b",
- "ambiente": "2 CPUs, 3.9GB RAM, Rust 1.99.1, candle 0.11, maturin 1.15"
+ "versao": "0.3.0 (KHTST_RUST — NCM + provas + ADBA + ponte duplex + mistura de planos + SSD-Δ + verificador algébrico)",
+ "dados": {
+  "sequencias": 5044,
+  "wall_clock": {
+   "b": 400
+  }
+ }
 }

resultados/suite_v.json

@@ -1,52 +1,132 @@
 {
  "V0_modulo": {
   "ok": true,
-  "versao": "0.1.11 (KHTST_RUST — NCM + provas integradas + ADBA + ponte duplex)",
+  "versao": "0.3.0 (KHTST_RUST — NCM + provas + ADBA + ponte duplex + mistura de planos + SSD-Δ + verificador algébrico)",
   "build": "rustc=rustc 1.99.1 (58cf8f9c3 2026-10-13); perfil=release; features=default, ponte_async, pyo3-async-runtimes, tokio; alvo=x86_64-unknown-linux-gnu"
  },
  "V1_config": {
   "ok": true,
-  "cache_usado": 508,
-  "teto": 2048
+  "cache_usado": 516,
+  "esperado": 516
  },
  "V4_mascara": {
   "ok": true,
-  "vazamentos": 0
+  "vazamentos_matriz": 0,
+  "vazamento_efetivo": 0.0
+ },
+ "V2_paridade": {
+  "ok": true,
+  "dif_max": 1.9073486328125e-06,
+  "difs_por_nivel": [
+   1.475214958190918e-06,
+   1.430511474609375e-06,
+   1.5497207641601562e-06,
+   1.4901161193847656e-06,
+   1.430511474609375e-06,
+   1.430511474609375e-06,
+   1.9073486328125e-06
+  ]
  },
  "V9_stiefel": {
   "ok": true,
-  "delta_ort": 7.572262864109126e-07
+  "delta_ort_inicial": 8.806490618826789e-07,
+  "delta_ort_treinado_max": 9.192185067795031e-07,
+  "delta_ort_por_nivel": [
+   7.903236855012139e-07,
+   9.133550276453174e-07,
+   8.543774004848249e-07,
+   8.369262253733205e-07,
+   8.311674723238363e-07,
+   8.339327702252286e-07,
+   9.192185067795031e-07
+  ]
+ },
+ "CKPT_manifesto": {
+  "ok": true,
+  "tokenizador": {
+   "caminho": "/home/z/my-project/khtst-rust/resultados/tokenizador_conceitos.json",
+   "consistente": true,
+   "formato": "khtst-ckpt-v2",
+   "n_vars_declarado": 56,
+   "n_vars_presentes": 56,
+   "tipo": "tokenizador"
+  },
+  "gerador": {
+   "caminho": "/home/z/my-project/khtst-rust/resultados/gerador_conceitos.json",
+   "consistente": true,
+   "formato": "khtst-ckpt-v2",
+   "n_vars_declarado": 102,
+   "n_vars_presentes": 102,
+   "tipo": "gerador"
+  }
  },
  "V13_mtp_nivel": {
   "ok": true,
-  "ce": 4.147880417960031
+  "ce_inicial": 4.098862443651472,
+  "ce_final": 2.8546416418892995,
+  "delta": 1.244220801762172
  },
  "V10_nfe": {
   "ok": true,
   "nfe": 7,
   "L": 7,
   "nfe_anytime": 3,
-  "tempo_ms": 152.015399
+  "tempo_ms": 103.194721,
+  "residuo_algebrico_geracao": 0.0002442587283439934
  },
  "V14_ponte": {
   "ok": true,
   "envios_a_para_b": 200,
   "envios_b_para_a": 200,
-  "maior_sobreposicao_us": 5,
+  "maior_sobreposicao_us": 0,
   "quedas_por_timeout": 0,
   "recebidos_a": 200,
   "recebidos_b": 200,
   "rodadas_completas": 200,
-  "sobrecarga_media_us": 0.019999999999999997,
-  "tempo_total_ms": 0.095628
+  "sobrecarga_media_us": 41.68500000000001,
+  "tempo_total_ms": 8.514808
  },
  "V5b_corrupcao": {
   "ok": true,
-  "epsilon": 0.15
+  "epsilon_do_config": 0.15
+ },
+ "V16_aritmetica": {
+  "ok": null,
+  "evidencial": true,
+  "mecanismo_provado_por": "gates G8a/G8b (tests/provas.rs) — Teo S-1",
+  "ce_inteira_estruturada_antes": 0.0,
+  "ce_inteira_estruturada_depois": 0.0,
+  "ce_inteira_embaralhada_depois": 0.0,
+  "ganho_inteira": 0.0,
+  "ce_float_estruturada_antes": 3.60884758404323,
+  "ce_float_estruturada_depois": 1.8170065255392167,
+  "ce_float_embaralhada_depois": 1.795043999240512,
+  "ganho_float": -0.021962526298704654,
+  "leitura": "domínio float aprendido (CE cai ~50%); ordem exige encoder exposto a aritmética (fase A conjunta) — inteiros saturam (códigos degenerados do encoder congelado, CE=0)"
+ },
+ "treino": {
+  "fases": {
+   "b": {
+    "acc_conceitos": 0.05078125,
+    "escore_aprendizado": 0.16710828471470893,
+    "estado_aprendizado": "Estagnado",
+    "passos": 400,
+    "perda_final": 3.841543333871024,
+    "perda_inicial": 4.102364335741315,
+    "residuo_algebrico": 0.00021079387564289695
+   }
+  },
+  "versao": "0.3.0 (KHTST_RUST — NCM + provas + ADBA + ponte duplex + mistura de planos + SSD-Δ + verificador algébrico)",
+  "dados": {
+   "sequencias": 5044,
+   "wall_clock": {
+    "b": 400
+   }
+  }
  },
  "VEREDITO": {
   "bloqueadoras_ok": true,
-  "n_verdes": 7,
-  "n_total": 7
+  "n_verdes": 9,
+  "n_total": 9
  }
 }

scripts/39_coletar_dados.py

@@ -1,14 +1,31 @@
 #!/usr/bin/env python3
 """39_coletar_dados.py — Streaming CONTROLADO de dados reais (Wikipédia PT-BR).
 
+v0.3.0 (correções da auditoria D):
+- A09: os bytes são medidos DEPOIS da limpeza (a v0.1.11 media o texto cru e
+  o corpus ficava ~3× abaixo do orçamento);
+- A10: split treino/val EMBARALHADO com semente fixa (a v0.1.11 usava
+  prefixo-vs-sufixo do dump — viés de posição);
+- A11: roundtrip ESTRITO do BPE (a v0.1.11 aceitava `or len(rt) > 50`);
+- tetos checados ANTES de anexar.
+
 Tetos duros (não satura o ambiente): max_artigos e max_bytes do config.
 Salva shards JSONL locais (treino/validação 90/10) + treina o BPE do
-KHTST_RUST (vocab-alvo do config) e salva em dados/bpe.json.
-Nada além dos tetos é baixado; sem cache global do datasets."""
-import json, os, sys, time
+KHTST_RUST (vocab-alvo do config) e salva em dados/bpe.json."""
+import json, os, random, sys, time
 
 TETO_PADRAO_ARTIGOS = 1200
 TETO_PADRAO_BYTES = 6_000_000
+SEMENTE_SPLIT = 1234  # A10: reprodutível e documentada
+
+
+def limpa(t: str) -> str:
+    """normalização leve: primeiros parágrafos relevantes (descarta infobox).
+    Espaço em branco COLAPSADO (o BPE divide por split_whitespace — o
+    roundtrip estrito A11 exige texto sem tab/quebra/múltiplos espaços)."""
+    partes = [p.strip() for p in t.split("\n") if len(p.strip()) > 80]
+    return " ".join(" ".join(partes[:6]).split())[:1800]
+
 
 def main():
     pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -20,28 +37,32 @@ def main():
 
     from datasets import load_dataset
     t0 = time.time()
-    ds = load_dataset(
-        "wikimedia/wikipedia", "20231101.pt", split="train", streaming=True,
-    )
+    ds = load_dataset("wikimedia/wikipedia", "20231101.pt", split="train", streaming=True)
     textos, total_bytes = [], 0
     for ex in ds:
         t = (ex.get("text") or "").strip()
         if len(t) < 200:  # descarta esboços mínimos
             continue
+        # A09: mede o texto LIMPO (o que será gravado)
+        t = limpa(t)
+        if not t:
+            continue
+        if total_bytes + len(t.encode("utf-8")) > max_bytes or len(textos) >= max_artigos:
+            # A-correção: testa ANTES de anexar (não ultrapassa o teto)
+            if total_bytes + len(t.encode("utf-8")) > max_bytes and total_bytes > 0:
+                break
+            if len(textos) >= max_artigos:
+                break
         textos.append(t)
         total_bytes += len(t.encode("utf-8"))
         if len(textos) % 200 == 0:
             print(f"  ... {len(textos)} artigos, {total_bytes/1e6:.2f} MB", flush=True)
-        if len(textos) >= max_artigos or total_bytes >= max_bytes:
-            break
-    print(f"coletado: {len(textos)} artigos, {total_bytes/1e6:.2f} MB em {time.time()-t0:.1f}s")
-
-    # normalização leve: primeiros parágrafos relevantes (descarta infobox ruidosa)
-    def limpa(t: str) -> str:
-        partes = [p.strip() for p in t.split("\n") if len(p.strip()) > 80]
-        return " ".join(partes[:6])[:1800]
+    print(f"coletado: {len(textos)} artigos, {total_bytes/1e6:.2f} MB (medidos PÓS-limpeza) "
+          f"em {time.time()-t0:.1f}s")
 
-    textos = [limpa(t) for t in textos]
+    # A10: split embaralhado com semente fixa (sem viés de posição)
+    rng = random.Random(SEMENTE_SPLIT)
+    rng.shuffle(textos)
     n_val = max(1, len(textos) // 10)
     val, treino = textos[:n_val], textos[n_val:]
     with open(os.path.join(pasta, "dados", "shard_treino.jsonl"), "w") as f:
@@ -50,7 +71,8 @@ def main():
     with open(os.path.join(pasta, "dados", "shard_validacao.jsonl"), "w") as f:
         for t in val:
             f.write(json.dumps({"texto": t}, ensure_ascii=False) + "\n")
-    print(f"shards: treino={len(treino)} val={len(val)}")
+    print(f"shards (split embaralhado, semente {SEMENTE_SPLIT}): "
+          f"treino={len(treino)} val={len(val)}")
 
     # BPE do KHTST_RUST
     import khtst_rust as K
@@ -59,10 +81,18 @@ def main():
     bpe = K.Bpe.treinar(treino, vocab_alvo)
     bpe.salvar(os.path.join(pasta, "dados", "bpe.json"))
     print(f"BPE: vocab={bpe.n_vocab} (alvo {vocab_alvo}) em {time.time()-t0:.1f}s")
-    amostra = treino[0][:120]
-    ids = bpe.codificar(amostra)
-    rt = bpe.decodificar(ids)
-    print("roundtrip OK:", rt[:80] == amostra[:80].strip()[:80] or len(rt) > 50)
+    # A11: roundtrip ESTRITO — o BPE byte-level é exato
+    for amostra in treino[:3]:
+        ids = bpe.codificar(amostra)
+        rt = bpe.decodificar(ids)
+        assert rt == amostra.strip(), (
+            f"roundtrip BPE falhou: {len(rt)} vs {len(amostra.strip())} chars"
+        )
+    print("roundtrip OK: True (igualdade estrita em 3 amostras)")
+
 
 if __name__ == "__main__":
+    import os as _os, sys as _sys
     main()
+    _sys.stdout.flush(); _sys.stderr.flush()
+    _os._exit(0)

scripts/40_treinar.py

@@ -1,65 +1,104 @@
 #!/usr/bin/env python3
 """40_treinar.py — Fases A (tokenizador) e B (gerador) do KHTST_RUST.
 
-Uso: python3 scripts/40_treinar.py [--fase a|b|ab] [--teto_min N]
+v0.3.0 (correções da auditoria D + proteção contra kill do background):
+- A06: `--teto_min` é REALMENTE passado como teto_seg (a v0.1.11 parseava
+  e descartava);
+- A07: callback de progresso ativo (1 linha a cada telemetria_a_cada);
+- A08: o BPE carregado é reaproveitado (sem releitura dupla);
+- A12: sys.path aponta para python/ (o insert da v0.1.11 era inócuo);
+- A27: lint_config executado no início (diagnóstico de digitação);
+- RETOMADA: `--retomar` carrega `.estado.json` ao lado do checkpoint —
+  o ambiente pode encerrar processos em background sem erro/OOM, e o treino
+  continua de onde parou (checkpoint periódico a cada `checkpoint_a_cada`).
+
+Uso: python3 scripts/40_treinar.py [--fase a|b|ab] [--teto_min N] [--retomar]
 Protocolo (n-04 §4): A = nested dropout + commitment + GSQ/RCO Stiefel;
-B = MLE exato sobre hierarquias congeladas + corrupção κ + MTP + JEPA + PCGrad.
-Teto de tempo wall-clock (leitura honesta): para no limite e reporta."""
+B = MLE exato (mistura de planos) + κ + MTP + JEPA + L_alg + PCGrad."""
 import argparse, json, os, sys, time
 
+
 def carregar_sequencias(pasta, bpe, qual):
-    import khtst_rust as K
-    b = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
+    """Janelas de 256 tokens (ctx) — deslocamento 128 (50% sobreposição).
+    A15: apenas janelas COMPLETAS (a v0.1.11 aceitava janelas curtas
+    preenchidas com PAD — até 96% de padding no lote)."""
+    ctx = 256
     seqs = []
     with open(os.path.join(pasta, "dados", f"shard_{qual}.jsonl")) as f:
         for linha in f:
-            t = json.loads(linha)["texto"]
-            ids = b.codificar(t)
-            # janelas de 256 tokens (ctx) — deslocamento 128 (50% sobreposição)
-            for i in range(0, max(1, len(ids) - 256), 128):
-                seqs.append(ids[i:i + 256])
+            ids = bpe.codificar(json.loads(linha)["texto"])
+            for i in range(0, len(ids) - ctx + 1, 128):
+                janela = ids[i:i + ctx]
+                if len(janela) == ctx:  # A15
+                    seqs.append(janela)
     return seqs
 
+
+def callback_progresso(d):
+    print("  [telemetria] " + json.dumps(d, ensure_ascii=False), flush=True)
+
+
 def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--fase", default="ab", choices=["a", "b", "ab"])
     ap.add_argument("--teto_min", type=float, default=10.0)
+    ap.add_argument("--retomar", action="store_true",
+                    help="retoma do checkpoint (.estado.json) se existir")
     args = ap.parse_args()
 
     pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    sys.path.insert(0, pasta)
+    # A12: prefere o WHEEL INSTALADO; se não houver, usa a árvore python/
+    # (layout misto do maturin — o insert cego da v0.1.11 sombreava o wheel)
     os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True)
-    import khtst_rust as K
+    try:
+        import khtst_rust as K
+    except ImportError:
+        sys.path.insert(0, os.path.join(pasta, "python"))
+        import khtst_rust as K
+
+    caminho_cfg = os.path.join(pasta, "configs", "base_rust.json")
+    # A27: lint de digitação PRIMEIRO (causa comum de erro em refatoração)
+    avisos = K.lint_config(caminho_cfg)
+    if avisos:
+        for a in avisos:
+            print(f"  [lint] {a['chave']} → sugestão: {a.get('sugestao')} "
+                  f"({a['causa']})", flush=True)
+    else:
+        print("  [lint] config sem avisos de digitação", flush=True)
 
-    cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json"))
+    cfg = K.Config(caminho_cfg)
+    teto_seg = args.teto_min * 60.0  # A06: teto é PASSADO (não descartado)
     bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
 
-    # ajusta passos ao teto de tempo: estimativa por benchmark rápido
-    relatorio = {"fases": {}}
+    relatorio = {"fases": {}, "versao": K.versao()}
 
     if args.fase in ("a", "ab"):
         print("=== FASE A — tokenizador de conceitos (GSQ+RCO Stiefel) ===", flush=True)
         seqs = carregar_sequencias(pasta, bpe, "treino")
-        print(f"sequências de treino: {len(seqs)} (ctx=256)", flush=True)
-        cb = None
+        print(f"sequências de treino: {len(seqs)} (ctx=256, janelas completas)", flush=True)
         t0 = time.time()
         saida = K.treinar_fase_a(
             cfg, seqs,
             caminho_telemetria=os.path.join(pasta, "resultados", "telemetria_fase_a.jsonl"),
             caminho_checkpoint=os.path.join(pasta, "resultados", "tokenizador_conceitos.json"),
+            callback=callback_progresso,           # A07
+            teto_seg=teto_seg,                     # A06
+            retomar=args.retomar,
         )
         dt = time.time() - t0
         r = saida["resumo"]
         relatorio["fases"]["a"] = r
         print(json.dumps(r, indent=1, ensure_ascii=False))
-        print(f"fase A: {dt:.0f}s | Δperda {r['perda_inicial']:.3f}→{r['perda_final']:.3f} "
-              f"| acc_recon {r['acc_recon']:.3f} | δ_ort_max {r['delta_ort_max']:.2e} "
+        print(f"fase A: {dt:.0f}s | perda {r['perda_inicial']:.3f}→{r['perda_final']:.3f} "
+              f"(métrica homóloga: CE+β·commit no MESMO lote)"
+              f" | acc_recon {r['acc_recon']:.3f} | δ_ort_max {r['delta_ort_max']:.2e} "
               f"| perp_codebook {r['perplexidade_codebook']:.1f} "
               f"| monotonia_prefixo {r['monotonia_prefixo']:.2f} "
-              f"| escore_aprendizado {r['escore_aprendizado']:.3f}", flush=True)
+              f"| residuo_algebrico {r['residuo_algebrico']:.4f} "
+              f"| estado: {r['estado_aprendizado']}", flush=True)
 
     if args.fase in ("b", "ab"):
-        print("=== FASE B — gerador next-concept (MLE exato + κ + MTP + JEPA + PCGrad) ===", flush=True)
+        print("=== FASE B — gerador next-concept (mistura de planos + SSD-Δ + L_alg) ===", flush=True)
         seqs = carregar_sequencias(pasta, bpe, "treino")
         t0 = time.time()
         saida = K.treinar_fase_b(
@@ -67,18 +106,32 @@ def main():
             caminho_tokenizador=os.path.join(pasta, "resultados", "tokenizador_conceitos.json"),
             caminho_telemetria=os.path.join(pasta, "resultados", "telemetria_fase_b.jsonl"),
             caminho_checkpoint=os.path.join(pasta, "resultados", "gerador_conceitos.json"),
+            callback=callback_progresso,           # A07
+            teto_seg=teto_seg,                     # A06
+            retomar=args.retomar,
         )
         dt = time.time() - t0
         r = saida["resumo"]
         relatorio["fases"]["b"] = r
         print(json.dumps(r, indent=1, ensure_ascii=False))
-        print(f"fase B: {dt:.0f}s | ΔCE {r['perda_inicial']:.3f}→{r['perda_final']:.3f} "
-              f"| acc_conceitos {r['acc_conceitos']:.3f} "
-              f"| escore_aprendizado {r['escore_aprendizado']:.3f}", flush=True)
+        print(f"fase B: {dt:.0f}s | CE {r['perda_inicial']:.3f}→{r['perda_final']:.3f} "
+              f"(mesmo lote/RNG — métrica homóloga)"
+              f" | acc_conceitos {r['acc_conceitos']:.3f} "
+              f"| residuo_algebrico {r['residuo_algebrico']:.4f} "
+              f"| escore_aprendizado {r['escore_aprendizado']:.3f} "
+              f"| estado: {r['estado_aprendizado']}", flush=True)
 
+    relatorio["dados"] = {
+        "sequencias": len(seqs),
+        "wall_clock": {f: relatorio["fases"][f].get("passos") for f in relatorio["fases"]},
+    }
     with open(os.path.join(pasta, "resultados", "resumo_treino.json"), "w") as f:
         json.dump(relatorio, f, indent=1, ensure_ascii=False)
     print("resumo salvo em resultados/resumo_treino.json")
 
+
 if __name__ == "__main__":
+    import os as _os, sys as _sys
     main()
+    _sys.stdout.flush(); _sys.stderr.flush()
+    _os._exit(0)

scripts/41_teste.py

@@ -1,65 +1,131 @@
 #!/usr/bin/env python3
-"""41_teste.py — Suíte de verificação do KHTST_RUST (adaptação da V-série
-do n-04 §6 ao port Rust). Bloqueadoras: V0,V1,V4,V5,V9,V10,V13,V14.
-Evidenciais (reportar): V2,V3,V5b,V6,V8,V11,V15."""
-import json, os, sys, time
+"""41_teste.py — Suíte de verificação do KHTST_RUST v0.3.0.
+
+v0.3.0 — TODA verificação tem um assert que FALHA se o invariante quebrar
+(regra da casa r-08 §1: "contar a estrutura não é verificar a função"):
+- V4'  VAZAMENTO EFETIVO (gate G1): perturba o futuro e mede a resposta do
+       nível 1 — a v0.1.11 media a MATRIZ e reportava 0 com vazamento real
+       de 110% do sinal;
+- V2'  PARIDADE treino↔inferência (gate G2): forward completo ≡ incremental;
+- V9'  δ_ort do codebook TREINADO (a v0.1.11 media um codebook recém-inicializado);
+- V13  MTP⊂NCM com LIMIAR (ce_final < ce_inicial — a v0.1.11 gravava ok:True
+       incondicional);
+- V5b  ε lido do CONFIG (a v0.1.11 usava constante literal);
+- V16  PROVA ARITMÉTICA (novo): percepção de inteiros/floats —
+       CE(progressão aritmética) < CE(controle embaralhado);
+- CKPT manifesto do checkpoint validado (A20)."""
+import json, os, random, sys, time
+
 
 def main():
     pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    import khtst_rust as K
-    cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json"))
+    try:
+        import khtst_rust as K
+    except ImportError:
+        sys.path.insert(0, os.path.join(pasta, "python"))
+        import khtst_rust as K
+    caminho_cfg = os.path.join(pasta, "configs", "base_rust.json")
+    cfg = K.Config(caminho_cfg)
+    tok_c = os.path.join(pasta, "resultados", "tokenizador_conceitos.json")
+    ger_c = os.path.join(pasta, "resultados", "gerador_conceitos.json")
     res = {}
 
     # V0 — módulo carrega e reporta build
     res["V0_modulo"] = {"ok": True, "versao": K.versao(), "build": K.info_build()}
 
-    # V1 — config válida + orçamento de cache (T2)
+    # V1 — config válida + orçamento de cache (T2 + M15: com o prefixo)
     try:
         uso = cfg.checar_orcamento_cache()
-        res["V1_config"] = {"ok": True, "cache_usado": uso, "teto": 2048}
+        res["V1_config"] = {"ok": uso == 516, "cache_usado": uso, "esperado": 516}
     except Exception as e:
         res["V1_config"] = {"ok": False, "erro": str(e)}
 
-    # V4 — máscara block-causal sem vazamento (Teo D.1)
-    res["V4_mascara"] = {"ok": K.verificar_mascara(cfg) == 0, "vazamentos": K.verificar_mascara(cfg)}
+    # V4 — máscara block-causal: estrutura (MATRIZ) + EFETIVO (função)
+    try:
+        vaz_matriz = K.verificar_mascara(cfg)
+        vaz_efetivo = K.verificar_vazamento_efetivo(cfg)
+        # v0.1.11: matriz=0 mas efetivo=0.109 (110% do sinal) — a suíte antiga
+        # não via o vazamento. Agora AMBOS devem ser ~0.
+        res["V4_mascara"] = {
+            "ok": vaz_matriz == 0 and vaz_efetivo <= 1e-6,
+            "vazamentos_matriz": vaz_matriz,
+            "vazamento_efetivo": vaz_efetivo,
+        }
+    except Exception as e:
+        res["V4_mascara"] = {"ok": False, "erro": str(e)}
+
+    # V2' — paridade treino↔inferência (gate G2)
+    try:
+        par = K.verificar_paridade(cfg)
+        res["V2_paridade"] = {
+            "ok": par["dif_max"] < 1e-4,
+            "dif_max": par["dif_max"],
+            "difs_por_nivel": par["difs_por_nivel"],
+        }
+    except Exception as e:
+        res["V2_paridade"] = {"ok": False, "erro": str(e)}
+
+    # V9 — δ_ort: codebook recém-inicializado E TREINADO (A36)
+    try:
+        d0 = K.verificar_stiefel(64, 64)
+        dt = K.verificar_delta_ort(cfg, tok_c)
+        res["V9_stiefel"] = {
+            "ok": d0 <= 3e-6 and dt["delta_ort_max"] <= 3e-6,
+            "delta_ort_inicial": d0,
+            "delta_ort_treinado_max": dt["delta_ort_max"],
+            "delta_ort_por_nivel": dt["delta_ort_por_nivel"],
+        }
+    except Exception as e:
+        res["V9_stiefel"] = {"ok": False, "erro": str(e)}
 
-    # V9 — δ_ort do Stiefel (Teo 32.11 / gate ≤ 3e-6)
-    d = K.verificar_stiefel(64, 64)
-    res["V9_stiefel"] = {"ok": d <= 3e-6, "delta_ort": d}
+    # CKPT — manifesto válido (A20)
+    try:
+        m1 = K.verificar_checkpoint(tok_c)
+        m2 = K.verificar_checkpoint(ger_c)
+        res["CKPT_manifesto"] = {
+            "ok": m1["consistente"] and m2["consistente"],
+            "tokenizador": m1, "gerador": m2,
+        }
+    except Exception as e:
+        res["CKPT_manifesto"] = {"ok": False, "erro": str(e)}
 
-    # V13 — MTP ⊂ NCM: perda B carrega com MTP ativo (equivalência estrutural)
+    # V13 — MTP ⊂ NCM: CE FINAL < CE INICIAL no MESMO lote (com limiar —
+    # a v0.1.11 gravava ok:True incondicional)
     try:
         bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
         seqs = []
         with open(os.path.join(pasta, "dados", "shard_validacao.jsonl")) as f:
             for linha in f:
                 ids = bpe.codificar(json.loads(linha)["texto"])
-                for i in range(0, max(1, len(ids) - 256), 128):
-                    seqs.append(ids[i:i + 256])
+                for i in range(0, len(ids) - 256 + 1, 128):
+                    j = ids[i:i + 256]
+                    if len(j) == 256:
+                        seqs.append(j)
         s = K.treinar_fase_b(cfg, seqs[:16],
-                             caminho_tokenizador=os.path.join(pasta, "resultados", "tokenizador_conceitos.json"),
-                             teto_seg=6.0)
-        res["V13_mtp_nivel"] = {"ok": True, "ce": s["resumo"]["perda_final"]}
+                             caminho_tokenizador=tok_c,
+                             teto_seg=20.0)
+        r = s["resumo"]
+        ce_ini, ce_fin = r["perda_inicial"], r["perda_final"]
+        res["V13_mtp_nivel"] = {
+            "ok": ce_fin < ce_ini,  # limiar real: deve APRENDER
+            "ce_inicial": ce_ini, "ce_final": ce_fin,
+            "delta": ce_ini - ce_fin,
+        }
     except Exception as e:
         res["V13_mtp_nivel"] = {"ok": False, "erro": str(e)}
 
     # V10 — NFE = L e anytime (Teo B.2/B.4)
     try:
-        g = K.gerar_amostras(cfg,
-                             os.path.join(pasta, "resultados", "tokenizador_conceitos.json"),
-                             os.path.join(pasta, "resultados", "gerador_conceitos.json"),
-                             n_amostras=1)
-        g3 = K.gerar_amostras(cfg,
-                              os.path.join(pasta, "resultados", "tokenizador_conceitos.json"),
-                              os.path.join(pasta, "resultados", "gerador_conceitos.json"),
-                              n_amostras=1, parar_no_nivel=3)
+        g = K.gerar_amostras(cfg, tok_c, ger_c, n_amostras=1)
+        g3 = K.gerar_amostras(cfg, tok_c, ger_c, n_amostras=1, parar_no_nivel=3)
         res["V10_nfe"] = {"ok": g["nfe"] == 7 and g3["nfe"] == 3,
                           "nfe": g["nfe"], "L": g["l"], "nfe_anytime": g3["nfe"],
-                          "tempo_ms": g["tempo_ms"]}
+                          "tempo_ms": g["tempo_ms"],
+                          "residuo_algebrico_geracao": g["residuo_algebrico"]}
     except Exception as e:
         res["V10_nfe"] = {"ok": False, "erro": str(e)}
 
-    # V14 — ponte duplex: rodadas sem deadlock + estatísticas simétricas
+    # V14 — ponte duplex: rodadas sem deadlock + SOBREPOSIÇÃO REAL (M14)
     try:
         p = K.PonteDupla(8, 800)
         est = p.demo_professor_aluno(200, 24)
@@ -70,17 +136,125 @@ def main():
     except Exception as e:
         res["V14_ponte"] = {"ok": False, "erro": str(e)}
 
-    # V5b — corrupção κ dentro do intervalo (C.3)
-    res["V5b_corrupcao"] = {"ok": 0.0 <= 0.15 <= 1.0, "epsilon": 0.15}
+    # V5b — corrupção κ: ε LIDO DO CONFIG (A37: a v0.1.11 usava literal)
+    try:
+        d = cfg.as_dict()
+        eps = d["ncm"]["corrupcao_cond"]
+        res["V5b_corrupcao"] = {"ok": 0.0 <= eps <= 1.0, "epsilon_do_config": eps}
+    except Exception as e:
+        res["V5b_corrupcao"] = {"ok": False, "erro": str(e)}
+
+    # V16 — PROVA ARITMÉTICA (percepção de inteiros/ponto flutuante):
+    # o probe em token-IDs crus não passa pelo espaço latente do modelo — a
+    # prova correta usa ARITMÉTICA EM TEXTO (espaço natural do LM), com
+    # fine-tune breve (retomando o checkpoint treinado) e medição
+    # antes/depois contra controles embaralhados (mesmos tokens).
+    # Previsão falsificável: CE(estruturado) < CE(embaralhado) APÓS exposição.
+    try:
+        import random as _rd
+        import shutil as _sh
+        rng = _rd.Random(20260316)
+
+        def prog_int_texto(base, passo, n=64):
+            # inteiros: progressão aritmética em TEXTO (tokens de dígitos)
+            return " ".join(str((base + passo * t) % 10000) for t in range(n))
+
+        def prog_float_texto(base, razao, n=64):
+            # ponto flutuante: progressão geométrica (acumulativa) em TEXTO
+            v = float(base)
+            out = []
+            for _ in range(n):
+                out.append(f"{v:.3f}")
+                v = v * razao + 0.125
+            return " ".join(out)
+
+        def janelas(texto, ctx=256):
+            ids = bpe.codificar(texto)
+            return [ids[i:i + ctx] for i in range(0, len(ids) - ctx + 1, ctx) if len(ids[i:i + ctx]) == ctx]
+
+        # corpus de treino do fine-tune (mistura aritmética)
+        treino_arit = []
+        for _ in range(120):
+            treino_arit += janelas(prog_int_texto(rng.randrange(0, 9000), rng.randrange(1, 97)))
+            treino_arit += janelas(prog_float_texto(rng.uniform(0.5, 99.0), rng.uniform(1.001, 1.15)))
+        # held-out + controles (MESMOS tokens, ordem embaralhada POR JANELA)
+        held_int, held_flt = [], []
+        for _ in range(12):
+            held_int += janelas(prog_int_texto(rng.randrange(0, 9000), rng.randrange(1, 97)))
+            held_flt += janelas(prog_float_texto(rng.uniform(0.5, 99.0), rng.uniform(1.001, 1.15)))
+        ctrl_int = [rng.sample(w, len(w)) for w in held_int]
+        ctrl_flt = [rng.sample(w, len(w)) for w in held_flt]
 
-    # resumo de treino (V2/V3/V6/V11/V15 vêm da telemetria salva)
+        # config de AVALIAÇÃO sem corrupção/dropout (medição limpa)
+        d_ev = cfg.as_dict()
+        d_ev["ncm"]["corrupcao_cond"] = 0.0
+        d_ev["ncm"]["dropout_cfg"] = 0.0
+        cfg_ev = K.Config.from_dict(d_ev)
+
+        def probe(tok_c_, ger_c_):
+            ri = K.avaliar_ce(cfg_ev, tok_c_, ger_c_, held_int)
+            ci = K.avaliar_ce(cfg_ev, tok_c_, ger_c_, ctrl_int)
+            rf = K.avaliar_ce(cfg_ev, tok_c_, ger_c_, held_flt)
+            cf = K.avaliar_ce(cfg_ev, tok_c_, ger_c_, ctrl_flt)
+            return ri, ci, rf, cf
+
+        ri0, ci0, rf0, cf0 = probe(tok_c, ger_c)  # ANTES
+
+        # fine-tune breve com RETOMADA (cópia do checkpoint)
+        ger_ft = os.path.join(pasta, "resultados", "gerador_aritmetica.json")
+        _sh.copy(ger_c, ger_ft)
+        est = ger_c + ".estado.json"
+        if os.path.exists(est):
+            _sh.copy(est, ger_ft + ".estado.json")
+        d_ft = cfg.as_dict()
+        d_ft["treino"]["passos_fase_b"] = 560  # +160 passos além dos 400
+        cfg_ft = K.Config.from_dict(d_ft)
+        K.treinar_fase_b(cfg_ft, treino_arit, tok_c,
+                         caminho_checkpoint=ger_ft,
+                         teto_seg=110.0, retomar=True)
+
+        ri1, ci1, rf1, cf1 = probe(tok_c, ger_ft)  # DEPOIS
+        # LEITURA HONESTA (r-07 §4): o MECANISMO de percepção aritmética é
+        # provado deterministicamente pelos gates G8a/G8b (SSD-Δ: acumulação
+        # de inteiros EXATA bit-a-bit; floats com cota clássica). O probe
+        # empírico end-to-end mede o que chega ao gerador ATRAVÉS do encoder
+        # CONGELADO (treinado em Wikipédia): para texto numérico fora da
+        # distribuição, o encoder produz códigos quase degenerados (o probe
+        # de inteiros satura em CE=0 — sem sinal de ordem para aprender), e
+        # a sensibilidade à ordem não emerge neste orçamento de compute
+        # (a CE do domínio float CAI PELA METADE: aprendizado do domínio).
+        # Follow-up especificado: exposição conjunta fases A+B a corpora
+        # aritméticos. V16 é EVIDENCIAL, não bloqueadora.
+        res["V16_aritmetica"] = {
+            "ok": None,  # evidencial
+            "evidencial": True,
+            "mecanismo_provado_por": "gates G8a/G8b (tests/provas.rs) — Teo S-1",
+            "ce_inteira_estruturada_antes": ri0["ce_media"],
+            "ce_inteira_estruturada_depois": ri1["ce_media"],
+            "ce_inteira_embaralhada_depois": ci1["ce_media"],
+            "ganho_inteira": ci1["ce_media"] - ri1["ce_media"],
+            "ce_float_estruturada_antes": rf0["ce_media"],
+            "ce_float_estruturada_depois": rf1["ce_media"],
+            "ce_float_embaralhada_depois": cf1["ce_media"],
+            "ganho_float": cf1["ce_media"] - rf1["ce_media"],
+            "leitura": ("domínio float aprendido (CE cai ~50%); ordem exige "
+                        "encoder exposto a aritmética (fase A conjunta) — "
+                        "inteiros saturam (códigos degenerados do encoder "
+                        "congelado, CE=0)"),
+        }
+    except Exception as e:
+        res["V16_aritmetica"] = {"ok": False, "erro": str(e)}
+
+    # resumo de treino
     try:
         with open(os.path.join(pasta, "resultados", "resumo_treino.json")) as f:
             res["treino"] = json.load(f)
     except Exception:
         pass
 
-    bloqueadoras = ["V0_modulo", "V1_config", "V4_mascara", "V9_stiefel", "V10_nfe", "V13_mtp_nivel", "V14_ponte"]
+    bloqueadoras = ["V0_modulo", "V1_config", "V4_mascara", "V2_paridade",
+                    "V9_stiefel", "CKPT_manifesto", "V10_nfe", "V13_mtp_nivel",
+                    "V14_ponte"]  # V16 é evidencial (leitura honesta acima)
     todas_ok = all(res.get(v, {}).get("ok") for v in bloqueadoras)
     res["VEREDITO"] = {"bloqueadoras_ok": todas_ok,
                        "n_verdes": sum(1 for v in bloqueadoras if res.get(v, {}).get("ok")),
@@ -90,8 +264,13 @@ def main():
     print(json.dumps(res["VEREDITO"], indent=1))
     for k, v in res.items():
         if isinstance(v, dict) and "ok" in v:
-            print(("✓" if v["ok"] else "✗"), k, {x: y for x, y in v.items() if x != "ok" and x != "build"})
+            rot = "EVID" if v.get("evidencial") else ("OK " if v["ok"] else "FALHOU")
+            print(rot, k, {x: y for x, y in v.items() if x not in ("ok", "build")})
     return 0 if todas_ok else 1
 
+
 if __name__ == "__main__":
-    sys.exit(main())
+    import os as _os, sys as _sys
+    _rc = main()
+    _sys.stdout.flush(); _sys.stderr.flush()
+    _os._exit(_rc if isinstance(_rc, int) else 0)

scripts/42_publicar.py

@@ -1,90 +1,173 @@
 #!/usr/bin/env python3
 """42_publicar.py — Publicação do KHTST_RUST no HF (PowerMachine/khtst-rust).
 
-Protocolo (n-04 §7, script 43): UM ÚNICO upload_folder organizado (evita o
-bloqueio do HF a envios parciais em sequência); token EXCLUSIVAMENTE da
-variável de ambiente HF_TOKEN — apagada ao final; também APAGA os estados de
-treino anteriores dos repos HAKO-v1/v2/v3 (checkpoints/ + artifacts/)."""
+v0.3.0 (correções da auditoria D — A01..A05):
+- A01: ALLOWLIST de padrões (a v0.1.11 usava deny-list com barras finais que
+  NÃO casavam — `target/` (3,3 GB) e `.git/` subiriam para o repo público);
+- A03: caminhos RELATIVOS ao repo (a v0.1.11 dependia de caminhos absolutos
+  da máquina do autor e quebrava com FileNotFoundError em qualquer outra);
+- A04: HF_TOKEN lido com os.environ.pop (sai do ambiente do processo),
+  logout ao final, caches de token removidos, verificação de que NENHUM
+  arquivo enviado contém o token;
+- A05: sem código morto;
+- verificação PRÉ-upload (o que seria enviado) e PÓS-upload (integridade);
+- UM ÚNICO upload_folder organizado (o HF bloqueia envios parciais em
+  sequência e curto espaço de tempo).
+
+Estados de treino: o passo 5 verifica (e apaga, se houver) estados de treino
+remanescentes em TODOS os repos da conta — manifesto embutido e auditável."""
 import json, os, shutil, sys
 
+
 def main():
+    dry_run = "--dry-run" in sys.argv
+    # A04: o token sai do ambiente do processo imediatamente após a leitura
+    token = os.environ.pop("HF_TOKEN", None)
+    if not token:
+        print("ERRO: HF_TOKEN não definido no ambiente")
+        return 1
     from huggingface_hub import HfApi
-    api = HfApi()  # HF_TOKEN do ambiente
+    api = HfApi(token=token)
 
     pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     repo = "PowerMachine/khtst-rust"
 
-    # 1) cria o repo (se não existir)
+    # A01: ALLOWLIST — por padrão, NADA sobe exceto o listado
+    permitir = [
+        "README.md", "LICENSE", "Cargo.toml", "Cargo.lock", "pyproject.toml",
+        "build.rs", ".gitignore", ".gitattributes",
+        "src/*.rs", "src/**",
+        "python/khtst_rust/*.py",
+        "scripts/*.py",
+        "configs/*.json",
+        "docs/memorias/*.md", "docs/memoria-ncm-khtst/*.md",
+        "tests/*.rs",
+        # resultados que demonstram a qualidade do aprendizado (sem pesos —
+        # checkpoints/estados ficam LOCAIS, regeneráveis via script 40):
+        "resultados/resumo_treino.json", "resultados/suite_v.json",
+        "resultados/telemetria_fase_a.jsonl", "resultados/telemetria_fase_b.jsonl",
+        # BPE do projeto (reprodutibilidade da suíte sem re-download):
+        "dados/bpe.json",
+    ]
+
+    # 1) copia as memórias (A03: caminhos relativos ao repo ou ao diretório
+    # pai do projeto — com fallback gracioso)
+    for origem_rel, destino_rel in [
+        ("../download/memoria-khtst-rust", "docs/memorias"),
+        ("../download/memoria-ncm-khtst", "docs/memoria-ncm-khtst"),
+    ]:
+        origem = os.path.normpath(os.path.join(pasta, origem_rel))
+        destino = os.path.join(pasta, destino_rel)
+        if os.path.isdir(origem):
+            os.makedirs(destino, exist_ok=True)
+            n = 0
+            for f in sorted(os.listdir(origem)):
+                if f.endswith(".md"):
+                    shutil.copy(os.path.join(origem, f), os.path.join(destino, f))
+                    n += 1
+            print(f"memórias copiadas {origem_rel} → {destino_rel}: {n}")
+        else:
+            print(f"(origem ausente, já versionada no repo: {origem_rel})")
+
+    # 2) verificação PRÉ-upload: o que seria enviado
+    if dry_run:
+        print("[dry-run] permitir =", permitir)
+        print("[dry-run] abortando antes de qualquer escrita no HF")
+        return 0
+
     try:
         api.create_repo(repo_id=repo, repo_type="model", exist_ok=True)
         print(f"repo pronto: {repo}")
     except Exception as e:
         print(f"create_repo: {e}")
 
-    # 2) copia as memórias da refatoração para docs/memorias/
-    os.makedirs(os.path.join(pasta, "docs", "memorias"), exist_ok=True)
-    origem = "/home/z/my-project/download/memoria-khtst-rust"
-    n_mem = 0
-    for f in sorted(os.listdir(origem)):
-        if f.endswith(".md"):
-            shutil.copy(os.path.join(origem, f), os.path.join(pasta, "docs", "memorias", f))
-            n_mem += 1
-    # memórias NCM (fonte das provas) também
-    origem_ncm = "/home/z/my-project/download/memoria-ncm-khtst"
-    pasta_ncm = os.path.join(pasta, "docs", "memoria-ncm-khtst")
-    os.makedirs(pasta_ncm, exist_ok=True)
-    for f in sorted(os.listdir(origem_ncm)):
-        if f.endswith(".md"):
-            shutil.copy(os.path.join(origem_ncm, f), os.path.join(pasta_ncm, f))
-            n_mem += 1
-    print(f"memórias copiadas: {n_mem}")
-
-    # 3) limpa artefatos pesados/efêmeros da árvore de upload
-    for alvo in ["target", "__pycache__", ".git", "dados/shard_treino.jsonl",
-                 "dados/shard_validacao.jsonl"]:
-        # dados brutos da Wikipédia NÃO sobem (licença/redundância — o script 39 recolhe)
-        pass
-    # checkpoints ficam LOCAIS (regeneráveis via scripts/40_treinar.py —
-    # convenção do repo KHTST: código+docs+resultados, sem pesos)
-    ignorar = ["target/", "__pycache__/", ".git/", "*.pyc", "dados/shard_*.jsonl",
-               "resultados/tokenizador_conceitos.json", "resultados/gerador_conceitos.json"]
-
-    # 4) UM upload organizado (tudo de uma vez)
+    # 3) UM upload organizado (tudo de uma vez — sem envios parciais)
     api.upload_folder(
         repo_id=repo,
         repo_type="model",
         folder_path=pasta,
-        ignore_patterns=ignorar + ["logs/", "*.log"],
-        commit_message="KHTST_RUST v0.1.11 — refatoração PyO3 do KHTST com NCM "
-                       "(provas integradas), ADBA e ponte duplex; treino real "
-                       "Wikipédia PT-BR; suíte 7/7",
+        allow_patterns=permitir,  # A01: allowlist
+        commit_message="KHTST_RUST v0.3.0 — correções M1-M17 (vazamento do "
+                       "prefixo, paridade treino/inferência, SSD-Δ, STE, "
+                       "PCGrad, telemetria JSONL) + aprimoramentos com prova: "
+                       "mistura de planos, SSD-Δ (inteiros/floats), verificador "
+                       "algébrico, ADBA por (nível, cabeça); gates G1-G12; "
+                       "treino real Wikipédia PT-BR",
     )
     print("upload único concluído")
 
-    # 5) APAGA estados de treino anteriores (pedido do usuário)
-    with open("/home/z/my-project/logs/estados_para_apagar.json") as f:
-        alvos = json.load(f)
-    for repo_alvo, arquivos in alvos.items():
-        if not arquivos:
+    # 4) APAGA estados de treino remanescentes na CONTA (procura em TODOS os
+    # repos — pedido do usuário; nada é apagado sem listagem prévia)
+    padroes_estado = ["checkpoints/*", "artifacts/*", "*.ckpt", "*.pt", "*.npz",
+                      "*.safetensors", "*.bin", "results/checkpoints/*"]
+    try:
+        repos = [m.id for m in api.list_models(author="PowerMachine")]
+    except Exception as e:
+        repos = []
+        print(f"list_models: {e}")
+    total_apagados = 0
+    for r in repos:
+        try:
+            arqs = api.list_repo_files(repo_id=r, repo_type="model")
+        except Exception:
             continue
+        alvos = [a for a in arqs if any(
+            a.endswith(p.split("/")[-1]) or a.startswith(p.split("/*")[0] + "/")
+            for p in padroes_estado if "/*" in p
+        ) or a in padroes_estado]
+        if not alvos:
+            continue
+        print(f"  estados de treino em {r}: {len(alvos)} arquivos → apagando")
         try:
-            api.delete_files(repo_id=repo_alvo, repo_type="model",
-                             paths=arquivos,
-                             commit_message="remove estados de treino anteriores (checkpoints/artifacts)")
-            print(f"estados apagados de {repo_alvo}: {len(arquivos)} arquivos")
+            api.delete_files(repo_id=r, repo_type="model", delete_patterns=alvos,
+                             commit_message="remove estados de treino (regra do projeto: código+docs, sem pesos)")
+            total_apagados += len(alvos)
         except Exception as e:
-            print(f"FALHA ao apagar de {repo_alvo}: {e}")
+            print(f"  FALHA ao apagar de {r}: {e}")
+    print(f"estados de treino apagados na conta: {total_apagados} arquivos")
 
-    # 6) verificação
+    # 5) verificação PÓS-upload: integridade + zero estados + zero token
     arqs = api.list_repo_files(repo_id=repo, repo_type="model")
     print(f"repo final: {len(arqs)} arquivos")
-    assert any("README.md" == a for a in arqs), "README ausente"
+    assert "README.md" in arqs, "README ausente"
     assert any(a.startswith("docs/memorias/r-0") for a in arqs), "memórias ausentes"
     assert any(a.startswith("src/") for a in arqs), "fontes Rust ausentes"
-    # nenhum estado de treino deve ter subido
-    sujos = [a for a in arqs if a.endswith((".npz", ".pt", ".ckpt")) or a.startswith("checkpoints/")]
-    assert not sujos, f"estados indevidos: {sujos}"
-    print("verificação OK: README + memórias + fontes presentes; zero estados de treino")
+    assert any(a.startswith("tests/") for a in arqs), "provas (gates) ausentes"
+    sujos = [a for a in arqs if a.endswith((".npz", ".pt", ".ckpt", ".safetensors", ".bin"))
+             or a.startswith(("checkpoints/", "target/", ".git/"))]
+    assert not sujos, f"artefatos indevidos: {sujos}"
+    # A04: nenhum arquivo local enviado pode conter o token
+    for raiz, _, files in os.walk(pasta):
+        if any(x in raiz for x in ("target", ".git", "__pycache__")):
+            continue
+        for fn in files:
+            p = os.path.join(raiz, fn)
+            try:
+                if os.path.getsize(p) < 50_000_000 and token in open(p, "rb").read().decode("utf-8", "ignore"):
+                    raise AssertionError(f"TOKEN encontrado em {p}!")
+            except (IsADirectoryError, PermissionError):
+                pass
+    print("verificação OK: fontes+provas+memórias presentes; zero estados; zero token")
+
+    # 6) A04: erradicação do token
+    del token
+    try:
+        from huggingface_hub import logout
+        logout()
+    except Exception:
+        pass
+    for p in [os.path.expanduser("~/.cache/huggingface/token"),
+              os.path.expanduser("~/.huggingface/token")]:
+        if os.path.exists(p):
+            os.remove(p)
+    os.environ.pop("HF_TOKEN", None)
+    os.environ.pop("HUGGING_FACE_HUB_TOKEN", None)
+    print("token HF apagado do ambiente e dos caches (logout executado)")
+    return 0
+
 
 if __name__ == "__main__":
-    main()
+    import os as _os, sys as _sys
+    _rc = main()
+    _sys.stdout.flush(); _sys.stderr.flush()
+    _os._exit(_rc if isinstance(_rc, int) else 0)

src/amostrador.rs

@@ -1,16 +1,23 @@
 //! Amostrador NCM (inferência) — port de `conceitos/amostrador.py` (n-04 §2.5).
 //!
 //! Laço de níveis (Teo B.2/B.4): EXATAMENTE L avaliações do gerador
-//! (NFE = L — V10; com CFG ativa são 2L — Cor. B.2.1, ainda ≪ T·N da difusão);
-//! parada anytime em k (Teo A.2/B.4); temperatura-auto por nível por bisseção
-//! de entropia (Teo D.3/28.8 — monotonia estrita de H em τ); CFG por
-//! interpolação de logits entre ramos condicionado/não-condicionado (Teo
-//! D.2(iii)); MBR com utilidade de concordância (Teo C.4/T6).
+//! (NFE = L — V10; com CFG ativa são 2L — Cor. B.2.1); parada anytime em k
+//! (Teo A.2/B.4); temperatura-auto por nível (Teo D.3/28.8; v0.3.0: ativada
+//! por `ncm.temperaturas.entropia_alvo`); CFG por interpolação de logits
+//! (Teo D.2(iii)); MBR com utilidade de concordância (Teo C.4/T6 — v0.3.0:
+//! INTEGRADO via `ncm.mbr.n_cand > 1`).
+//!
+//! v0.2.0: a primeira janela (prefixo + nível 1) usa a máscara CORRETA —
+//! prefixo causal (a v0.1.11 usava `vec![0.0]`: o prefixo via o nível 1,
+//! o condicionamento enxergava o que devia condicionar — X4).
+//! v0.3.0: cabeça de MISTURA DE PLANOS (amostragem paralela — Teo C-1(iii)),
+//! estado SSD + buffer pós-bloco-0 transportados (M2/M4) e resíduo algébrico
+//! do nível gerado (Teo G-1) como telemetria de geração.
 
 use candle_core::{Device, Result, Tensor, D};
 use crate::gerador::{GeradorConceitos, N_PREFIXO};
 use crate::tokenizador::TokenizadorConceitos;
-use crate::tronco::CacheKv;
+use crate::tronco::EstadoNivel;
 use rand::prelude::*;
 
 pub struct AmostradorConceitos {
@@ -21,12 +28,22 @@ pub struct AmostradorConceitos {
     pub limites_tau: [f64; 2],
     pub cfg_scale: f64,
     pub entropia_alvo: Option<f64>,
+    pub temperaturas_auto: bool,
+    /// resíduo algébrico do último nível gerado (Teo G-1 — telemetria)
+    pub residuo_algebrico_ultimo: f64,
 }
 
 unsafe impl Send for AmostradorConceitos {}
 
 impl AmostradorConceitos {
-    pub fn novo(gerador: &mut GeradorConceitos, tok: &TokenizadorConceitos, cfg_scale: f64, limites: [f64; 2], entropia_alvo: Option<f64>) -> Self {
+    pub fn novo(
+        gerador: &mut GeradorConceitos,
+        tok: &TokenizadorConceitos,
+        cfg_scale: f64,
+        limites: [f64; 2],
+        entropia_alvo: Option<f64>,
+        temperaturas_auto: bool,
+    ) -> Self {
         let l = gerador.niveis.len();
         AmostradorConceitos {
             gerador: gerador as *mut _,
@@ -36,6 +53,8 @@ impl AmostradorConceitos {
             limites_tau: limites,
             cfg_scale,
             entropia_alvo,
+            temperaturas_auto,
+            residuo_algebrico_ultimo: 0.0,
         }
     }
 
@@ -50,8 +69,8 @@ impl AmostradorConceitos {
     /// H(softmax(logits/τ)) é estritamente crescente em τ (lema do Teo 28.8).
     pub fn calibrar_tau(&self, logits: &Tensor, iters: usize) -> Result<f64> {
         let alvo = match self.entropia_alvo {
-            Some(h) => h,
-            None => return Ok(1.0),
+            Some(h) if self.temperaturas_auto => h,
+            _ => return Ok(1.0),
         };
         let (mut lo, mut hi) = (self.limites_tau[0], self.limites_tau[1]);
         for _ in 0..iters {
@@ -77,8 +96,8 @@ impl AmostradorConceitos {
             let t = &*self.tok;
             let l = g.niveis.len();
             let cfg_ativo = (self.cfg_scale - 1.0).abs() > 1e-9;
-            let mut caches_cond: Vec<CacheKv> = Vec::new();
-            let mut caches_uncond: Vec<CacheKv> = Vec::new();
+            let mut estado_cond = EstadoNivel::novo();
+            let mut estado_uncond = EstadoNivel::novo();
             let mut zhats: Vec<Tensor> = Vec::new();
             let mut codigos: Vec<Tensor> = Vec::new();
             let fim = parar_no_nivel.unwrap_or(l).min(l);
@@ -86,35 +105,33 @@ impl AmostradorConceitos {
             for nivel in 0..fim {
                 let n_l = g.niveis[nivel];
                 let entrada_cond = g.entrada_nivel_pub(zhats.last(), nivel, b, dev)?;
-                // ramo não-condicionado: mesmo nível com ẑ = 0 (D.2(iii))
                 let entrada_uncond = if cfg_ativo {
                     Some(g.entrada_nivel_pub(None, nivel, b, dev)?)
                 } else {
                     None
                 };
                 let (h_c, h_u): (Tensor, Option<Tensor>) = if nivel == 0 {
-                    // prefixo entra junto na 1ª avaliação
+                    // prefixo entra junto na 1ª avaliação — máscara da primeira
+                    // janela com prefixo CAUSAL (v0.2.0, X4/M1-incremental)
                     let prefixo_ids = Tensor::zeros((b, N_PREFIXO), candle_core::DType::U32, dev)?;
                     let pe = g.emb_niveis.tabela.fwd(&prefixo_ids)?;
                     let e = Tensor::cat(&[pe, entrada_cond], 1)?;
-                    let h = self.forward_bloco(g, &e, &mut caches_cond, nivel)?;
+                    let h = self.forward_bloco(g, &e, &mut estado_cond, nivel)?;
                     self.nfe_contador += 1;
                     let hc = h.narrow(1, N_PREFIXO, n_l)?;
                     let hu = if let Some(eu) = entrada_uncond {
-                        let eu2 = Tensor::cat(&[{
-                            let prefixo_ids2 = Tensor::zeros((b, N_PREFIXO), candle_core::DType::U32, dev)?;
-                            g.emb_niveis.tabela.fwd(&prefixo_ids2)?
-                        }, eu], 1)?;
-                        let hu = self.forward_bloco(g, &eu2, &mut caches_uncond, nivel)?;
+                        let prefixo_ids2 = Tensor::zeros((b, N_PREFIXO), candle_core::DType::U32, dev)?;
+                        let eu2 = Tensor::cat(&[g.emb_niveis.tabela.fwd(&prefixo_ids2)?, eu], 1)?;
+                        let hu = self.forward_bloco(g, &eu2, &mut estado_uncond, nivel)?;
                         self.nfe_contador += 1;
                         Some(hu.narrow(1, N_PREFIXO, n_l)?)
                     } else { None };
                     (hc, hu)
                 } else {
-                    let h = self.forward_bloco(g, &entrada_cond, &mut caches_cond, nivel)?;
+                    let h = self.forward_bloco(g, &entrada_cond, &mut estado_cond, nivel)?;
                     self.nfe_contador += 1;
                     let hu = if let Some(eu) = entrada_uncond {
-                        let hu = self.forward_bloco(g, &eu, &mut caches_uncond, nivel)?;
+                        let hu = self.forward_bloco(g, &eu, &mut estado_uncond, nivel)?;
                         self.nfe_contador += 1;
                         Some(hu)
                     } else { None };
@@ -123,6 +140,13 @@ impl AmostradorConceitos {
                 let ids = self.amostrar_nivel(g, &h_c, h_u.as_ref(), nivel, rng, greedy)?;
                 codigos.push(ids.clone());
                 zhats = t.reconstruir_de_codigos(&codigos, nivel + 1, b, dev)?;
+                // resíduo algébrico do nível gerado (Teo G-1 — telemetria)
+                if zhats.len() >= 2 {
+                    let n_ant = zhats[zhats.len() - 2].dim(1)?;
+                    let voltou = crate::mascaras::interp_para(&zhats[zhats.len() - 1], n_ant, dev)?;
+                    let dif = (&voltou - &zhats[zhats.len() - 2])?;
+                    self.residuo_algebrico_ultimo = dif.sqr()?.mean_all()?.to_scalar::<f32>()? as f64;
+                }
             }
             Ok((codigos, self.nfe_contador - nfe_inicio))
         }
@@ -132,16 +156,50 @@ impl AmostradorConceitos {
         &mut self,
         g: &mut GeradorConceitos,
         entrada: &Tensor,
-        caches: &mut Vec<CacheKv>,
+        estado: &mut EstadoNivel,
         nivel: usize,
     ) -> Result<Tensor> {
         let n_novo = entrada.dim(1)?;
-        let n_cache = caches.first().and_then(|c| c.k.as_ref()).map(|k| k.dims()[2]).unwrap_or(0);
+        let n_cache = estado
+            .caches
+            .first()
+            .and_then(|c| c.k.as_ref())
+            .map(|k| k.dims()[2])
+            .unwrap_or(0);
         let total_vis = n_cache + n_novo;
-        // block-causal incremental: posições novas veem cache + próprio bloco
-        let m = vec![0f32; n_novo * total_vis];
-        let mascara = Tensor::from_vec(m, (n_novo, total_vis), entrada.device())?;
-        let niveis_novos = vec![nivel + 1; n_novo];
+        // v0.2.0: na PRIMEIRA janela (prefixo + nível 1, sem cache) a máscara
+        // é o canto superior-esquerdo da block-causal: prefixo causal dentro
+        // do prefixo; nível 1 vê TUDO (bidirecional intra-nível, como no
+        // treino — Teo D.1(ii)). Nas demais: tudo visível (o bloco novo é o
+        // mais recente).
+        let mascara = if n_cache == 0 {
+            let total = n_novo;
+            let mut m = vec![f32::MIN; total * total];
+            // prefixo causal
+            for i in 0..N_PREFIXO.min(total) {
+                for j in 0..=i {
+                    m[i * total + j] = 0.0;
+                }
+            }
+            // posições do nível 1: veem o bloco inteiro (bidirecional)
+            for i in N_PREFIXO.min(total)..total {
+                for j in 0..total {
+                    m[i * total + j] = 0.0;
+                }
+            }
+            Tensor::from_vec(m, (total, total), entrada.device())?
+        } else {
+            let m = vec![0f32; n_novo * total_vis];
+            Tensor::from_vec(m, (n_novo, total_vis), entrada.device())?
+        };
+        // níveis dos queries: no 1º call inclui o prefixo (nível 0)
+        let niveis_novos = if n_cache == 0 {
+            let mut v = vec![0usize; N_PREFIXO.min(n_novo)];
+            v.extend(std::iter::repeat(nivel + 1).take(n_novo - N_PREFIXO.min(n_novo)));
+            v
+        } else {
+            vec![nivel + 1; n_novo]
+        };
         let mut niveis_totais = vec![0usize; N_PREFIXO.min(n_cache)];
         let restante = n_cache.saturating_sub(N_PREFIXO);
         let mut usados = 0usize;
@@ -152,7 +210,7 @@ impl AmostradorConceitos {
             usados += tomar;
         }
         niveis_totais.extend(niveis_novos.clone());
-        g.tronco.forward_nivel(entrada, caches, &mascara, &niveis_novos, &niveis_totais)
+        g.tronco.forward_nivel(entrada, estado, &mascara, nivel + 1, &niveis_novos, &niveis_totais)
     }
 
     unsafe fn amostrar_nivel(
@@ -164,6 +222,53 @@ impl AmostradorConceitos {
         rng: &mut StdRng,
         greedy: bool,
     ) -> Result<Tensor> {
+        // v0.3.0: cabeça de MISTURA (amostragem paralela — Teo C-1(iii))
+        // quando ativa; senão a cabeça produto da v0.1.11.
+        let usar_mistura = g.m_planos >= 2 && !g.cabecas_mistura.is_empty();
+        if usar_mistura {
+            let cab = &g.cabecas_mistura[nivel];
+            let (ids, _planos) = if let Some(hu) = h_uncond {
+                // CFG sobre os PESOS e LOGITS por plano: mistura interpolada
+                // l̃_m,i = l^u_m,i + s·(l^c_m,i − l^u_m,i); w̃ = w^u + s·(w^c − w^u)
+                let (ids_c, _) = cab.amostrar(h_cond, rng, greedy)?;
+                let _ = ids_c;
+                // simplificação honesta: interpola os LOGITS MARGINAIS
+                let lm_c = cab.logits_marginais(h_cond)?;
+                let lm_u = cab.logits_marginais(hu)?;
+                let dif = (&lm_c - &lm_u)?.affine(self.cfg_scale, 0.0)?;
+                let misto = (&lm_u + &dif)?;
+                let (b, n_l, k) = (misto.dim(0)?, misto.dim(1)?, misto.dim(2)?);
+                let plano = misto.reshape((b * n_l, k))?;
+                let tau = self.calibrar_tau(&plano, 8)?;
+                self.temperaturas[nivel] = tau;
+                let probs = candle_nn::ops::softmax(&plano.affine(1.0 / tau.max(1e-3), 0.0)?, D::Minus1)?;
+                let pv = probs.flatten_all()?.to_vec1::<f32>()?;
+                let mut ids = Vec::with_capacity(b * n_l);
+                for i in 0..b * n_l {
+                    if greedy {
+                        let (mut melhor, mut mi) = (-1f32, 0usize);
+                        for (j, v) in pv[i * k..(i + 1) * k].iter().enumerate() {
+                            if *v > melhor { melhor = *v; mi = j; }
+                        }
+                        ids.push(mi as u32);
+                    } else {
+                        let r: f32 = rng.gen();
+                        let mut acc = 0f32;
+                        let mut esc = k - 1;
+                        for (j, v) in pv[i * k..(i + 1) * k].iter().enumerate() {
+                            acc += *v;
+                            if r <= acc { esc = j; break; }
+                        }
+                        ids.push(esc as u32);
+                    }
+                }
+                (Tensor::from_vec(ids, (b, n_l), misto.device())?, vec![])
+            } else {
+                cab.amostrar(h_cond, rng, greedy)?
+            };
+            return Ok(ids);
+        }
+        // cabeça produto (v0.1.11 — bit-a-bit)
         let logits_cond = g.cabeca.cabecas[nivel].fwd(h_cond)?;
         let plano = match h_uncond {
             Some(hu) => {
@@ -176,10 +281,10 @@ impl AmostradorConceitos {
         };
         let (b, n_l, _) = (plano.dim(0)?, plano.dim(1)?, plano.dim(2)?);
         let plano2 = plano.reshape((b * n_l, g.k))?;
-        // temperatura-auto por nível (D.3)
+        // temperatura-auto por nível (D.3 — v0.3.0: ativa com entropia_alvo)
         let tau = self.calibrar_tau(&plano2, 8)?;
         self.temperaturas[nivel] = tau;
-        let probs = candle_nn::ops::softmax_last_dim(&plano2.affine(1.0 / tau.max(1e-3), 0.0)?)?;
+        let probs = candle_nn::ops::softmax(&plano2.affine(1.0 / tau.max(1e-3), 0.0)?, D::Minus1)?;
         let plana = probs.flatten_all()?.to_vec1::<f32>()?;
         let k = g.k;
         let mut ids = Vec::with_capacity(b * n_l);

src/atencao.rs

@@ -3,33 +3,61 @@
 //! de NCM"). Prova completa na memória r-04; síntese:
 //!
 //! (i)  [paralelismo preservado] o resumo-âncora por nível h_ℓ é função
-//!      APENAS de c_{<ℓ} (computado do cache/entrada corrente), logo a
+//!      APENAS de c_{<ℓ} (computado do buffer/entrada corrente), logo a
 //!      fatoração p(c_ℓ|c_{<ℓ}) = Π_i p(c_{ℓ,i}|c_{<ℓ}) e NFE = L
 //!      permanecem EXATOS (Teo B.2/D.1);
-//! (ii) [expressividade ⊇ NCM] com γ=0, w_ℓ'=1, τ_ℓ=1 a ADBA reduz-se à
+//! (ii) [expressividade ⊇ NCM] com γ=0, ξ=0, ζ=0 a ADBA reduz-se à
 //!      atenção block-causal do NCM (classe estritamente contida);
 //! (iii)[planejamento reforçado] o âncora agrega o estado global dos níveis
-//!      anteriores num vetor por nível — injetado por FiLM — fortalecendo a
-//!      hipótese H2 do Teo C.2 (condicionais consistentes dado o plano).
+//!      anteriores num vetor por nível — injetado por FiLM.
 //!
-//! Componentes: (a) atenção multi-cabeça com máscara aditiva arbitrária +
-//! KV-cache; (b) reponderação aprendível w_{ℓ'} dos logits por nível-fonte;
-//! (c) temperatura aprendível τ_ℓ por nível; (d) injeção FiLM do resumo.
+//! ## v0.3.0 — reponderação e temperatura por (NÍVEL, CABEÇA) com limites
+//! (método A.1.2 da proposta C; corrige M5/M6 da auditoria r-08)
+//!
+//!   logit(i,j) = ⟨q_i,k_j⟩/(√d_h·τ_{h,λ(i)}) + L_W·tanh(ξ_{h,λ(j)})
+//!   τ_{h,ℓ}    = exp(T_τ·tanh(ζ_{h,ℓ}))
+//!
+//! **Teo A-1 (neutralidade e estabilidade).**
+//! (i) *Nascimento neutro*: ξ=0 ⇒ peso w = e^0 = 1; ζ=0 ⇒ τ = e^0 = 1; as
+//! operações `+0.0` e `/1.0` são exatas em f32 (exceto −0.0→+0.0, sem efeito
+//! no softmax) ⇒ a primeira passada é bit-a-bit a atenção block-causal.
+//! (ii) *Limites*: |log w| ≤ L_W e τ ∈ [e^{−T_τ}, e^{T_τ}] ⇒ a razão entre
+//! pesos de nível é ≤ e^{2L_W}: o mecanismo NÃO pode colapsar o softmax em
+//! uniforme (exigiria razão → ∞) nem saturar (τ→0). O `clamp` da v0.1.11 —
+//! que tinha gradiente NULO fora da faixa (M6, "dead gradient") — é removido:
+//! tanh tem gradiente sech² > 0 em todo R.
+//! (iii) *Gradientes limitados*: |∂L/∂ζ| ≤ (T_τ/τ_min)·|Cov_p(u,ḡ)| e
+//! |∂L/∂ξ| ≤ L_W·|Σ p·Δ| — sem modo explosivo (Teo A.1.2 da proposta C).
+//! (iv) *Capacidade*: o espaço de reponderações vai de R^{L+1} (v0.1.11,
+//! 1 escalar por nível para TODAS as cabeças) para R^{H·(L+1)} — com H=4,
+//! L=7: 32 parâmetros por bloco. Estritamente mais expressivo: duas cabeças
+//! podem confiar diferentemente no mesmo nível-fonte.
+//! (v) *Fatoração preservada*: ξ e ζ são funções de ÍNDICES de posição
+//! (λ(·), h) — nunca de VALORES — logo o Teo A.1.4 da proposta C aplica-se
+//! (a distribuição preditiva p(c_ℓ|c_{<ℓ}) permanece bem definida).
 
 use candle_core::{Result, Tensor, Var, D};
 use crate::camadas::{Linear, RmsNorm, Swiglu};
 
+/// Limites padrão da parametrização tanh (Teo A-1(ii)).
+pub const LIMITE_LOG_W: f64 = 2.0; // w ∈ [e⁻², e²]
+pub const LIMITE_TAU: f64 = 1.0;   // τ ∈ [e⁻¹, e]
+
 pub struct CabecaAdba {
     pub q: Linear,
     pub k: Linear,
     pub v: Linear,
     pub o: Linear,
-    /// Reponderação de logits por nível-fonte (len = nº de níveis + 1 p/ prefixo).
-    pub w_nivel: Option<Var>,
-    /// Temperatura aprendível por nível (log-espaço, neutro = 0).
-    pub log_tau_nivel: Option<Var>,
+    /// Parâmetro cru da reponderação por (nível-fonte, cabeça): (H, L+1).
+    /// log w_{h,ℓ} = L_W·tanh(ξ_{h,ℓ}); init 0 ⇒ w = 1 (neutro).
+    pub xi: Option<Var>,
+    /// Parâmetro cru da temperatura por (nível-query, cabeça): (H, L+1).
+    /// τ_{h,ℓ} = exp(T_τ·tanh(ζ_{h,ℓ})); init 0 ⇒ τ = 1 (neutro).
+    pub zeta: Option<Var>,
     pub n_cabecas: usize,
     pub d_cabeca: usize,
+    pub limite_log_w: f64,
+    pub limite_tau: f64,
 }
 
 #[derive(Default, Clone)]
@@ -39,24 +67,43 @@ pub struct CacheKv {
 }
 
 impl CabecaAdba {
-    pub fn nova(d_modelo: usize, n_cabecas: usize, n_niveis: usize, adba_ativo: bool, reponderar: bool, tau_nivel: bool, dev: &candle_core::Device) -> Result<Self> {
+    pub fn nova(
+        d_modelo: usize,
+        n_cabecas: usize,
+        n_niveis: usize,
+        adba_ativo: bool,
+        reponderar: bool,
+        tau_nivel: bool,
+        dev: &candle_core::Device,
+    ) -> Result<Self> {
         let d_cabeca = d_modelo / n_cabecas;
         let desvio = 1.0 / ((d_modelo * 2) as f64).sqrt();
         let mk = || Linear::sem_vies(d_modelo, d_modelo, desvio, dev);
-        let w_nivel = if adba_ativo && reponderar {
-            Some(Var::from_tensor(&Tensor::ones((n_niveis + 1,), candle_core::DType::F32, dev)?)?)
+        // (H, L+1) — nascimento neutro: zeros ⇒ w=1, τ=1
+        let xi = if adba_ativo && reponderar {
+            Some(Var::from_tensor(&Tensor::zeros(
+                (n_cabecas, n_niveis + 1),
+                candle_core::DType::F32,
+                dev,
+            )?)?)
         } else {
             None
         };
-        let log_tau_nivel = if adba_ativo && tau_nivel {
-            Some(Var::from_tensor(&Tensor::zeros((n_niveis + 1,), candle_core::DType::F32, dev)?)?)
+        let zeta = if adba_ativo && tau_nivel {
+            Some(Var::from_tensor(&Tensor::zeros(
+                (n_cabecas, n_niveis + 1),
+                candle_core::DType::F32,
+                dev,
+            )?)?)
         } else {
             None
         };
         Ok(CabecaAdba {
             q: mk()?, k: mk()?, v: mk()?, o: mk()?,
-            w_nivel, log_tau_nivel,
+            xi, zeta,
             n_cabecas, d_cabeca,
+            limite_log_w: LIMITE_LOG_W,
+            limite_tau: LIMITE_TAU,
         })
     }
 
@@ -77,6 +124,9 @@ impl CabecaAdba {
     /// Atenção com máscara aditiva (T_k × T_k) e offsets de nível para a
     /// reponderação/temperatura da ADBA. `niveis_query`/`niveis_chave` dizem
     /// a qual nível (0=prefixo, 1..L) pertence cada posição.
+    ///
+    /// Vetorizado (v0.3.0): os vieses são construídos por `index_select` —
+    /// nenhum laço `.get()` por posição (A-correção de desempenho).
     pub fn attention(
         &self,
         x: &Tensor,
@@ -97,30 +147,37 @@ impl CabecaAdba {
         cache.v = Some(v.clone());
         let escala = 1.0 / (self.d_cabeca as f64).sqrt();
         let mut scores = q.matmul(&k.transpose(2, 3)?)?.affine(escala, 0.0)?;
-        // ADBA (ii): reponderação por nível-fonte — score += log w_{ℓ'}
-        if let (Some(w), Some(nq), Some(nk)) = (&self.w_nivel, niveis_query, niveis_chave) {
+        // ADBA (ii): reponderação por (nível-fonte, cabeça) — bias = L_W·tanh(ξ)
+        if let (Some(xi), Some(_nq), Some(nk)) = (&self.xi, niveis_query, niveis_chave) {
             let t_k = scores.dim(3)?;
-            let w_clamped = w.as_tensor().clamp(1e-3f32, 1e3f32)?;
-            let log_w = (&w_clamped + 1e-8)?.log()?;
-            let mut biases = vec![0f32; t_k];
-            for (j, &nivel) in nk.iter().enumerate().take(t_k) {
-                biases[j] = log_w.get(nivel)?.to_scalar::<f32>()?;
-            }
-            let _ = nq;
-            let bias = Tensor::from_vec(biases, (t_k,), x.device())?;
-            scores = scores.broadcast_add(&bias.reshape((1, 1, 1, t_k))?)?;
+            let idx = Tensor::from_vec(
+                nk.iter().take(t_k).map(|&n| n as u32).collect::<Vec<u32>>(),
+                (t_k,),
+                x.device(),
+            )?;
+            // xi (H, L+1) → index_select colunas → (H, t_k)
+            let bias = xi
+                .as_tensor()
+                .index_select(&idx, 1)?
+                .tanh()?
+                .affine(self.limite_log_w as f64, 0.0)?;
+            scores = scores.broadcast_add(&bias.reshape((1, self.n_cabecas, 1, t_k))?)?;
         }
-        // ADBA (iii): temperatura por nível do QUERY
-        if let (Some(lt), Some(nq), _) = (&self.log_tau_nivel, niveis_query, niveis_chave) {
+        // ADBA (iii): temperatura por (nível do QUERY, cabeça) — τ = e^{T·tanh(ζ)}
+        if let (Some(zeta), Some(nq), _) = (&self.zeta, niveis_query, niveis_chave) {
             let t_q = scores.dim(2)?;
-            let tau = lt.as_tensor().affine(0.1, 0.0)?.exp()?; // suave (±~10% por unidade)
-            let mut fatores = vec![1f32; t_q];
-            for (i, &nivel) in nq.iter().enumerate().take(t_q) {
-                fatores[i] = tau.get(nivel)?.to_scalar::<f32>()?;
-            }
-            let f = Tensor::from_vec(fatores, (t_q,), x.device())?
-                .reshape((1, 1, t_q, 1))?;
-            scores = scores.broadcast_div(&f)?;
+            let idx = Tensor::from_vec(
+                nq.iter().take(t_q).map(|&n| n as u32).collect::<Vec<u32>>(),
+                (t_q,),
+                x.device(),
+            )?;
+            let tau = zeta
+                .as_tensor()
+                .index_select(&idx, 1)?
+                .tanh()?
+                .affine(self.limite_tau as f64, 0.0)?
+                .exp()?;
+            scores = scores.broadcast_div(&tau.reshape((1, self.n_cabecas, t_q, 1))?)?;
         }
         if let Some(m) = mascara {
             scores = scores.broadcast_add(m)?;
@@ -132,8 +189,8 @@ impl CabecaAdba {
 
     pub fn vars(&self) -> Vec<Var> {
         let mut v: Vec<Var> = [self.q.vars(), self.k.vars(), self.v.vars(), self.o.vars()].concat();
-        if let Some(w) = &self.w_nivel { v.push(w.clone()); }
-        if let Some(t) = &self.log_tau_nivel { v.push(t.clone()); }
+        if let Some(w) = &self.xi { v.push(w.clone()); }
+        if let Some(t) = &self.zeta { v.push(t.clone()); }
         v
     }
 }
@@ -179,25 +236,30 @@ impl BlocoAdba {
 /// Resumo-âncora por nível (ADBA i): h_ℓ = Attn(q_ℓ, K/V = c_{<ℓ}) — pooling
 /// sobre as posições dos níveis anteriores (função de c_{<ℓ} APENAS).
 pub struct AncoraNivel {
-    pub q: Var, // (d,) vetor de consulta aprendível por nível — (L, d)
+    pub q: Var, // (L, d) consultas aprendíveis por nível
     pub proj: Linear,
 }
 
 impl AncoraNivel {
     pub fn nova(d: usize, n_niveis: usize, dev: &candle_core::Device) -> Result<Self> {
-        let q = Tensor::randn(0f32, 0.02, (n_niveis, d), dev)?;
+        let q = crate::rng::randn_semeado(0.02, &[n_niveis, d], dev)?;
         Ok(AncoraNivel { q: Var::from_tensor(&q)?, proj: Linear::novo(d, d, 0.02, dev)? })
     }
 
-    /// contexto (1, n_ctx, d) das posições dos níveis < ℓ → resumo (1, d).
+    /// BATCHED (M17/A32): contexto (b, n_ctx, d) das posições dos níveis < ℓ
+    /// → resumo (b, d). Uma única chamada de kernel por nível (a v0.1.11
+    /// fazia b chamadas sequenciais).
     pub fn resumir(&self, contexto: &Tensor, nivel: usize) -> Result<Tensor> {
+        let b = contexto.dim(0)?;
         let d = self.q.as_tensor().dim(1)?;
         let q = self.q.as_tensor().get(nivel)?.reshape((1, 1, d))?;
-        // atenção de cabeça única: softmax(q·Kᵀ/√d)·V
+        // atenção de cabeça única batched: (1,1,d) @ (b,d,n_ctx) → (b,1,n_ctx)
         let escala = 1.0 / (d as f64).sqrt();
-        let scores = q.matmul(&contexto.transpose(1, 2)?)?.affine(escala, 0.0)?;
+        let scores = q
+            .broadcast_matmul(&contexto.transpose(1, 2)?.contiguous()?)?
+            .affine(escala, 0.0)?;
         let pesos = candle_nn::ops::softmax(&scores, D::Minus1)?;
-        let resumo = pesos.matmul(contexto)?.reshape((1, d))?;
+        let resumo = pesos.matmul(contexto)?.reshape((b, d))?;
         self.proj.fwd(&resumo)
     }
 
@@ -207,3 +269,39 @@ impl AncoraNivel {
         v
     }
 }
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    /// Gate G5 (parte): nascimento neutro — ξ=ζ=0 ⇒ w=1, τ=1 bit-a-bit.
+    #[test]
+    fn gate_nascimento_neutro_adba() -> Result<()> {
+        let dev = candle_core::Device::Cpu;
+        crate::rng::inicializar(777);
+        let x = crate::rng::randn_semeado(1.0, &[1, 12, 32], &dev)?;
+        let attn = CabecaAdba::nova(32, 4, 3, true, true, true, &dev)?;
+        let niveis = vec![0usize, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3];
+        // com ADBA (ξ=ζ=0) vs sem ADBA (None): saídas idênticas bit-a-bit
+        let mut c1 = CacheKv::default();
+        let y1 = attn.attention(&x, None, &mut c1, Some(&niveis), Some(&niveis))?;
+        let attn2 = CabecaAdba::nova(32, 4, 3, false, false, false, &dev)?;
+        // mesmos pesos q/k/v/o: copia
+        let dif = attn.q.w.as_tensor().sub(attn2.q.w.as_tensor())?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif > 0.0, "pesos distintos por semente");
+        // com pesos iguais a saída deve ser igual — testa via MESMA instância com
+        // xi/zeta zerados (já são) contra uma instância sem ADBA com mesmos pesos:
+        // em vez disso, verifica w=1 e τ=1 diretamente
+        if let Some(xi) = &attn.xi {
+            let w = xi.as_tensor().tanh()?.affine(LIMITE_LOG_W, 0.0)?.exp()?;
+            let dif = (&w - &Tensor::ones(w.shape(), w.dtype(), w.device())?)?.abs()?.max_all()?.to_scalar::<f32>()?;
+            assert_eq!(dif, 0.0, "w=1 no nascimento");
+        }
+        if let Some(zeta) = &attn.zeta {
+            let tau = zeta.as_tensor().tanh()?.affine(LIMITE_TAU, 0.0)?.exp()?;
+            let dif = (&tau - &Tensor::ones(tau.shape(), tau.dtype(), tau.device())?)?.abs()?.max_all()?.to_scalar::<f32>()?;
+            assert_eq!(dif, 0.0, "τ=1 no nascimento");
+        }
+        Ok(())
+    }
+}

src/camadas.rs

@@ -5,6 +5,8 @@
 use candle_core::{DType, Device, Result, Tensor, Var};
 use candle_nn::ops::rms_norm;
 
+// v0.3.0: init via RNG semeado (A19) — Tensor::randn usava entropia do SO.
+
 pub struct Linear {
     pub w: Var, // (d_saida, d_entrada)
     pub b: Option<Var>,
@@ -12,13 +14,13 @@ pub struct Linear {
 
 impl Linear {
     pub fn novo(d_entrada: usize, d_saida: usize, desvio: f64, dev: &Device) -> Result<Self> {
-        let w = Tensor::randn(0f32, desvio as f32, (d_saida, d_entrada), dev)?;
+        let w = crate::rng::randn_semeado(desvio as f32, &[d_saida, d_entrada], dev)?;
         let b = Tensor::zeros((d_saida,), DType::F32, dev)?;
         Ok(Linear { w: Var::from_tensor(&w)?, b: Some(Var::from_tensor(&b)?) })
     }
 
     pub fn sem_vies(d_entrada: usize, d_saida: usize, desvio: f64, dev: &Device) -> Result<Self> {
-        let w = Tensor::randn(0f32, desvio as f32, (d_saida, d_entrada), dev)?;
+        let w = crate::rng::randn_semeado(desvio as f32, &[d_saida, d_entrada], dev)?;
         Ok(Linear { w: Var::from_tensor(&w)?, b: None })
     }
 
@@ -61,7 +63,7 @@ pub struct Embedding {
 
 impl Embedding {
     pub fn novo(vocab: usize, d: usize, dev: &Device) -> Result<Self> {
-        let t = Tensor::randn(0f32, 0.02, (vocab, d), dev)?;
+        let t = crate::rng::randn_semeado(0.02, &[vocab, d], dev)?;
         Ok(Embedding { tabela: Var::from_tensor(&t)? })
     }
 

src/config.rs

@@ -1,6 +1,13 @@
 //! Config do KHTST_RUST — espelha `configs/base.json` do KHTST v23 + seção `ncm`
 //! (n-04 §3) + seções novas (rust/adba/ponte/telemetria). Defaults neutros
-//! (nascimento neutro, T10): `ncm.ativo=false` E `lambdas.conceito=0.0` (dupla trava).
+//! (nascimento neutro, T10): `ncm.ativo=false` E `lambdas.conceito=0.0` (dupla
+//! trava — v0.3.0: a trava agora é LIDA pelo código: `ncm.ativo=false` força
+//! ADBA/SSD-Δ/mistura/λ_alg desligados).
+//!
+//! v0.3.0 (A25): TODAS as structs usam `#[serde(deny_unknown_fields)]` —
+//! chave digitada errada (ex.: "d_model") agora FALHA com mensagem do serde
+//! em vez de ser ignorada em silêncio; o `lint_config` (Levenshtein) fornece
+//! a sugestão de correção.
 
 use serde::{Deserialize, Serialize};
 
@@ -9,6 +16,7 @@ fn padrao_niveis() -> Vec<usize> {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
 pub struct MoE {
     #[serde(default = "d_true")]
     pub ativo: bool,
@@ -22,6 +30,7 @@ fn d_usize2() -> usize { 2 }
 fn d_usize4() -> usize { 4 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct MTP {
     #[serde(default = "d_true")]
     pub ativo: bool,
@@ -40,6 +49,7 @@ impl Default for MTP {
 fn d_f005() -> f64 { 0.05 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Modelo {
     pub vocab: usize,
     pub d_modelo: usize,
@@ -55,6 +65,10 @@ pub struct Modelo {
     pub mtp: MTP,
     #[serde(default = "d_true")]
     pub usar_atencao_arvore: bool,
+    /// v0.3.0: porta aditiva de 2ª ordem do SSD (SSD-Δ) — percepção de
+    /// aritmética de inteiros/floats (Teo S-1). Default false = neutro.
+    #[serde(default)]
+    pub ssd_delta: bool,
 }
 impl Default for Modelo {
     fn default() -> Self {
@@ -70,11 +84,13 @@ impl Default for Modelo {
             moe: MoE::default(),
             mtp: MTP::default(),
             usar_atencao_arvore: true,
+            ssd_delta: false,
         }
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Gsq {
     pub tau0: f64,
     pub tau_min: f64,
@@ -85,23 +101,32 @@ impl Default for Gsq {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct NestedDropout {
     #[serde(default = "d_tipo_nd")]
     pub tipo: String,
 }
 fn d_tipo_nd() -> String { "uniforme".into() }
+impl Default for NestedDropout {
+    fn default() -> Self { NestedDropout { tipo: "uniforme".into() } }
+}
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Lambdas {
     pub conceito: f64,
     pub rec: f64,
     pub rho_ancora: f64,
+    /// v0.3.0: peso do verificador algébrico L_alg (Teo G-1). 0 = desligado.
+    #[serde(default)]
+    pub algebrico: f64,
 }
 impl Default for Lambdas {
-    fn default() -> Self { Lambdas { conceito: 0.0, rec: 1.0, rho_ancora: 0.05 } }
+    fn default() -> Self { Lambdas { conceito: 0.0, rec: 1.0, rho_ancora: 0.05, algebrico: 0.0 } }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Temperaturas {
     pub auto: bool,
     pub entropia_alvo: Option<f64>,
@@ -113,6 +138,7 @@ impl Default for Temperaturas {
 
 /// Seção `ncm` — schema aditivo do n-04 §3 (defaults 100% neutros).
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Ncm {
     pub ativo: bool,
     #[serde(default = "padrao_niveis")]
@@ -121,10 +147,12 @@ pub struct Ncm {
     pub k_por_nivel: usize,
     pub ema_codebook: f64,
     pub beta_commit: f64,
+    #[serde(default)]
     pub nested_dropout: NestedDropout,
     pub corrupcao_cond: f64,
     pub dropout_cfg: f64,
     pub cfg_scale: f64,
+    #[serde(default)]
     pub gsq: Gsq,
     #[serde(default = "d_pesos_nivel")]
     pub pesos_nivel: String,
@@ -132,8 +160,9 @@ pub struct Ncm {
     pub lambdas: Lambdas,
     #[serde(default)]
     pub temperaturas: Temperaturas,
+    #[serde(default)]
     pub mbr: Mbr,
-    /// Modo da escala R_ℓ dos codebooks: "ema_projecao" | "otima_teo" | "aprendida" (r-01 §4.4).
+    /// Modo da escala R_ℓ dos codebooks: "ema_projecao" | "otima_teo".
     #[serde(default = "d_escala_r")]
     pub escala_r: String,
     /// Modo de quantização: "gsq_rco" (padrão, Teo D.4) | "ste_ema" (Teo A.0).
@@ -142,10 +171,16 @@ pub struct Ncm {
     /// Níveis como tokens (modo D.6 — MTP equivalente).
     #[serde(default)]
     pub niveis_token: bool,
+    /// v0.3.0 — MISTURA DE PLANOS (raciocínio em subníveis paralelos):
+    /// nº de planos M por nível na cabeça (Teo C-1). 1 = cabeça produto
+    /// da v0.1.11 (bit-a-bit). ≥ 2 = mistura.
+    #[serde(default = "d_um")]
+    pub mistura_planos: usize,
 }
 fn d_pesos_nivel() -> String { "uniforme".into() }
 fn d_escala_r() -> String { "ema_projecao".into() }
 fn d_modo_quant() -> String { "gsq_rco".into() }
+fn d_um() -> usize { 1 }
 
 impl Default for Ncm {
     fn default() -> Self {
@@ -168,11 +203,13 @@ impl Default for Ncm {
             escala_r: "ema_projecao".into(),
             modo_quantizacao: "gsq_rco".into(),
             niveis_token: false,
+            mistura_planos: 1,
         }
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Mbr {
     pub n_cand: usize,
 }
@@ -182,23 +219,33 @@ impl Default for Mbr {
 
 /// ADBA — Atenção Dual-Bloco Adaptativa (aprimoramento 1; prova em r-04).
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Adba {
     pub ativo: bool,
     /// Peso FiLM do resumo-âncora por nível (0 = NCM puro).
     pub gamma_ancora: f64,
-    /// Reponderação aprendível dos logits por nível-fonte (true = ativa).
+    /// Reponderação aprendível dos logits por (nível, cabeça) (true = ativa).
     pub reponderacao_nivel: bool,
-    /// Temperatura aprendível por nível (true = ativa).
+    /// Temperatura aprendível por (nível, cabeça) (true = ativa).
     pub temperatura_nivel: bool,
+    /// v0.3.0: limite |log w| da reponderação (Teo A-1(ii); padrão 2.0).
+    #[serde(default = "d_lim_w")]
+    pub limite_log_w: f64,
+    /// v0.3.0: limite τ ∈ [e⁻x, eˣ] (padrão 1.0).
+    #[serde(default = "d_lim_tau")]
+    pub limite_tau: f64,
 }
+fn d_lim_w() -> f64 { 2.0 }
+fn d_lim_tau() -> f64 { 1.0 }
 impl Default for Adba {
     fn default() -> Self {
-        Adba { ativo: true, gamma_ancora: 1.0, reponderacao_nivel: true, temperatura_nivel: true }
+        Adba { ativo: true, gamma_ancora: 1.0, reponderacao_nivel: true, temperatura_nivel: true, limite_log_w: 2.0, limite_tau: 1.0 }
     }
 }
 
 /// Ponte Dupla — comunicação paralela bidirecional entre modelos (aprimoramento 2; prova em r-05).
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Ponte {
     pub ativo: bool,
     pub capacidade: usize,
@@ -210,6 +257,7 @@ impl Default for Ponte {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Treino {
     pub lr: f64,
     pub aquecimento: usize,
@@ -220,8 +268,16 @@ pub struct Treino {
     pub peso_decaimento: f64,
     #[serde(default = "d_usize25")]
     pub telemetria_a_cada: usize,
+    /// v0.3.0 (A19): semente do RNG global (reprodutibilidade bit-a-bit).
+    #[serde(default = "d_semente")]
+    pub semente: u64,
+    /// v0.3.0: checkpoint periódico a cada N passos (0 = só no fim) —
+    /// proteção contra o encerramento em background do ambiente.
+    #[serde(default)]
+    pub checkpoint_a_cada: usize,
 }
 fn d_usize25() -> usize { 25 }
+fn d_semente() -> u64 { 317 }
 impl Default for Treino {
     fn default() -> Self {
         Treino {
@@ -233,17 +289,23 @@ impl Default for Treino {
             clip: 1.0,
             peso_decaimento: 0.01,
             telemetria_a_cada: 25,
+            semente: 317,
+            checkpoint_a_cada: 0,
         }
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct TelemetriaCfg {
     pub jsonl: bool,
     pub deteccao_aprendizado: bool,
     pub ajuste_automatico: bool,
     pub paciencia_plateau: usize,
     pub fator_lr_plateau: f64,
+    /// A24: truncar o JSONL no início (default false = append).
+    #[serde(default)]
+    pub truncar_jsonl: bool,
 }
 impl Default for TelemetriaCfg {
     fn default() -> Self {
@@ -253,19 +315,26 @@ impl Default for TelemetriaCfg {
             ajuste_automatico: true,
             paciencia_plateau: 200,
             fator_lr_plateau: 0.6,
+            truncar_jsonl: false,
         }
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
 pub struct Dados {
+    #[serde(default)]
     pub shard_treino: String,
+    #[serde(default)]
     pub shard_validacao: String,
+    #[serde(default)]
     pub max_artigos: usize,
+    #[serde(default)]
     pub max_bytes: usize,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct MemoriaCfg {
     pub som_lado: usize,
     pub lambda_jepa: f64,
@@ -276,6 +345,7 @@ impl Default for MemoriaCfg {
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct ConfigKhtst {
     #[serde(default)]
     pub modelo: Modelo,
@@ -326,22 +396,48 @@ impl ConfigKhtst {
         if self.treino.lote == 0 || self.treino.lr <= 0.0 {
             return Err("treino.lote >= 1 e treino.lr > 0 exigidos".into());
         }
+        if n.mistura_planos == 0 {
+            return Err("ncm.mistura_planos >= 1 exigido (1 = cabeça produto neutra)".into());
+        }
         Ok(())
     }
 
     /// L (número de níveis) — Teo B.2(ii).
     pub fn l_niveis(&self) -> usize { self.ncm.niveis.len() }
 
-    /// Verificação de orçamento do KV-cache (T2): |cond| + Σ_{j<L} n_j ≤ kv_cache_max.
+    /// Verificação de orçamento do KV-cache (T2 + M15): a v0.1.11 calculava
+    /// `ctx + soma − ctx` = soma (508), IGNORANDO as 8 posições de prefixo —
+    /// a sequência real tem 516. Agora: `N_PREFIXO + Σ n_ℓ` (gate G6).
     pub fn checar_orcamento_cache(&self) -> Result<usize, String> {
         let soma: usize = self.ncm.niveis.iter().copied().sum();
-        let usado = self.modelo.comprimento_ctx + soma - self.modelo.comprimento_ctx; // cond + níveis < L
+        let n_prefixo = crate::gerador::N_PREFIXO;
+        let usado = n_prefixo + soma;
         if usado > self.modelo.kv_cache_max {
             return Err(format!(
-                "orçamento do KV-cache violado (T2): {} > kv_cache_max = {}",
-                usado, self.modelo.kv_cache_max
+                "orçamento do KV-cache violado (T2): {} (prefixo {} + Σ níveis {}) > kv_cache_max = {}",
+                usado, n_prefixo, soma, self.modelo.kv_cache_max
             ));
         }
         Ok(usado)
     }
 }
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    /// Gate G6: orçamento com prefixo = 516 (a v0.1.11 devolvia 508).
+    #[test]
+    fn orcamento_cache_inclui_prefixo() {
+        let cfg = ConfigKhtst::default();
+        assert_eq!(cfg.checar_orcamento_cache().unwrap(), 8 + 508);
+    }
+
+    /// A25: chave digitada errada deve FALHAR (a v0.1.11 ignorava em silêncio).
+    #[test]
+    fn chave_errada_falha() {
+        let txt = r#"{"modelo": {"vocab": 100, "d_model": 192}}"#;
+        let r: Result<ConfigKhtst, _> = serde_json::from_str(txt);
+        assert!(r.is_err(), "d_model (typo) deve ser rejeitado por deny_unknown_fields");
+    }
+}

src/controlador.rs

@@ -2,19 +2,38 @@
 //! automatizados de todos hiper parâmetros"). TODA decisão é registrada na
 //! telemetria com motivo (auditável).
 //!
-//! - LR: aquecimento → cosseno; plateau (paciência) → ×fator; divergência
-//!   (NaN ou perda > 2× mínimo EMA) → ×0,3 + rollback do estado;
-//! - λ (âncora, Teo 29.2): hipergradiente exato;
-//! - ε da corrupção (Teo C.3(ii)): calibra pela taxa de erro por nível em
-//!   validação (cobertura — "calibrar ρ tal que erro ≤ ρ");
-//! - clip: adapta ao percentil da norma de gradiente;
-//! - τ do GSQ: agenda analítica (Teo 30.6) — no tokenizador.
+//! ## v0.2.0 — M9: LR com multiplicador e RECUPERAÇÃO (a v0.1.11 era um
+//! "ratchet": `lr = min(lr_corrente, lr_prog)` com lr_corrente só
+//! decrescente — um único plateau/divergência matava o treino para sempre,
+//! e o "rollback do estado" prometido no docstring não existia).
+//!
+//! **Teo C-2 (convergência do multiplicador).** Seja m_t o multiplicador
+//! (1.0 no início; ×0.3 em divergência; recuperação ×(1+κ) por passo, cap 1).
+//! O LR aplicado é lr_t = m_t · lr_prog(t). Então:
+//! (i) m_t ≤ 1 sempre (o multiplicador nunca AMPLIA o LR além da agenda);
+//! (ii) após a última divergência em t*, m_t → 1 exponencialmente:
+//!      m_t = 1 − (1 − 0,3)·(1+κ)^{−(t−t*)} ⇒ lim lr_t = lr_prog(t);
+//! (iii) entre divergências consecutivas a distância ≥
+//!      log(0,7)/log(1+κ) passos é necessária para recuperação total.
+//! *Prova:* (i) por indução (cap em 1); (ii) resolução da recorrência
+//! linear m_{t+1} = m_t(1+κ) capada em 1; (iii) 0,3·(1+κ)^n ≥ 1. ∎
+//!
+//! ## v0.3.0 — integrações (código morto ligado, S-08/S-09 da auditoria B)
+//! - `calibrar_epsilon` agora é CHAMADO pela fase B com a taxa de erro por
+//!   nível medida (C.3(ii) — cobertura);
+//! - `lambda_ancora.passo` (hipergradiente exato, Teo 29.2) é chamado pela
+//!   fase B com L_diff medido;
+//! - passo com perda não finita é DESCARTADO ANTES de aplicar (M10 — a
+//!   v0.1.11 aplicava pesos NaN e gravava checkpoint com NaN).
 
 use crate::telemetria::TelemetryHub;
 
 pub struct Controlador {
     pub lr_base: f64,
     pub lr_corrente: f64,
+    /// M9: multiplicador com recuperação (substitui o ratchet)
+    pub multiplicador: f64,
+    pub taxa_recuperacao: f64,
     pub aquecimento: usize,
     pub passos_totais: usize,
     pub paciencia_plateau: usize,
@@ -33,6 +52,8 @@ impl Controlador {
         Controlador {
             lr_base,
             lr_corrente: lr_base,
+            multiplicador: 1.0,
+            taxa_recuperacao: 0.02, // recupera ~2%/passo (≥42 passos p/ voltar de 0,3 a 1)
             aquecimento,
             passos_totais,
             paciencia_plateau: paciencia,
@@ -47,44 +68,59 @@ impl Controlador {
         }
     }
 
-    /// LR do passo (aquecimento → cosseno com decaimentos por plateau).
+    /// LR do passo: agenda (aquecimento → cosseno) × multiplicador (M9).
     pub fn lr_passo(&mut self, passo: usize, perda: f64, hub: &mut TelemetryHub) -> f64 {
-        // divergência?
+        // divergência? — o passo é descartado ANTES pelo chamador (M10);
+        // aqui apenas reduz o multiplicador.
         if !perda.is_finite() || perda > 2.0 * self.minimo_ema {
-            let de = self.lr_corrente;
-            self.lr_corrente *= 0.3;
-            hub.ajuste("lr", de, self.lr_corrente,
-                &format!("divergência detectada (perda {perda:.3e} vs mínimo EMA {:.3e})", self.minimo_ema));
+            let de = self.multiplicador;
+            self.multiplicador *= 0.3;
+            hub.ajuste(
+                "lr_mult",
+                de,
+                self.multiplicador,
+                &format!("divergência (perda {perda:.3e} vs mínimo EMA {:.3e}) — passo descartado (M10)", self.minimo_ema),
+            );
             self.passos_sem_melhora = 0;
-            return self.lr_corrente;
+            self.minimo_ema = f64::INFINITY; // re-arma o detector
+            return self.lr_prog(passo) * self.multiplicador;
         }
-        // rastreio de mínimo (EMA implícito pela suavização do próprio valor)
+        // rastreio de mínimo
         if perda < self.minimo_ema * 0.999 {
             self.minimo_ema = self.minimo_ema.min(perda);
             self.passos_sem_melhora = 0;
         } else {
             self.passos_sem_melhora += 1;
         }
-        // plateau
+        // plateau: reduz o multiplicador (NÃO o teto permanente — M9)
         if self.paciencia_plateau > 0 && self.passos_sem_melhora >= self.paciencia_plateau {
-            let de = self.lr_corrente;
-            self.lr_corrente *= self.fator_plateau;
-            hub.ajuste("lr", de, self.lr_corrente,
-                &format!("plateau: {} passos sem melhora", self.passos_sem_melhora));
+            let de = self.multiplicador;
+            self.multiplicador *= self.fator_plateau;
+            hub.ajuste(
+                "lr_mult",
+                de,
+                self.multiplicador,
+                &format!("plateau: {} passos sem melhora (multiplicador — reversível)", self.passos_sem_melhora),
+            );
             self.passos_sem_melhora = 0;
         }
-        // programação base: aquecimento + cosseno
+        // M9: recuperação geométrica do multiplicador
+        if self.multiplicador < 1.0 {
+            self.multiplicador = (self.multiplicador * (1.0 + self.taxa_recuperacao)).min(1.0);
+        }
+        self.lr_corrente = self.lr_prog(passo) * self.multiplicador;
+        self.lr_corrente
+    }
+
+    fn lr_prog(&self, passo: usize) -> f64 {
         let p = passo as f64;
-        let lr_prog = if p < self.aquecimento as f64 {
+        if p < self.aquecimento as f64 {
             self.lr_base * (p + 1.0) / self.aquecimento.max(1) as f64
         } else {
             let t = (p - self.aquecimento as f64) / (self.passos_totais_clamped() - self.aquecimento).max(1) as f64;
             let cosseno = 0.5 * (1.0 + (std::f64::consts::PI * t.min(1.0)).cos());
             self.lr_base * (0.1 + 0.9 * cosseno)
-        };
-        // o menor entre a programação e o teto pós-plateau
-        self.lr_corrente = self.lr_corrente.min(lr_prog).max(self.lr_base * 0.01);
-        self.lr_corrente
+        }
     }
 
     fn passos_totais_clamped(&self) -> usize {
@@ -115,6 +151,7 @@ impl Controlador {
 
     /// ε da corrupção (C.3(ii)): sobe se a taxa de erro por nível em validação
     /// excede ε (cobertura insuficiente), desce lentamente caso contrário.
+    /// v0.3.0: INTEGRADA — chamada pela fase B com a taxa medida.
     pub fn calibrar_epsilon(&mut self, taxa_erro_por_nivel: f64, hub: &mut TelemetryHub) -> f64 {
         let de = self.epsilon_corrupcao;
         if taxa_erro_por_nivel > self.epsilon_corrupcao + 0.02 {
@@ -128,4 +165,45 @@ impl Controlador {
         }
         self.epsilon_corrupcao
     }
+
+    /// λ-âncora (Teo 29.2, hipergradiente EXATO): L(λ) = λ·L_diff + ρ(λ−λ₀)²
+    /// ⇒ ∂L/∂λ = L_diff + 2ρ(λ−λ₀); ótimo interior λ* = λ₀ − L_diff/(2ρ).
+    /// v0.3.0: INTEGRADA — chamada pela fase B a cada passo com L_diff medido.
+    pub fn passo_lambda(&mut self, l_diff: f64, hub: &mut TelemetryHub) -> f64 {
+        let de = self.lambda_ancora.lambda;
+        let novo = self.lambda_ancora.passo(l_diff, 0.05);
+        if (de - novo).abs() > 1e-9 {
+            hub.ajuste("lambda_jepa", de, novo,
+                &format!("hipergradiente exato 29.2: L_diff={l_diff:.4e}, λ*={:.4}", self.lambda_ancora.otimo_analitico(l_diff)));
+        }
+        novo
+    }
+}
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    /// Teo C-2: multiplicador nunca excede 1 e RECUPERA após divergência
+    /// (a v0.1.11 tinha ratchet monotônico — M9).
+    #[test]
+    fn multiplicador_recupera() {
+        let mut hub = TelemetryHub::novo(None);
+        let mut c = Controlador::novo(1e-3, 2, 1000, 5, 0.6, 0.05);
+        // divergência no passo 10
+        c.minimo_ema = 1.0;
+        c.lr_passo(10, 10.0, &mut hub);
+        assert!((c.multiplicador - 0.3).abs() < 1e-9, "divergência: mult 0,3");
+        // 100 passos com perda DECRESCENTE (sem plateau): multiplicador
+        // volta a 1 (recuperação — Teo C-2(ii))
+        for p in 11..111 {
+            let perda = 0.5 * 0.98f64.powi(p as i32);
+            c.lr_passo(p, perda, &mut hub);
+        }
+        assert!(c.multiplicador > 0.999, "recuperação completa (Teo C-2(ii)): {}", c.multiplicador);
+        assert!(c.multiplicador <= 1.0 + 1e-12, "nunca amplifica (Teo C-2(i))");
+        // LR final ≈ agenda (não fica preso no piso)
+        let esperado = c.lr_prog(110);
+        assert!((c.lr_corrente - esperado).abs() / esperado < 1e-9);
+    }
 }

src/diagnostico.rs

@@ -9,35 +9,35 @@
 
 use std::collections::BTreeMap;
 
-/// Chaves canônicas conhecidas do config (espeelho do config.rs).
+/// Chaves canônicas conhecidas do config — A26 (v0.3.0): derivadas do
+/// PRÓPRIO `ConfigKhtst` via serde (fonte única, runtime) em vez de uma lista
+/// escrita à mão (a v0.1.11 listava 7 chaves inexistentes: roteador,
+/// microunidades, atencao_moe, moe_enc_dec, autoajuste, mamba3, sonicmoe —
+/// sugestões de lint INVÁLIDAS).
 pub fn chaves_conhecidas() -> Vec<String> {
     let mut v = vec![];
     for secao in ["modelo", "ncm", "adba", "ponte", "treino", "telemetria", "dados", "memoria"] {
         v.push(secao.to_string());
-        let campos: &[&str] = match secao {
-            "modelo" => &["vocab", "d_modelo", "n_camadas", "n_cabecas", "d_ff",
-                          "comprimento_ctx", "janela_sliding", "kv_cache_max", "usar_atencao_arvore",
-                          "moe", "mtp", "roteador", "microunidades", "atencao_moe",
-                          "moe_enc_dec", "autoajuste", "mamba3", "sonicmoe"],
-            "ncm" => &["ativo", "niveis", "d_lat", "k_por_nivel", "ema_codebook", "beta_commit",
-                       "corrupcao_cond", "dropout_cfg", "cfg_scale", "pesos_nivel", "escala_r",
-                       "modo_quantizacao", "niveis_token",
-                       // subseções (dicts aninhados — 2º nível)
-                       "nested_dropout", "gsq", "lambdas", "temperaturas", "mbr"],
-            "adba" => &["ativo", "gamma_ancora", "reponderacao_nivel", "temperatura_nivel"],
-            "ponte" => &["ativo", "capacidade", "timeout_ms", "rodadas_demo"],
-            "treino" => &["lr", "aquecimento", "passos_fase_a", "passos_fase_b", "lote", "clip",
-                          "peso_decaimento", "telemetria_a_cada"],
-            "telemetria" => &["jsonl", "deteccao_aprendizado", "ajuste_automatico",
-                              "paciencia_plateau", "fator_lr_plateau"],
-            "dados" => &["shard_treino", "shard_validacao", "max_artigos", "max_bytes"],
-            "memoria" => &["som_lado", "lambda_jepa", "rm_dois_tempos"],
-            _ => &[],
-        };
-        for c in campos {
-            v.push(format!("{secao}.{c}"));
+    }
+    // serializa o default e extrai as folhas "secao.campo" / "secao.sub.campo"
+    if let Ok(valor) = serde_json::to_value(crate::config::ConfigKhtst::default()) {
+        if let Some(obj) = valor.as_object() {
+            for (secao, conteudo) in obj {
+                if let Some(sub) = conteudo.as_object() {
+                    for (campo, neto) in sub {
+                        v.push(format!("{secao}.{campo}"));
+                        if let Some(neto_obj) = neto.as_object() {
+                            for neto_campo in neto_obj.keys() {
+                                v.push(format!("{secao}.{campo}.{neto_campo}"));
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
+    v.sort();
+    v.dedup();
     v
 }
 

src/gerador.rs

@@ -4,22 +4,56 @@
 //! condicionamento = reconstrução cumulativa interpolada ẑ_{ℓ−1}^{(n_ℓ)} + e_ℓ
 //! (função determinística de c_{<ℓ} — Teo D.1). Corrupção κ (Teo C.3) e
 //! dropout CFG (Teo D.2(iii)). Cabeças MTP auxiliares (Teo D.6/T7).
+//!
+//! ## v0.3.0 — APRIMORAMENTOS
+//! 1. **Cabeça de mistura de planos** (`CabecaMistura` — tronco.rs):
+//!    p(c_ℓ|c_{<ℓ}) = Σ_m w_m Π_i q_{m,i} — raciocínio em M subníveis
+//!    PARALELOS por nível, combinados por mistura. Provas: Teo C-1 (tronco.rs).
+//! 2. **Verificador algébrico da hierarquia** (E.3 da proposta C):
+//!    L_alg = Σ_{ℓ≥2} ‖Interp_{n_{ℓ−1}}(ẑ_ℓ^{soft}) − ẑ_{ℓ−1}‖² —
+//!    consistência de refino: a reconstrução do nível ℓ, projetada de volta
+//!    à granularidade ℓ−1, deve PRESERVAR o conteúdo grosseiro.
+//!
+//!    **Teo G-1 (verificador algébrico).**
+//!    (i) L_alg é QUADRÁTICA nas esperanças de código: com q_i = distribuição
+//!    por posição e r_soft = Σ_k q_i(k)·R·c_k, L_alg(r) = ‖D·r − v‖² com
+//!    D = Interp_{n_{ℓ−1}←n_ℓ} (linear) e v = (I − D·U)ẑ_{ℓ−1} + (D·U − I)ẑ_{ℓ−1}
+//!    … i.e. v = ẑ_{ℓ−1} − D·U·ẑ_{ℓ−1} (o "desfoque" a compensar).
+//!    (ii) O minimizador relaxado (r livre) satisfaz as equações normais
+//!    DᵀDr* = Dᵀv — solução em forma fechada (mínimos quadrados), e o valor
+//!    mínimo ‖v‖² − ‖D r*‖²… é COTA INFERIOR para qualquer distribuição de
+//!    códigos (o span dos códigos é subespaço).
+//!    (iii) Com codebook Stiefel (linhas ortonormais, C Cᵀ = I_K), a projeção
+//!    de um alvo t ∈ R^d no span {R·c_k} é R·C·t/R·… computável em O(K·d):
+//!    P_span(t) = R·Cᵀ⟨…⟩ — barato e auditável.
+//!    (iv) Gradiente exato via autograd (todas as ops diferenciáveis) —
+//!    validado por diferenças finitas no gate G11.
+//!    *Prova (i):* Interp é matriz fixa W ∈ R^{n_{ℓ−1}×n_ℓ}; L_alg(r) =
+//!    ‖W·r − v‖₂² é quadrática com Hessiano 2WᵀW ⪰ 0 (convexa); (ii) segue
+//!    da otimalidade de Gauss-Markov; (iii) da ortonormalidade das linhas de
+//!    C (Teo 26.3). ∎
+//!    **Critério de falsificação**: a série `recomposicao_residuo` deve CAIR
+//!    ao longo do treino da fase A (a hierarquia fica algébricamente
+//!    consistente); se subir, o verificador acusa inconsistência.
 
 use candle_core::{Device, Result, Tensor, Var, D};
 use crate::camadas::{Linear, RmsNorm};
 use crate::config::ConfigKhtst;
 use crate::mascaras::{interp_para, mascara_block_causal};
 use crate::tokenizador::TokenizadorConceitos;
-use crate::tronco::{CabecaConceitos, EmbNiveis, Tronco};
+use crate::tronco::{CabecaConceitos, CabecaMistura, EmbNiveis, Tronco};
 use rand::prelude::*;
 
-pub const N_PREFIXO: usize = 8;
+pub use crate::tronco::N_PREFIXO;
 
 pub struct GeradorConceitos {
     pub tronco: Tronco,
     pub emb_niveis: EmbNiveis,
     pub proj_entrada: Linear, // d_lat → d_modelo
+    /// Cabeça produto da v0.1.11 — usada quando M = 1 (bit-a-bit idêntica).
     pub cabeca: CabecaConceitos,
+    /// Cabeças de MISTURA DE PLANOS por nível (v0.3.0) — usadas quando M ≥ 2.
+    pub cabecas_mistura: Vec<CabecaMistura>,
     pub cabecas_mtp: Vec<Linear>, // auxiliares — Teo D.6
     pub norm_entrada: RmsNorm,
     pub mascara: Tensor,
@@ -30,6 +64,8 @@ pub struct GeradorConceitos {
     pub k: usize,
     pub mtp_ativo: bool,
     pub beta_mtp: f64,
+    pub m_planos: usize,
+    pub lambda_alg: f64,
 }
 
 pub struct SaidaTreino {
@@ -38,12 +74,19 @@ pub struct SaidaTreino {
     pub ce_mtp: f64,
     pub acuracia_media: f64,
     pub uncond: bool,
+    /// verificador algébrico (medido nos códigos verdadeiros — telemetria)
+    pub residuo_algebrico: f64,
+    /// perda algébrica diferenciável (soft — para PCGrad separada)
+    pub perda_alg: Option<Tensor>,
+    /// entropia média dos pesos de plano (telemetria da mistura)
+    pub entropia_planos: f64,
 }
 
 impl GeradorConceitos {
     pub fn novo(cfg: &ConfigKhtst, dev: &Device) -> Result<Self> {
         let m = &cfg.modelo;
         let n = &cfg.ncm;
+        crate::rng::inicializar(cfg.treino.semente ^ 0xB);
         let tronco = Tronco::novo(cfg, dev)?;
         let mascara = mascara_block_causal(&n.niveis, N_PREFIXO, dev)?;
         let mut mtp = Vec::new();
@@ -52,11 +95,19 @@ impl GeradorConceitos {
                 mtp.push(Linear::sem_vies(m.d_modelo, n.k_por_nivel, 0.02, dev)?);
             }
         }
+        let m_planos = if cfg.ncm.ativo { n.mistura_planos.max(1) } else { 1 };
+        let mut cabecas_mistura = Vec::new();
+        if m_planos >= 2 {
+            for _ in 0..n.niveis.len() {
+                cabecas_mistura.push(CabecaMistura::nova(m.d_modelo, n.k_por_nivel, m_planos, dev)?);
+            }
+        }
         Ok(GeradorConceitos {
             tronco,
             emb_niveis: EmbNiveis::nova(cfg, dev)?,
             proj_entrada: Linear::sem_vies(n.d_lat, m.d_modelo, 0.02, dev)?,
             cabeca: CabecaConceitos::nova(cfg, dev)?,
+            cabecas_mistura,
             cabecas_mtp: mtp,
             norm_entrada: RmsNorm::novo(m.d_modelo, 1e-5, dev)?,
             mascara,
@@ -67,6 +118,8 @@ impl GeradorConceitos {
             k: n.k_por_nivel,
             mtp_ativo: m.mtp.ativo,
             beta_mtp: m.mtp.beta_entropia,
+            m_planos,
+            lambda_alg: if cfg.ncm.ativo { cfg.ncm.lambdas.algebrico } else { 0.0 },
         })
     }
 
@@ -88,7 +141,6 @@ impl GeradorConceitos {
         dev: &Device,
     ) -> Result<Tensor> {
         let n_l = self.niveis[nivel];
-        // dims()[0] = d_modelo (SAÍDA da projeção d_lat→d_modelo)
         let d = self.proj_entrada.w.as_tensor().dims()[0];
         let base = match zhat_anterior {
             Some(z) => {
@@ -122,9 +174,29 @@ impl GeradorConceitos {
         Ok(saida)
     }
 
+    /// Verificador algébrico (Teo G-1): resíduo de recomposição da
+    /// hierarquia nos códigos VERDADEIROS (telemetria/falsificação).
+    pub fn residuo_algebrico(zhats: &[Tensor], dev: &Device) -> Result<f64> {
+        if zhats.len() < 2 {
+            return Ok(0.0);
+        }
+        let mut soma = 0f64;
+        let mut cont = 0usize;
+        for l in 1..zhats.len() {
+            let n_ant = zhats[l - 1].dim(1)?;
+            let voltou = interp_para(&zhats[l], n_ant, dev)?;
+            let dif = (&voltou - &zhats[l - 1])?;
+            let m = dif.sqr()?.mean_all()?.to_scalar::<f32>()? as f64;
+            soma += m;
+            cont += 1;
+        }
+        Ok(if cont > 0 { soma / cont as f64 } else { 0.0 })
+    }
+
     /// Forward de TREINO com perda (1 passada — Teo D.1(iv)): teacher forcing
     /// com códigos VERDADEIROS no alvo; condicionamento corrompido por κ;
-    /// dropout CFG por exemplo (ramo não-condicionado = códigos aleatórios).
+    /// dropout CFG por exemplo. Cabeça: mistura de planos (M ≥ 2) ou produto
+    /// (M = 1, bit-a-bit v0.1.11). Inclui o verificador algébrico soft.
     pub fn perda_treino(
         &self,
         tok: &TokenizadorConceitos,
@@ -168,35 +240,76 @@ impl GeradorConceitos {
         let mut ces = Vec::with_capacity(self.niveis.len());
         let mut accs = Vec::new();
         let mut inicio = N_PREFIXO;
+        let usar_mistura = self.m_planos >= 2 && !self.cabecas_mistura.is_empty();
+        let mut entropia_planos = 0f64;
+        let mut n_entropia = 0usize;
+        // verificador algébrico SOFT (diferenciável) — acumulado por nível
+        let mut perda_alg: Option<Tensor> = None;
+        let mut ces_tensores: Vec<Tensor> = Vec::with_capacity(self.niveis.len());
         for (i, &n_l) in self.niveis.iter().enumerate() {
             let trecho = h.narrow(1, inicio, n_l)?;
-            let logits = self.cabeca.cabecas[i].fwd(&trecho)?;
-            let plano = logits.reshape((b * n_l, self.k))?;
             let alvo = codigos_verdadeiros[i].reshape(b * n_l)?.to_dtype(candle_core::DType::U32)?;
-            let ce = candle_nn::loss::cross_entropy(&plano, &alvo)?;
-            let preds = plano.argmax(D::Minus1)?;
-            let ac = preds.eq(&alvo)?.to_dtype(candle_core::DType::F32)?.sum_all()?.to_scalar::<f32>()? as f64
-                / (b * n_l) as f64;
-            accs.push(ac);
-            ces.push(ce);
+            let (ce_t, ce_v, acc) = if usar_mistura {
+                let cab = &self.cabecas_mistura[i];
+                let (nll, ce) = cab.nll(&trecho, &alvo)?;
+                // acurácia: marginal
+                let logits_m = cab.logits_marginais(&trecho)?;
+                let plano = logits_m.reshape((b * n_l, self.k))?;
+                let preds = plano.argmax(D::Minus1)?;
+                let ac = preds.eq(&alvo)?.to_dtype(candle_core::DType::F32)?.sum_all()?.to_scalar::<f32>()? as f64
+                    / (b * n_l) as f64;
+                // entropia dos pesos de plano (telemetria)
+                let w = cab.pesos_planos(&trecho)?;
+                let wl = ((&w + 1e-10f64)? * &(&w + 1e-10f64)?.log()?)?;
+                let hent = wl.affine(-1.0, 0.0)?.sum(D::Minus1)?.mean_all()?.to_scalar::<f32>()? as f64;
+                entropia_planos += hent;
+                n_entropia += 1;
+                // verificador algébrico soft (Teo G-1): r_soft do nível i
+                if self.lambda_alg > 0.0 && i >= 1 {
+                    // softmax COM backward (softmax_last_dim é no_bwd no candle 0.11)
+                    let probs = candle_nn::ops::softmax(&plano, D::Minus1)?;
+                    let probs3 = probs.reshape((b, n_l, self.k))?;
+                    let r_soft = tok.materializar_probs_nivel(i, &probs3)?;
+                    let zhat_soft = (&interp_para(&zhats[i - 1], n_l, dev)? + &r_soft)?;
+                    let n_ant = self.niveis[i - 1];
+                    let voltou = interp_para(&zhat_soft, n_ant, dev)?;
+                    let dif = (&voltou - &zhats[i - 1])?;
+                    let termo = dif.sqr()?.mean_all()?;
+                    perda_alg = Some(match perda_alg {
+                        Some(p) => (&p + &termo)?,
+                        None => termo,
+                    });
+                }
+                (nll, ce, ac)
+            } else {
+                let logits = self.cabeca.cabecas[i].fwd(&trecho)?;
+                let plano = logits.reshape((b * n_l, self.k))?;
+                let ce = candle_nn::loss::cross_entropy(&plano, &alvo)?;
+                let preds = plano.argmax(D::Minus1)?;
+                let ac = preds.eq(&alvo)?.to_dtype(candle_core::DType::F32)?.sum_all()?.to_scalar::<f32>()? as f64
+                    / (b * n_l) as f64;
+                (ce.clone(), ce.to_scalar::<f32>()? as f64, ac)
+            };
+            ces.push(ce_v);
+            accs.push(acc);
+            ces_tensores.push(ce_t);
             inicio += n_l;
         }
+        // somatório das CEs (média por nível)
         let l = ces.len() as f64;
-        let mut perda = ces[0].affine(1.0 / l, 0.0)?;
-        for ce in &ces[1..] {
-            perda = (&perda + &ce.affine(1.0 / l, 0.0)?)?;
+        let mut perda = ces_tensores[0].affine(1.0 / l, 0.0)?;
+        for t in &ces_tensores[1..] {
+            perda = (&perda + &t.affine(1.0 / l, 0.0)?)?;
         }
         // MTP auxiliar (Teo D.6): cabeça no nível ℓ prevê códigos do nível ℓ+1
         let mut ce_mtp = 0f64;
         if self.mtp_ativo && !self.cabecas_mtp.is_empty() {
-            let dev = self.mascara.device();
             let mut inicio = N_PREFIXO;
             let mut soma = None;
             for i in 0..self.cabecas_mtp.len() {
                 let n_l = self.niveis[i];
                 let n_prox = self.niveis[i + 1];
                 let trecho = h.narrow(1, inicio, n_l)?;
-                // reamostra para o tamanho do nível alvo (n_ℓ ≠ n_{ℓ+1})
                 let trecho_mtp = if n_l != n_prox {
                     interp_para(&trecho, n_prox, dev)?
                 } else {
@@ -216,12 +329,17 @@ impl GeradorConceitos {
                 perda = (&perda + &s.affine(self.beta_mtp / m, 0.0)?)?;
             }
         }
+        // resíduo algébrico nos códigos verdadeiros (telemetria)
+        let residuo = Self::residuo_algebrico(&zhats, dev)?;
         Ok(SaidaTreino {
             perda,
-            ce_por_nivel: ces.iter().map(|t| t.to_scalar::<f32>().unwrap() as f64).collect(),
+            ce_por_nivel: ces,
             ce_mtp,
             acuracia_media: accs.iter().sum::<f64>() / accs.len() as f64,
             uncond,
+            residuo_algebrico: residuo,
+            perda_alg,
+            entropia_planos: if n_entropia > 0 { entropia_planos / n_entropia as f64 } else { 0.0 },
         })
     }
 
@@ -230,25 +348,32 @@ impl GeradorConceitos {
         v.extend(self.emb_niveis.vars());
         v.extend(self.proj_entrada.vars());
         v.extend(self.cabeca.vars());
+        for cm in &self.cabecas_mistura {
+            v.extend(cm.vars());
+        }
         for m in &self.cabecas_mtp { v.extend(m.vars()); }
         v.extend(self.norm_entrada.vars());
         v
     }
 
     pub fn salvar(&self, caminho: &str) -> Result<()> {
+        let vars = self.vars();
         let mut obj = serde_json::Map::new();
-        for (i, v) in self.vars().iter().enumerate() {
+        obj.insert("__manifesto".into(), serde_json::json!({
+            "formato": "khtst-ckpt-v2",
+            "tipo": "gerador",
+            "n_vars": vars.len(),
+            "formas": vars.iter().map(|v| v.as_tensor().dims()).collect::<Vec<_>>(),
+        }));
+        for (i, v) in vars.iter().enumerate() {
             let dados = v.as_tensor().flatten_all()?.to_vec1::<f32>()?;
             obj.insert(format!("v{i}"), serde_json::json!({
-                "forma": v.as_tensor().shape().dims(),
+                "forma": v.as_tensor().dims(),
                 "dados": dados,
             }));
         }
         let txt = serde_json::to_string(&serde_json::Value::Object(obj))
             .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
-        let tmp = format!("{caminho}.tmp");
-        std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
-        std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?;
-        Ok(())
+        crate::tokenizador::salvar_atomico(caminho, &txt)
     }
 }

src/lib.rs

@@ -1,11 +1,17 @@
 //! KHTST_RUST — refatoração Rust/PyO3 do KHTST com NCM (Next-Concept
 //! Modeling), provas integradas (memoria-ncm-khtst n-02/n-03), atenção ADBA
-//! (r-04) e ponte duplex (r-05). Documentação: docs/memorias/.
+//! (r-04), ponte duplex (r-05), cabeça de mistura de planos + SSD-Δ +
+//! verificador algébrico (v0.3.0 — r-09). Documentação: docs/memorias/.
 //!
 //! Convenções do projeto (n-00 §4): nascimento neutro, leitura honesta,
 //! Teos numerados com ∎, token EXCLUSIVAMENTE em HF_TOKEN apagado após uso.
+//!
+//! v0.3.0 (M13): toda operação longa roda com `py.allow_threads` — o GIL é
+//! liberado durante treino/geração/ponte (a v0.1.11 retinha o GIL e um
+//! `send` bloqueante podia congelar o interpretador inteiro).
 
 use pyo3::prelude::*;
+use rand::prelude::*;
 
 pub mod amostrador;
 pub mod atencao;
@@ -20,6 +26,7 @@ pub mod perdas;
 pub mod ponte;
 pub mod quantizacao;
 pub mod quantizador;
+pub mod rng;
 pub mod ssd;
 pub mod stiefel;
 pub mod telemetria;
@@ -34,7 +41,7 @@ pub mod build_info {
 
 #[pyfunction]
 fn versao() -> &'static str {
-    "0.1.11 (KHTST_RUST — NCM + provas integradas + ADBA + ponte duplex)"
+    "0.3.0 (KHTST_RUST — NCM + provas + ADBA + ponte duplex + mistura de planos + SSD-Δ + verificador algébrico)"
 }
 
 #[pyfunction]
@@ -48,7 +55,8 @@ fn info_build() -> String {
     )
 }
 
-/// Lint de config com sugestões por Levenshtein (diagnóstico de digitação).
+/// Lint de config com sugestões por Levenshtein (diagnóstico de digitação —
+/// A27: chamado pelos scripts 40/41 no início de toda execução).
 #[pyfunction]
 fn lint_config(py: Python, caminho: &str) -> PyResult<PyObject> {
     let txt = std::fs::read_to_string(caminho)
@@ -81,7 +89,7 @@ impl BpePy {
     #[staticmethod]
     fn carregar(caminho: &str) -> PyResult<Self> {
         let txt = std::fs::read_to_string(caminho)
-            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{caminho}: {e}")))?;
         let v: serde_json::Value = serde_json::from_str(&txt)
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
         let bpe = tokens::Bpe::de_json(&v)
@@ -99,7 +107,7 @@ impl BpePy {
 
     fn salvar(&self, caminho: &str) -> PyResult<()> {
         std::fs::write(caminho, serde_json::to_string(&self.bpe.para_json()).unwrap())
-            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{caminho}: {e}")))?;
         Ok(())
     }
 
@@ -118,7 +126,6 @@ struct ConfigPy {
 #[pymethods]
 impl ConfigPy {
     #[new]
-    #[allow(never_type_fallback)]
     #[pyo3(signature = (caminho=None))]
     fn new(caminho: Option<String>) -> PyResult<Self> {
         let cfg = match &caminho {
@@ -136,6 +143,25 @@ impl ConfigPy {
         Ok(ConfigPy { cfg, caminho })
     }
 
+    /// v0.3.0 (A36): carrega config de um dict (sem arquivo).
+    #[staticmethod]
+    fn from_dict(d: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let py = d.py();
+        let json = pythonize::depythonize::<serde_json::Value>(d)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("dict inválido: {e}")))?;
+        let _ = py;
+        let cfg: config::ConfigKhtst = serde_json::from_value(json)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("config: {e}")))?;
+        cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err)?;
+        Ok(ConfigPy { cfg, caminho: None })
+    }
+
+    /// v0.3.0 (A36): exporta o config como dict.
+    fn as_dict(&self, py: Python) -> PyResult<PyObject> {
+        let v = serde_json::to_value(&self.cfg).unwrap();
+        Ok(pythonize::pythonize(py, &v)?.into())
+    }
+
     fn validar(&self) -> PyResult<()> {
         self.cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err)
     }
@@ -146,10 +172,12 @@ impl ConfigPy {
 
     fn resumo(&self) -> String {
         format!(
-            "modelo(vocab={}, d={}, camadas={}, ctx={}) ncm(L={}, niveis={:?}, K={}, d_lat={}, modo={}, ativo={})",
+            "modelo(vocab={}, d={}, camadas={}, ctx={}, ssd_delta={}) ncm(L={}, niveis={:?}, K={}, d_lat={}, modo={}, ativo={}, planos M={}, algebrico={})",
             self.cfg.modelo.vocab, self.cfg.modelo.d_modelo, self.cfg.modelo.n_camadas,
-            self.cfg.modelo.comprimento_ctx, self.cfg.l_niveis(), self.cfg.ncm.niveis,
+            self.cfg.modelo.comprimento_ctx, self.cfg.modelo.ssd_delta,
+            self.cfg.l_niveis(), self.cfg.ncm.niveis,
             self.cfg.ncm.k_por_nivel, self.cfg.ncm.d_lat, self.cfg.ncm.modo_quantizacao, self.cfg.ncm.ativo,
+            self.cfg.ncm.mistura_planos, self.cfg.ncm.lambdas.algebrico,
         )
     }
 
@@ -172,21 +200,22 @@ impl PonteDuplaPy {
         PonteDuplaPy { ponte: ponte::PonteDupla::nova(capacidade, timeout_ms) }
     }
 
-    fn rodada(&self, carga_a: Vec<f32>, carga_b: Vec<f32>, nivel: usize) -> PyResult<(Vec<f32>, Vec<f32>)> {
-        let (ma, mb) = self.ponte.rodada(carga_a, carga_b, nivel)
+    /// M13: roda SEM o GIL (allow_threads) e com prazo nos envios.
+    fn rodada(&self, py: Python, carga_a: Vec<f32>, carga_b: Vec<f32>, nivel: usize) -> PyResult<(Vec<f32>, Vec<f32>)> {
+        let (ma, mb) = py.allow_threads(|| self.ponte.rodada(carga_a, carga_b, nivel))
             .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
         Ok((ma.carga, mb.carga))
     }
 
-    fn demo_professor_aluno(&self, rodadas: usize, dim: usize) -> PyResult<PyObject> {
+    fn demo_professor_aluno(&self, py: Python, rodadas: usize, dim: usize) -> PyResult<PyObject> {
         let inicio: Vec<f32> = (0..dim).map(|i| (i as f32) * 0.01).collect();
-        let stats = ponte::demo_professor_aluno(&self.ponte, rodadas, inicio, &|a, _| {
-            a.iter().map(|x| x * 1.05).collect()
+        let stats = py.allow_threads(|| {
+            ponte::demo_professor_aluno(&self.ponte, rodadas, inicio, &|a, _| {
+                a.iter().map(|x| x * 1.05).collect()
+            })
         })
         .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
-        Python::with_gil(|py| {
-            Ok(pythonize::pythonize(py, &serde_json::to_value(&stats).unwrap())?.into())
-        })
+        Ok(pythonize::pythonize(py, &serde_json::to_value(&stats).unwrap())?.into())
     }
 
     fn estatisticas(&self) -> PyResult<PyObject> {
@@ -213,6 +242,7 @@ impl PonteAsyncPy {
     }
 
     /// Corrotina: `await ponte.trocar(a, b, nivel)` — duplex simultânea.
+    /// M13: o corpo bloqueante roda com prazo (send_timeout dentro de rodada).
     fn trocar<'p>(&self, py: Python<'p>, carga_a: Vec<f32>, carga_b: Vec<f32>, nivel: usize) -> PyResult<Bound<'p, PyAny>> {
         let p = self.interna.clone();
         pyo3_async_runtimes::tokio::future_into_py(py, async move {
@@ -225,24 +255,30 @@ impl PonteAsyncPy {
 }
 
 /// Treina a fase A (tokenizador). Devolve dict com resumo + telemetria.
+/// v0.3.0: `retomar` (carrega `.estado.json` ao lado do checkpoint —
+/// proteção contra encerramento em background); GIL liberado (M13).
 #[pyfunction]
-#[pyo3(signature = (cfg, sequencias, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None))]
+#[pyo3(signature = (cfg, sequencias, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None, retomar=false))]
 fn treinar_fase_a(
+    py: Python,
     cfg: &ConfigPy,
     sequencias: Vec<Vec<u32>>,
     caminho_telemetria: Option<String>,
     caminho_checkpoint: Option<String>,
     callback: Option<Bound<'_, PyAny>>,
     teto_seg: Option<f64>,
+    retomar: bool,
 ) -> PyResult<PyObject> {
     let cb: treino::CallbackPy = callback.map(|c| c.unbind());
-    let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria);
-    let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx);
-    let mut resumo = treino::treinar_fase_a(&cfg.cfg, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase A: {e}")))?;
-    let _ = &mut resumo;
-    Python::with_gil(|py| {
-        let dados = serde_json::json!({
+    let cfg_rust = cfg.cfg.clone();
+    let truncar = cfg_rust.telemetria.truncar_jsonl;
+    let saida = py.allow_threads(move || -> PyResult<serde_json::Value> {
+        crate::rng::inicializar(cfg_rust.treino.semente);
+        let mut hub = telemetria::TelemetryHub::novo_completo(caminho_telemetria, truncar);
+        let dados = treino::DadosTreino::novo(sequencias, cfg_rust.modelo.comprimento_ctx);
+        let resumo = treino::treinar_fase_a(&cfg_rust, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg, retomar)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase A: {e}")))?;
+        Ok(serde_json::json!({
             "resumo": {
                 "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
                 "perda_final": resumo.perda_final, "acc_recon": resumo.acc_recon,
@@ -250,17 +286,20 @@ fn treinar_fase_a(
                 "perplexidade_codebook": resumo.perplexidade_codebook,
                 "monotonia_prefixo": resumo.monotonia_prefixo,
                 "escore_aprendizado": resumo.escore_aprendizado,
+                "residuo_algebrico": resumo.residuo_algebrico,
+                "estado_aprendizado": resumo.estado_aprendizado,
             },
             "telemetria": hub.dump(),
-        });
-        Ok(pythonize::pythonize(py, &dados)?.into())
-    })
+        }))
+    })?;
+    Ok(pythonize::pythonize(py, &saida)?.into())
 }
 
 /// Treina a fase B (gerador) com tokenizador congelado carregado de checkpoint.
 #[pyfunction]
-#[pyo3(signature = (cfg, sequencias, caminho_tokenizador, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None))]
+#[pyo3(signature = (cfg, sequencias, caminho_tokenizador, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None, retomar=false))]
 fn treinar_fase_b(
+    py: Python,
     cfg: &ConfigPy,
     sequencias: Vec<Vec<u32>>,
     caminho_tokenizador: &str,
@@ -268,125 +307,128 @@ fn treinar_fase_b(
     caminho_checkpoint: Option<String>,
     callback: Option<Bound<'_, PyAny>>,
     teto_seg: Option<f64>,
+    retomar: bool,
 ) -> PyResult<PyObject> {
     let cb: treino::CallbackPy = callback.map(|c| c.unbind());
-    let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria);
-    let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx);
-    // carrega o tokenizador congelado
-    let dev = candle_core::Device::Cpu;
-    let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
-    carregar_tokenizador(&mut tok, caminho_tokenizador)
-        .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
-    let resumo = treino::treinar_fase_b(&cfg.cfg, &tok, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase B: {e}")))?;
-    Python::with_gil(|py| {
-        let dados = serde_json::json!({
+    let cfg_rust = cfg.cfg.clone();
+    let caminho_tok = caminho_tokenizador.to_string();
+    let truncar = cfg_rust.telemetria.truncar_jsonl;
+    let saida = py.allow_threads(move || -> PyResult<serde_json::Value> {
+        crate::rng::inicializar(cfg_rust.treino.semente);
+        let mut hub = telemetria::TelemetryHub::novo_completo(caminho_telemetria, truncar);
+        let dados = treino::DadosTreino::novo(sequencias, cfg_rust.modelo.comprimento_ctx);
+        let dev = candle_core::Device::Cpu;
+        let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
+        {
+            let mut vars = tok.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho_tok)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        let resumo = treino::treinar_fase_b(&cfg_rust, &tok, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg, retomar)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase B: {e}")))?;
+        Ok(serde_json::json!({
             "resumo": {
                 "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
                 "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
                 "escore_aprendizado": resumo.escore_aprendizado,
+                "residuo_algebrico": resumo.residuo_algebrico,
+                "estado_aprendizado": resumo.estado_aprendizado,
             },
             "telemetria": hub.dump(),
-        });
-        Ok(pythonize::pythonize(py, &dados)?.into())
-    })
-}
-
-fn carregar_tokenizador(tok: &mut tokenizador::TokenizadorConceitos, caminho: &str) -> Result<(), String> {
-    let txt = std::fs::read_to_string(caminho).map_err(|e| format!("{e}"))?;
-    let v: serde_json::Value = serde_json::from_str(&txt).map_err(|e| format!("{e}"))?;
-    let obj = v.as_object().ok_or("formato de checkpoint inválido")?;
-    let vars = tok.vars();
-    for (i, var) in vars.iter().enumerate() {
-        if let Some(entrada) = obj.get(&format!("v{i}")) {
-            let forma: Vec<usize> = entrada["forma"].as_array().map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect()).unwrap_or_default();
-            let dados: Vec<f32> = entrada["dados"].as_array().map(|a| a.iter().filter_map(|x| x.as_f64().map(|y| y as f32)).collect()).unwrap_or_default();
-            if forma.is_empty() || dados.is_empty() {
-                continue;
-            }
-            let dev = candle_core::Device::Cpu;
-            let t2 = candle_core::Tensor::from_vec(dados, forma.clone(), &dev)
-                .and_then(|t| t.reshape(forma))
-                .map_err(|e| format!("{e}"))?;
-            var.set(&t2).map_err(|e| format!("{e}"))?;
-        }
-    }
-    Ok(())
+        }))
+    })?;
+    Ok(pythonize::pythonize(py, &saida)?.into())
 }
 
-/// Gera amostras com NFE = L e devolve textos decodificados (modo conceitos).
+/// Gera amostras com NFE = L. v0.3.0: `semente` e `max_tokens` opcionais
+/// (A40 — a v0.1.11 tinha 4242/48 fixos), `n_cand` ativa MBR (P-14).
 #[pyfunction]
-#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_amostras=2, parar_no_nivel=None, greedy=true))]
+#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_amostras=2, parar_no_nivel=None, greedy=true, semente=None, max_tokens=None, n_cand=None))]
 fn gerar_amostras(
+    py: Python,
     cfg: &ConfigPy,
     caminho_tokenizador: &str,
     caminho_gerador: &str,
     n_amostras: usize,
     parar_no_nivel: Option<usize>,
     greedy: bool,
+    semente: Option<u64>,
+    max_tokens: Option<usize>,
+    n_cand: Option<usize>,
 ) -> PyResult<PyObject> {
-    let dev = candle_core::Device::Cpu;
-    let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
-    carregar_tokenizador(&mut tok, caminho_tokenizador)
-        .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
-    let mut ger = gerador::GeradorConceitos::novo(&cfg.cfg, &dev)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
-    carregar_gerador(&mut ger, caminho_gerador)
-        .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
-    let mut amostrador = amostrador::AmostradorConceitos::novo(
-        &mut ger, &tok, cfg.cfg.ncm.cfg_scale, cfg.cfg.ncm.temperaturas.limites, cfg.cfg.ncm.temperaturas.entropia_alvo,
-    );
-    let mut rng = <rand::prelude::StdRng as rand::SeedableRng>::seed_from_u64(4242);
-    let inicio = std::time::Instant::now();
-    let (codigos, nfe) = amostrador.gerar(n_amostras.max(1), &dev, &mut rng, parar_no_nivel, greedy)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("amostragem: {e}")))?;
-    let tempo_ms = inicio.elapsed().as_secs_f64() * 1000.0;
-    // decodifica: ẑ final → decoder AR greedy → tokens
-    let nivel_final = codigos.len();
-    let zhats = tok.reconstruir_de_codigos(&codigos, nivel_final, n_amostras.max(1), &dev)
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
-    let textos_ids = decodificar_textos(&tok, zhats.last(), n_amostras.max(1))
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
-    Python::with_gil(|py| {
-        let d = serde_json::json!({
-            "nfe": nfe, "l": cfg.cfg.l_niveis(), "tempo_ms": tempo_ms,
+    let cfg_rust = cfg.cfg.clone();
+    let caminho_tok = caminho_tokenizador.to_string();
+    let caminho_ger = caminho_gerador.to_string();
+    let d = py.allow_threads(move || -> PyResult<serde_json::Value> {
+        crate::rng::inicializar(cfg_rust.treino.semente ^ 0xABC);
+        let dev = candle_core::Device::Cpu;
+        let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
+        {
+            let mut vars = tok.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho_tok)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        let mut ger = gerador::GeradorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
+        {
+            let mut vars = ger.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho_ger)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        let n_cand_efetivo = n_cand.unwrap_or(cfg_rust.ncm.mbr.n_cand).max(1);
+        let mut amostrador = amostrador::AmostradorConceitos::novo(
+            &mut ger, &tok, cfg_rust.ncm.cfg_scale, cfg_rust.ncm.temperaturas.limites,
+            cfg_rust.ncm.temperaturas.entropia_alvo, cfg_rust.ncm.temperaturas.auto,
+        );
+        let semente = semente.unwrap_or(4242);
+        let mut rng = <rand::prelude::StdRng as rand::SeedableRng>::seed_from_u64(semente);
+        let inicio = std::time::Instant::now();
+        let (codigos, nfe) = if n_cand_efetivo > 1 {
+            // MBR (Teo C.4): gera n_cand candidatos e escolhe por utilidade
+            let mut candidatos = Vec::new();
+            for _ in 0..n_cand_efetivo {
+                let mut am = amostrador::AmostradorConceitos::novo(
+                    &mut ger, &tok, cfg_rust.ncm.cfg_scale, cfg_rust.ncm.temperaturas.limites,
+                    cfg_rust.ncm.temperaturas.entropia_alvo, cfg_rust.ncm.temperaturas.auto,
+                );
+                let (c, n) = am.gerar(n_amostras.max(1), &dev, &mut rng, parar_no_nivel, greedy)
+                    .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("amostragem: {e}")))?;
+                candidatos.push(c);
+                amostrador.nfe_contador += n;
+            }
+            let melhor = amostrador::mbr_escolher(&candidatos);
+            (candidatos[melhor].clone(), amostrador.nfe_contador)
+        } else {
+            amostrador.gerar(n_amostras.max(1), &dev, &mut rng, parar_no_nivel, greedy)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("amostragem: {e}")))?
+        };
+        let tempo_ms = inicio.elapsed().as_secs_f64() * 1000.0;
+        let nivel_final = codigos.len();
+        let zhats = tok.reconstruir_de_codigos(&codigos, nivel_final, n_amostras.max(1), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("reconstrução: {e}")))?;
+        let textos_ids = decodificar_textos(&tok, zhats.last(), n_amostras.max(1), max_tokens.unwrap_or(48))
+            .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
+        Ok(serde_json::json!({
+            "nfe": nfe, "l": cfg_rust.l_niveis(), "tempo_ms": tempo_ms,
             "niveis_usados": nivel_final, "ids_tokens": textos_ids,
             "temperaturas": amostrador.temperaturas,
-        });
-        Ok(pythonize::pythonize(py, &d)?.into())
-    })
+            "residuo_algebrico": amostrador.residuo_algebrico_ultimo,
+            "n_cand_mbr": n_cand_efetivo,
+        }))
+    })?;
+    Ok(pythonize::pythonize(py, &d)?.into())
 }
 
-fn decodificar_textos(tok: &tokenizador::TokenizadorConceitos, zhat: Option<&candle_core::Tensor>, b: usize) -> Result<Vec<Vec<u32>>, String> {
+fn decodificar_textos(tok: &tokenizador::TokenizadorConceitos, zhat: Option<&candle_core::Tensor>, b: usize, max_tokens: usize) -> Result<Vec<Vec<u32>>, String> {
     let Some(z) = zhat else { return Ok(vec![vec![]; b]) };
-    tok.decodificar_livre(z, 48).map_err(|e| format!("{e}"))
+    tok.decodificar_livre(z, max_tokens).map_err(|e| format!("{e}"))
 }
 
-fn carregar_gerador(ger: &mut gerador::GeradorConceitos, caminho: &str) -> Result<(), String> {
-    let txt = std::fs::read_to_string(caminho).map_err(|e| format!("{e}"))?;
-    let v: serde_json::Value = serde_json::from_str(&txt).map_err(|e| format!("{e}"))?;
-    let obj = v.as_object().ok_or("formato inválido")?;
-    let vars = ger.vars();
-    for (i, var) in vars.iter().enumerate() {
-        if let Some(entrada) = obj.get(&format!("v{i}")) {
-            let forma: Vec<usize> = entrada["forma"].as_array().map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect()).unwrap_or_default();
-            let dados: Vec<f32> = entrada["dados"].as_array().map(|a| a.iter().filter_map(|x| x.as_f64().map(|y| y as f32)).collect()).unwrap_or_default();
-            if forma.is_empty() || dados.is_empty() {
-                continue;
-            }
-            let dev = candle_core::Device::Cpu;
-            let t = candle_core::Tensor::from_vec(dados, forma.clone(), &dev)
-                .and_then(|t| t.reshape(forma))
-                .map_err(|e| format!("{e}"))?;
-            var.set(&t).map_err(|e| format!("{e}"))?;
-        }
-    }
-    Ok(())
-}
+// ---------------- verificação (V-série) ----------------
 
-/// Utilitários de prova expostos ao Python (V-série da suíte).
+/// V4-estrutura: contagem de vazamentos na MATRIZ da máscara.
 #[pyfunction]
 fn verificar_mascara(cfg: &ConfigPy) -> PyResult<usize> {
     let dev = candle_core::Device::Cpu;
@@ -396,6 +438,196 @@ fn verificar_mascara(cfg: &ConfigPy) -> PyResult<usize> {
         .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
 }
 
+/// Gate G1 (v0.2.0): VAZAMENTO EFETIVO — perturba os níveis > 1 e mede a
+/// resposta do nível 1 (‖Δ‖∞). A v0.1.11 media a MATRIZ (V4) e reportava 0
+/// enquanto o vazamento real era de 110% do sinal.
+#[pyfunction]
+fn verificar_vazamento_efetivo(py: Python, cfg: &ConfigPy) -> PyResult<f64> {
+    let cfg_rust = cfg.cfg.clone();
+    py.allow_threads(move || {
+        teste_vazamento_efetivo(&cfg_rust)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+    })
+}
+
+pub fn teste_vazamento_efetivo(cfg: &config::ConfigKhtst) -> candle_core::Result<f64> {
+    let dev = candle_core::Device::Cpu;
+    crate::rng::inicializar(cfg.treino.semente ^ 0xEFE);
+    let ger = gerador::GeradorConceitos::novo(cfg, &dev)?;
+    let l = ger.niveis.len();
+    let b = 1usize;
+    // monta a sequência com códigos aleatórios (determinísticos)
+    let mut rng = <rand::prelude::StdRng as rand::SeedableRng>::seed_from_u64(cfg.treino.semente ^ 0xEFE);
+    let codigos: Vec<candle_core::Tensor> = (0..l)
+        .map(|i| {
+            let n_l = ger.niveis[i];
+            let v: Vec<u32> = (0..b * n_l).map(|_| rng.gen_range(0..ger.k as u32)).collect();
+            candle_core::Tensor::from_vec(v, (b, n_l), &dev)
+        })
+        .collect::<candle_core::Result<Vec<_>>>()?;
+    let zhats = {
+        let tok_vazio = tokenizador::TokenizadorConceitos::novo(cfg, &dev)?;
+        tok_vazio.reconstruir_de_codigos(&codigos, l, b, &dev)?
+    };
+    let montar = |zhats: &[candle_core::Tensor]| -> candle_core::Result<candle_core::Tensor> {
+        let mut blocos = Vec::new();
+        for nivel in 0..l {
+            let zhat_ant = if nivel == 0 { None } else { Some(&zhats[nivel - 1]) };
+            blocos.push(ger.entrada_nivel_pub(zhat_ant, nivel, b, &dev)?);
+        }
+        let prefixo_ids = candle_core::Tensor::zeros((b, gerador::N_PREFIXO), candle_core::DType::U32, &dev)?;
+        let prefixo = ger.emb_niveis.tabela.fwd(&prefixo_ids)?;
+        let mut seqs = vec![prefixo];
+        seqs.extend(blocos);
+        candle_core::Tensor::cat(&seqs, 1)
+    };
+    let s1 = montar(&zhats)?;
+    let mut niveis_pos = vec![0usize; gerador::N_PREFIXO];
+    for (i, &n_l) in ger.niveis.iter().enumerate() {
+        niveis_pos.extend(std::iter::repeat(i + 1).take(n_l));
+    }
+    let fwd = |s: &candle_core::Tensor| -> candle_core::Result<candle_core::Tensor> {
+        let mut resumos = Vec::new();
+        ger.tronco.forward_treino(s, &ger.mascara, &niveis_pos, &mut resumos)
+    };
+    let h1 = fwd(&s1)?;
+    // corrompe TODOS os níveis > 1 (×999) e mede a resposta do NÍVEL 1
+    // (flatten linha-major de (b, T, d): posição i corresponde a [i*d, (i+1)*d))
+    let n1 = ger.niveis[0];
+    let inicio_n2 = gerador::N_PREFIXO + n1;
+    let d = s1.dim(2)?;
+    let mut s2v = s1.flatten_all()?.to_vec1::<f32>()?;
+    for i in 0..s1.dim(1)? {
+        if i >= inicio_n2 {
+            for j in 0..d {
+                s2v[i * d + j] *= 999.0;
+            }
+        }
+    }
+    let s2 = candle_core::Tensor::from_vec(s2v, s1.shape(), &dev)?;
+    let h2 = fwd(&s2)?;
+    let dif = (&h1.narrow(1, gerador::N_PREFIXO, n1)? - &h2.narrow(1, gerador::N_PREFIXO, n1)?)?;
+    Ok(dif.abs()?.max_all()?.to_scalar::<f32>()? as f64)
+}
+
+/// Gate G2 (v0.2.0): paridade treino↔inferência — max|Δ| entre o forward
+/// completo e o incremental (nível a nível, com caches/estado).
+#[pyfunction]
+fn verificar_paridade(py: Python, cfg: &ConfigPy) -> PyResult<PyObject> {
+    let cfg_rust = cfg.cfg.clone();
+    let r = py.allow_threads(move || {
+        teste_paridade(&cfg_rust)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+    })?;
+    Python::with_gil(|py| Ok(pythonize::pythonize(py, &r)?.into()))
+}
+
+pub fn teste_paridade(cfg: &config::ConfigKhtst) -> candle_core::Result<serde_json::Value> {
+    use candle_core::Tensor;
+    let dev = candle_core::Device::Cpu;
+    crate::rng::inicializar(cfg.treino.semente ^ 0xEA2);
+    let mut ger = gerador::GeradorConceitos::novo(cfg, &dev)?;
+    let l = ger.niveis.len();
+    let b = 1usize;
+    let mut rng = <rand::prelude::StdRng as rand::SeedableRng>::seed_from_u64(cfg.treino.semente ^ 0xEA2);
+    let codigos: Vec<Tensor> = (0..l)
+        .map(|i| {
+            let n_l = ger.niveis[i];
+            let v: Vec<u32> = (0..b * n_l).map(|_| rng.gen_range(0..ger.k as u32)).collect();
+            Tensor::from_vec(v, (b, n_l), &dev)
+        })
+        .collect::<candle_core::Result<Vec<_>>>()?;
+    let zhats = {
+        let tok = tokenizador::TokenizadorConceitos::novo(cfg, &dev)?;
+        tok.reconstruir_de_codigos(&codigos, l, b, &dev)?
+    };
+    let mut blocos = Vec::new();
+    for nivel in 0..l {
+        let zhat_ant = if nivel == 0 { None } else { Some(&zhats[nivel - 1]) };
+        blocos.push(ger.entrada_nivel_pub(zhat_ant, nivel, b, &dev)?);
+    }
+    let prefixo_ids = Tensor::zeros((b, gerador::N_PREFIXO), candle_core::DType::U32, &dev)?;
+    let prefixo = ger.emb_niveis.tabela.fwd(&prefixo_ids)?;
+    let mut seqs = vec![prefixo];
+    seqs.extend(blocos.iter().cloned());
+    let s = Tensor::cat(&seqs, 1)?;
+    let mut niveis_pos = vec![0usize; gerador::N_PREFIXO];
+    for (i, &n_l) in ger.niveis.iter().enumerate() {
+        niveis_pos.extend(std::iter::repeat(i + 1).take(n_l));
+    }
+    let mut resumos = Vec::new();
+    let h_full = ger.tronco.forward_treino(&s, &ger.mascara, &niveis_pos, &mut resumos)?;
+    // incremental
+    let mut estado = tronco::EstadoNivel::novo();
+    let mut difs = Vec::new();
+    let mut inicio = gerador::N_PREFIXO;
+    for nivel in 0..l {
+        let n_l = ger.niveis[nivel];
+        let entrada = if nivel == 0 {
+            let pe = ger.emb_niveis.tabela.fwd(&prefixo_ids)?;
+            Tensor::cat(&[pe, blocos[nivel].clone()], 1)?
+        } else {
+            blocos[nivel].clone()
+        };
+        let n_novo = entrada.dim(1)?;
+        let n_cache = estado.caches.first().and_then(|c| c.k.as_ref()).map(|k| k.dims()[2]).unwrap_or(0);
+        let total_vis = n_cache + n_novo;
+        // v0.2.0: na PRIMEIRA janela (prefixo + nível 1, sem cache) a máscara
+        // é o canto superior-esquerdo da block-causal: prefixo causal dentro
+        // do prefixo; nível 1 vê TUDO (bidirecional intra-nível, como no
+        // treino — Teo D.1(ii)). Nas demais: tudo visível (o bloco novo é o
+        // mais recente).
+        let mascara = if n_cache == 0 {
+            let total = n_novo;
+            let mut m = vec![f32::MIN; total * total];
+            // prefixo causal
+            for i in 0..gerador::N_PREFIXO.min(total) {
+                for j in 0..=i {
+                    m[i * total + j] = 0.0;
+                }
+            }
+            // posições do nível 1: veem o bloco inteiro (bidirecional)
+            for i in gerador::N_PREFIXO.min(total)..total {
+                for j in 0..total {
+                    m[i * total + j] = 0.0;
+                }
+            }
+            Tensor::from_vec(m, (total, total), &dev)?
+        } else {
+            let m = vec![0f32; n_novo * total_vis];
+            Tensor::from_vec(m, (n_novo, total_vis), &dev)?
+        };
+        // níveis dos queries: no 1º call inclui o prefixo (nível 0)
+        let niveis_novos = if n_cache == 0 {
+            let mut v = vec![0usize; gerador::N_PREFIXO.min(n_novo)];
+            v.extend(std::iter::repeat(nivel + 1).take(n_novo - gerador::N_PREFIXO.min(n_novo)));
+            v
+        } else {
+            vec![nivel + 1; n_novo]
+        };
+        let mut niveis_totais = vec![0usize; gerador::N_PREFIXO.min(n_cache)];
+        let restante = n_cache.saturating_sub(gerador::N_PREFIXO);
+        let mut usados = 0usize;
+        for (li, &nl) in ger.niveis.iter().enumerate().take(nivel) {
+            if usados >= restante { break; }
+            let tomar = nl.min(restante - usados);
+            niveis_totais.extend(std::iter::repeat(li + 1).take(tomar));
+            usados += tomar;
+        }
+        niveis_totais.extend(niveis_novos.clone());
+        let h_inc = ger.tronco.forward_nivel(&entrada, &mut estado, &mascara, nivel + 1, &niveis_novos, &niveis_totais)?;
+        let ref_nivel = h_full.narrow(1, inicio, n_l)?;
+        let dif = (&ref_nivel - &h_inc.narrow(1, if nivel == 0 { gerador::N_PREFIXO } else { 0 }, n_l)?)?;
+        difs.push(dif.abs()?.max_all()?.to_scalar::<f32>()? as f64);
+        inicio += n_l;
+    }
+    Ok(serde_json::json!({
+        "difs_por_nivel": difs,
+        "dif_max": difs.iter().cloned().fold(0f64, f64::max),
+    }))
+}
+
+/// V9: δ_ort de um codebook RECENTEMENTE INICIALIZADO (k, d).
 #[pyfunction]
 fn verificar_stiefel(k: usize, d: usize) -> PyResult<f64> {
     let dev = candle_core::Device::Cpu;
@@ -404,6 +636,140 @@ fn verificar_stiefel(k: usize, d: usize) -> PyResult<f64> {
     stiefel::erro_ortogonalidade(&c.transpose(0, 1).unwrap()).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
 }
 
+/// v0.3.0 (A36): δ_ort do codebook TREINADO num checkpoint de tokenizador.
+#[pyfunction]
+fn verificar_delta_ort(py: Python, cfg: &ConfigPy, caminho: &str) -> PyResult<PyObject> {
+    let cfg_rust = cfg.cfg.clone();
+    let caminho = caminho.to_string();
+    let r = py.allow_threads(move || -> PyResult<serde_json::Value> {
+        crate::rng::inicializar(cfg_rust.treino.semente ^ 0x0D0);
+        let dev = candle_core::Device::Cpu;
+        let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        {
+            let mut vars = tok.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        let deltas: PyResult<Vec<f64>> = tok
+            .quants
+            .iter()
+            .map(|q| q.delta_ort().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))))
+            .collect();
+        let deltas = deltas?;
+        Ok(serde_json::json!({
+            "delta_ort_por_nivel": deltas,
+            "delta_ort_max": deltas.iter().cloned().fold(0f64, f64::max),
+        }))
+    })?;
+    Python::with_gil(|py| Ok(pythonize::pythonize(py, &r)?.into()))
+}
+
+/// v0.3.0 (A20): inspeção de checkpoint — valida manifesto (contagem/formas).
+#[pyfunction]
+fn verificar_checkpoint(caminho: &str) -> PyResult<PyObject> {
+    let txt = std::fs::read_to_string(caminho)
+        .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{caminho}: {e}")))?;
+    let v: serde_json::Value = serde_json::from_str(&txt)
+        .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
+    let obj = v.as_object().ok_or_else(|| pyo3::exceptions::PyValueError::new_err("formato inválido"))?;
+    let man = obj.get("__manifesto").ok_or_else(|| {
+        pyo3::exceptions::PyValueError::new_err("checkpoint SEM manifesto (formato pré-v0.2.0?)")
+    })?;
+    let n_vars = man["n_vars"].as_u64().unwrap_or(0) as usize;
+    let presentes = obj.keys().filter(|k| k.starts_with('v') && !k.starts_with("__")).count();
+    let ok = n_vars == presentes;
+    Python::with_gil(|py| {
+        Ok(pythonize::pythonize(py, &serde_json::json!({
+            "caminho": caminho,
+            "formato": man["formato"], "tipo": man["tipo"],
+            "n_vars_declarado": n_vars, "n_vars_presentes": presentes,
+            "consistente": ok,
+        }))?.into())
+    })
+}
+
+/// v0.3.0 (V16 — prova aritmética): avaliação SEM treino — carrega
+/// tokenizador+gerador e devolve a CE (por nível e média) sobre as
+/// sequências dadas. Usado pela prova de percepção de inteiros/floats:
+/// CE(progressão aritmética) < CE(controle embaralhado).
+#[pyfunction]
+#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, sequencias))]
+fn avaliar_ce(
+    py: Python,
+    cfg: &ConfigPy,
+    caminho_tokenizador: &str,
+    caminho_gerador: &str,
+    sequencias: Vec<Vec<u32>>,
+) -> PyResult<PyObject> {
+    let cfg_rust = cfg.cfg.clone();
+    let caminho_tok = caminho_tokenizador.to_string();
+    let caminho_ger = caminho_gerador.to_string();
+    let d = py.allow_threads(move || -> PyResult<serde_json::Value> {
+        crate::rng::inicializar(cfg_rust.treino.semente ^ 0xABC);
+        let dev = candle_core::Device::Cpu;
+        let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
+        {
+            let mut vars = tok.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho_tok)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        let mut ger = gerador::GeradorConceitos::novo(&cfg_rust, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?;
+        {
+            let mut vars = ger.vars();
+            treino::carregar_vars_do_checkpoint(&mut vars, &caminho_ger)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        }
+        // congela a corrupção/dropout para avaliação determinística
+        let dados = treino::DadosTreino::novo(sequencias, cfg_rust.modelo.comprimento_ctx);
+        let mut rng = <rand::prelude::StdRng as rand::SeedableRng>::seed_from_u64(271828);
+        let mut ces_por_nivel: Vec<Vec<f64>> = Vec::new();
+        let mut accs = Vec::new();
+        let mut residuos = Vec::new();
+        // avalia em minibatches do tamanho do lote de config
+        let mut todos: Vec<candle_core::Tensor> = Vec::new();
+        for s in &dados.sequencias {
+            todos.push(candle_core::Tensor::from_vec(s.clone(), (1, s.len()), &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
+        }
+        for chunk in todos.chunks(cfg_rust.treino.lote.max(1)) {
+            let plano = chunk[0].clone();
+            let b = chunk.len();
+            let n = plano.dim(1).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let mut v = Vec::with_capacity(b * n);
+            for t in chunk {
+                v.extend(t.flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?.to_vec1::<u32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
+            }
+            let ids = candle_core::Tensor::from_vec(v, (b, n), &dev)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let cod = tok.codificar_congelado(&ids).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let saida = ger.perda_treino(&tok, &cod.ids, &mut rng).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            ces_por_nivel.push(saida.ce_por_nivel.clone());
+            accs.push(saida.acuracia_media);
+            residuos.push(saida.residuo_algebrico);
+        }
+        // média por nível
+        let l = cfg_rust.l_niveis();
+        let mut media_nivel = vec![0f64; l];
+        for ces in &ces_por_nivel {
+            for (i, c) in ces.iter().enumerate() {
+                if i < l {
+                    media_nivel[i] += c / ces_por_nivel.len() as f64;
+                }
+            }
+        }
+        let media = media_nivel.iter().sum::<f64>() / l as f64;
+        Ok(serde_json::json!({
+            "ce_media": media,
+            "ce_por_nivel": media_nivel,
+            "acuracia_media": accs.iter().sum::<f64>() / accs.len().max(1) as f64,
+            "residuo_algebrico": residuos.iter().sum::<f64>() / residuos.len().max(1) as f64,
+        }))
+    })?;
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
 #[pymodule]
 fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
     pyo3_log::init();
@@ -415,6 +781,11 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(gerar_amostras, m)?)?;
     m.add_function(wrap_pyfunction!(verificar_mascara, m)?)?;
     m.add_function(wrap_pyfunction!(verificar_stiefel, m)?)?;
+    m.add_function(wrap_pyfunction!(verificar_vazamento_efetivo, m)?)?;
+    m.add_function(wrap_pyfunction!(verificar_paridade, m)?)?;
+    m.add_function(wrap_pyfunction!(verificar_delta_ort, m)?)?;
+    m.add_function(wrap_pyfunction!(verificar_checkpoint, m)?)?;
+    m.add_function(wrap_pyfunction!(avaliar_ce, m)?)?;
     m.add_class::<BpePy>()?;
     m.add_class::<ConfigPy>()?;
     m.add_class::<PonteDuplaPy>()?;

src/mascaras.rs

@@ -1,14 +1,45 @@
 //! Máscaras e interpolação multiscale (port de `conceitos/mascaras.py` do n-04 §2.2;
 //! contratos dos Teos D.1(ii)/B.2 — verificação V4: vazamento zero).
+//!
+//! ## Correção M1 (v0.2.0 — auditoria r-08)
+//! Na v0.1.11 as linhas `i < n_prefixo` nunca eram escritas ⇒ permaneciam
+//! `f32::MIN` em TODAS as colunas. O softmax de uma linha totalmente bloqueada
+//! **não é nulo — é uniforme** (o softmax subtrai o máximo; `exp(MIN−MIN)=1`):
+//! o prefixo "enxergava" a sequência inteira, inclusive níveis FUTUROS, e como
+//! o prefixo é visível a todos os blocos existia o caminho
+//! `nível futuro → prefixo → nível ℓ` — a fatoração next-concept (Teo B.1/D.1)
+//! estava quebrada em treino, e o V4 (que conta a MATRIZ) reportava 0.
+//!
+//! **Teo M-1 (isolamento causal do prefixo).** Com a máscara intra-prefixo
+//! causal (`M[i][j]=0 ⇔ j ≤ i` para `i < P`) e blocos visíveis apenas a
+//! `j < fim(ℓ)`, vale: a saída das posições do prefixo é função apenas do
+//! prefixo; a saída do nível ℓ é função de `prefixo ∪ níveis ≤ ℓ`.
+//! *Prova:* o softmax normaliza por linha sobre as colunas visíveis; com
+//! `M[i][j] = MIN` para `j > i` (prefixo) e `j ≥ fim(ℓ)` (bloco ℓ), os pesos
+//! fora do conjunto permitido são `exp(MIN − max) = 0` exatamente (subtração
+//! do máximo por linha no candle), logo o valor esperado dos V's não inclui
+//! posições proibidas; por indução em blocos (o bloco b+1 só lê saídas de
+//! blocos ≤ b, que por hipótese já são causais), o mapa inteiro fatora por
+//! `s_{permitido}`. ∎
+//!
+//! A verificação EFETIVA (perturbar o futuro e medir a resposta — gate G1)
+//! vive em `tests/provas.rs` e `lib.rs::verificar_vazamento_efetivo`.
 
 use candle_core::{D, DType, Device, Result, Tensor};
+use std::cell::RefCell;
 
-/// Máscara aditiva block-causal B (Teo D.1(ii)): o slot do bloco ℓ atende ao
-/// prefixo (sempre visível) e a TODOS os blocos ≤ ℓ (bidirecional no bloco
-/// próprio). `tamanhos` = [n_1, …, n_L]; `n_prefixo` = |cond|.
+/// Visibilidade do prefixo (Teo D.1(ii) + correção M1).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum VisaoPrefixo {
+    /// Causal dentro do prefixo (correto): posição i < P vê j ≤ i.
+    Causal,
+}
+
+/// Máscara aditiva block-causal B (Teo D.1(ii) + M1): o slot do bloco ℓ atende
+/// ao prefixo e a TODOS os blocos ≤ ℓ (bidirecional no bloco próprio); o
+/// prefixo é causal internamente. `tamanhos` = [n_1, …, n_L].
 ///
-/// Retorna matriz (T+P, T+P) f32 com 0 onde permitido e f32::MIN onde bloqueado,
-/// pronta para `scores + mask` (broadcast).
+/// Retorna matriz (T+P, T+P) f32 com 0 onde permitido e f32::MIN onde bloqueado.
 pub fn mascara_block_causal(tamanhos: &[usize], n_prefixo: usize, dev: &Device) -> Result<Tensor> {
     let mut cortes = vec![n_prefixo];
     for &t in tamanhos {
@@ -17,6 +48,12 @@ pub fn mascara_block_causal(tamanhos: &[usize], n_prefixo: usize, dev: &Device)
     }
     let total = *cortes.last().unwrap();
     let mut m = vec![f32::MIN; total * total];
+    // M1: prefixo causal — SEM linha totalmente bloqueada
+    for i in 0..n_prefixo {
+        for j in 0..=i {
+            m[i * total + j] = 0.0;
+        }
+    }
     for (bloco_i, (&ini_i, &fim_i)) in cortes.iter().zip(cortes.iter().skip(1)).enumerate() {
         for i in ini_i..fim_i {
             // prefixo sempre visível
@@ -33,8 +70,23 @@ pub fn mascara_block_causal(tamanhos: &[usize], n_prefixo: usize, dev: &Device)
     Tensor::from_vec(m, (total, total), dev)?.to_dtype(DType::F32)
 }
 
-/// Verificação V4 — nenhuma posição do bloco ℓ acessa bloco > ℓ.
-/// Devolve o número de vazamentos (deve ser 0).
+/// Detector M1: devolve o número de linhas da máscara SEM nenhuma posição
+/// visível (≥ 0.0). Com a correção, deve ser 0 para toda máscara produzida
+/// por `mascara_block_causal` (gate G4).
+pub fn linhas_sem_visivel(mascara: &Tensor) -> Result<usize> {
+    let total = mascara.dim(0)?;
+    let dados = mascara.flatten_all()?.to_vec1::<f32>()?;
+    let mut n = 0usize;
+    for i in 0..total {
+        if !dados[i * total..(i + 1) * total].iter().any(|&v| v >= 0.0) {
+            n += 1;
+        }
+    }
+    Ok(n)
+}
+
+/// Verificação V4 — nenhuma posição do bloco ℓ acessa bloco > ℓ (MATRIZ).
+/// O vazamento EFETIVO (função, não estrutura) é verificado pelo gate G1.
 pub fn contar_vazamentos(tamanhos: &[usize], n_prefixo: usize, mascara: &Tensor) -> Result<usize> {
     let total = mascara.dim(0)?;
     let dados = mascara.flatten_all()?.to_vec1::<f32>()?;
@@ -57,19 +109,60 @@ pub fn contar_vazamentos(tamanhos: &[usize], n_prefixo: usize, mascara: &Tensor)
     Ok(vazamentos)
 }
 
+/// Máscara incremental (rota KV-cache — M1 também aqui): as `n_novo` posições
+/// novas do nível ℓ+1 veem o cache (prefixo + níveis ≤ ℓ) e o próprio bloco.
+/// A v0.1.11 usava `vec![0.0]` (TUDO liberado) — a rota incremental herda o
+/// mesmo contrato block-causal do treino.
+pub fn mascara_incremental(n_novo: usize, total_vis: usize, dev: &Device) -> Result<Tensor> {
+    // linhas = posições novas (todas veem cache + próprias); a máscara é aditiva
+    // (n_novo × total_vis) — nada de futuro existe no incremental, logo tudo 0
+    // é correto AQUI; a correção M1 desta rota é que o PREFIXO no cache foi
+    // produzido pela máscara causal (treino) e não pela uniforme.
+    let m = vec![0f32; n_novo * total_vis];
+    Tensor::from_vec(m, (n_novo, total_vis), dev)?.to_dtype(DType::F32)
+}
+
 /// Matriz de interpolação linear `Interp_n` (n-02 §0): R^{n_de × d} → R^{n_para × d}.
 /// - downsample (n_para < n_de): média por segmento com pesos de sobreposição (área),
 ///   linhas somam 1 (contrato: "down = avg-pool por segmento");
 /// - upsample: interpolação linear entre os 2 vizinhos.
 /// Linear, determinística, sem parâmetros (gradiente flui por matmul).
+///
+/// M16: memoização thread-local por `(n_de, n_para, ptr-dispositivo)` — a
+/// v0.1.11 reconstruía a matriz a cada chamada (~16/passo × até 256 KB).
 pub fn matriz_interp(n_de: usize, n_para: usize, dev: &Device) -> Result<Tensor> {
+    thread_local! {
+        static CACHE: RefCell<Vec<(usize, usize, u64, Tensor)>> = RefCell::new(Vec::new());
+    }
+    let chave_dev = match dev {
+        Device::Cpu => 0u64,
+        #[allow(unreachable_patterns)]
+        _ => 1u64,
+    };
+    CACHE.with(|c| {
+        if let Ok(mut c) = c.try_borrow_mut() {
+            if let Some((_, _, _, t)) = c.iter().find(|(a, b, d, _)| *a == n_de && *b == n_para && *d == chave_dev) {
+                return Ok(t.clone());
+            }
+        }
+        let t = matriz_interp_bruta(n_de, n_para, dev)?;
+        if let Ok(mut c) = c.try_borrow_mut() {
+            if c.len() > 64 {
+                c.remove(0);
+            }
+            c.push((n_de, n_para, chave_dev, t.clone()));
+        }
+        Ok(t)
+    })
+}
+
+fn matriz_interp_bruta(n_de: usize, n_para: usize, dev: &Device) -> Result<Tensor> {
     let mut w = vec![0f32; n_para * n_de];
     if n_de == n_para {
         for i in 0..n_para {
             w[i * n_de + i] = 1.0;
         }
     } else if n_para < n_de {
-        // média por segmento com bordas fracionárias
         let razao = n_de as f64 / n_para as f64;
         for i in 0..n_para {
             let ini = i as f64 * razao;
@@ -83,7 +176,6 @@ pub fn matriz_interp(n_de: usize, n_para: usize, dev: &Device) -> Result<Tensor>
             }
         }
     } else {
-        // upsample linear
         let razao = n_de as f64 / n_para as f64;
         for i in 0..n_para {
             let centro = (i as f64 + 0.5) * razao - 0.5;
@@ -102,7 +194,6 @@ pub fn matriz_interp(n_de: usize, n_para: usize, dev: &Device) -> Result<Tensor>
 pub fn interp_para(x: &Tensor, n_para: usize, dev: &Device) -> Result<Tensor> {
     let n_de = x.dim(D::Minus2)?;
     let w = matriz_interp(n_de, n_para, dev)?;
-    // (n_para, n_de) x (..., n_de, d) -> (..., n_para, d)
     w.broadcast_matmul(x)
 }
 
@@ -124,14 +215,43 @@ mod testes {
         Ok(())
     }
 
+    /// Gate G4 (parte 1): NENHUMA linha totalmente bloqueada (o defeito M1).
+    #[test]
+    fn gate_mascara_sem_linhas_vazias() -> candle_core::Result<()> {
+        let dev = Device::Cpu;
+        let tamanhos = [4usize, 8, 16, 32, 64, 128, 256];
+        let m = mascara_block_causal(&tamanhos, 8, &dev)?;
+        assert_eq!(linhas_sem_visivel(&m)?, 0, "M1: nenhuma linha pode estar 100% bloqueada");
+        // prefixo causal: linha 0 vê apenas a coluna 0
+        let dados = m.flatten_all()?.to_vec1::<f32>()?;
+        let total = m.dim(0)?;
+        assert!(dados[0] >= 0.0 && dados[1] == f32::MIN, "prefixo deve ser causal");
+        // linha 7 (última do prefixo) vê 0..=7
+        for j in 0..total {
+            let esperado = if j <= 7 { 0.0 } else { f32::MIN };
+            assert_eq!(dados[7 * total + j], esperado, "linha 7 col {j}");
+        }
+        Ok(())
+    }
+
     #[test]
     fn interp_preserva_constante() -> candle_core::Result<()> {
         let dev = Device::Cpu;
-        // downsample de vetor constante → constante (linhas somam 1)
         let x = Tensor::from_vec(vec![2.0f32; 8], (8, 1), &dev)?;
         let y = interp_para(&x, 4, &dev)?;
         let v = y.flatten_all()?.to_vec1::<f32>()?;
         assert!(v.iter().all(|&a| (a - 2.0).abs() < 1e-5), "{v:?}");
         Ok(())
     }
+
+    /// M16: memoização devolve a MESMA matriz (ponteiro/igualdade de valores).
+    #[test]
+    fn interp_memoizada() -> candle_core::Result<()> {
+        let dev = Device::Cpu;
+        let a = matriz_interp(64, 32, &dev)?;
+        let b = matriz_interp(64, 32, &dev)?;
+        let dif = (&a - &b)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert_eq!(dif, 0.0);
+        Ok(())
+    }
 }

src/memoria.rs

@@ -17,14 +17,33 @@ pub struct SomConceitos {
 
 impl SomConceitos {
     pub fn novo(lado: usize, d_lat: usize, dev: &Device) -> Result<Self> {
+        crate::rng::inicializar(crate::rng::SEMENTE_SOM);
         Ok(SomConceitos {
-            prototipos: Tensor::randn(0f32, 0.1, (lado * lado, d_lat), dev)?,
+            prototipos: crate::rng::randn_semeado(0.1, &[lado * lado, d_lat], dev)?,
             lado,
             lr: 0.05,
             eq_medio: 0.0,
         })
     }
 
+    /// v0.3.0 (A22/retomada): protótipos serializados.
+    pub fn prototipos_flat(&self) -> Vec<f32> {
+        self.prototipos.flatten_all().unwrap().to_vec1::<f32>().unwrap()
+    }
+
+    pub fn lado(&self) -> usize {
+        self.lado
+    }
+
+    /// v0.3.0 (retomada): restaura protótipos salvos.
+    pub fn restaurar(&mut self, valores: &[f32], lado: usize) -> Result<()> {
+        let d = if lado > 0 { valores.len() / (lado * lado) } else { 0 };
+        let dev = self.prototipos.device();
+        self.prototipos = Tensor::from_vec(valores.to_vec(), (lado * lado, d), &dev)?;
+        self.lado = lado;
+        Ok(())
+    }
+
     /// Insere vetores (n, d_lat) com atualização online (sem gradiente — V14).
     pub fn inserir(&mut self, vetores: &Tensor) -> Result<f64> {
         let p = self.prototipos.flatten_all()?.to_vec1::<f32>()?;

src/ponte.rs

@@ -24,7 +24,6 @@ use serde::{Deserialize, Serialize};
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Mensagem {
     pub rodada: u64,
@@ -53,7 +52,7 @@ struct Lado {
     nome: String,
     para_outro: Sender<Mensagem>,
     do_outro: Receiver<Mensagem>,
-    ultima_janela: Mutex<Option<(Instant, Instant)>>,
+    ultima_janela: Arc<Mutex<Option<(Instant, Instant)>>>,
 }
 
 pub struct PonteDupla {
@@ -70,8 +69,8 @@ impl PonteDupla {
         let (tx_ab, rx_ab) = bounded::<Mensagem>(capacidade);
         let (tx_ba, rx_ba) = bounded::<Mensagem>(capacidade);
         PonteDupla {
-            a: Lado { nome: "A".into(), para_outro: tx_ab, do_outro: rx_ba, ultima_janela: Mutex::new(None) },
-            b: Lado { nome: "B".into(), para_outro: tx_ba, do_outro: rx_ab, ultima_janela: Mutex::new(None) },
+            a: Lado { nome: "A".into(), para_outro: tx_ab, do_outro: rx_ba, ultima_janela: Arc::new(Mutex::new(None)) },
+            b: Lado { nome: "B".into(), para_outro: tx_ba, do_outro: rx_ab, ultima_janela: Arc::new(Mutex::new(None)) },
             stats: Arc::new(Mutex::new(EstatisticasPonte::default())),
             ativa: Arc::new(AtomicBool::new(true)),
             capacidade,
@@ -81,6 +80,13 @@ impl PonteDupla {
 
     /// Uma RODADA de troca duplex: ambos os lados enviam e recebem com
     /// timeout — nenhuma espera ilimitada (Teo P.1 — sem deadlock).
+    ///
+    /// v0.2.0 (M13/M14): os ENVIOS usam `send_timeout` (a v0.1.11 usava
+    /// `send` bloqueante sem prazo — com o canal cheio o interpretador
+    /// inteiro congelava) e rodam em THREADS SEPARADAS — a métrica de
+    /// sobreposição mede a INTERSEÇÃO REAL das janelas de envio (a v0.1.11
+    /// media a duração do envio de A com os dois envios SEQUENCIAIS na
+    /// mesma thread — sobreposição estruturalmente nula).
     pub fn rodada(&self, carga_a: Vec<f32>, carga_b: Vec<f32>, nivel: usize) -> Result<(Mensagem, Mensagem), String> {
         let inicio = Instant::now();
         let rodada = {
@@ -89,11 +95,39 @@ impl PonteDupla {
         };
         let msg_a = Mensagem { rodada, origem: "A".into(), nivel, ts_us: inicio.elapsed().as_micros(), carga: carga_a };
         let msg_b = Mensagem { rodada, origem: "B".into(), nivel, ts_us: inicio.elapsed().as_micros(), carga: carga_b };
-        // envios (ambas as direções)
-        let t_env_a = Instant::now();
-        self.a.para_outro.send(msg_a).map_err(|e| format!("envio A: {e}"))?;
-        let t_env_b = Instant::now();
-        self.b.para_outro.send(msg_b).map_err(|e| format!("envio B: {e}"))?;
+        // M14: envios PARALELOS em threads separadas com prazo (M13)
+        let tx_a = self.a.para_outro.clone();
+        let tx_b = self.b.para_outro.clone();
+        let timeout = self.timeout;
+        let janela_a = self.a.ultima_janela.clone();
+        let janela_b = self.b.ultima_janela.clone();
+        let envio_a = std::thread::spawn(move || -> std::io::Result<(Instant, Instant)> {
+            let t0 = Instant::now();
+            tx_a.send_timeout(msg_a, timeout)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("{e}")))?;
+            Ok((t0, Instant::now()))
+        });
+        let envio_b = std::thread::spawn(move || -> std::io::Result<(Instant, Instant)> {
+            let t0 = Instant::now();
+            tx_b.send_timeout(msg_b, timeout)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("{e}")))?;
+            Ok((t0, Instant::now()))
+        });
+        let (ja, jb) = match (envio_a.join(), envio_b.join()) {
+            (Ok(Ok(a)), Ok(Ok(b))) => (a, b),
+            (Err(_), _) | (_, Err(_)) => return Err("join: pânico numa thread de envio".into()),
+            (Ok(Err(e)), _) | (_, Ok(Err(e))) => {
+                self.stats.lock().unwrap().quedas_por_timeout += 1;
+                return Err(format!("timeout de envio: {e}"));
+            }
+        };
+        // registra as janelas (M14)
+        if let Ok(mut j) = janela_a.lock() {
+            *j = Some(ja);
+        }
+        if let Ok(mut j) = janela_b.lock() {
+            *j = Some(jb);
+        }
         // recebimentos com timeout
         let recebido_b = self.b.do_outro.recv_timeout(self.timeout);
         let recebido_a = self.a.do_outro.recv_timeout(self.timeout);
@@ -108,11 +142,14 @@ impl PonteDupla {
                 s.tempo_total_ms = inicio.elapsed().as_secs_f64() * 1000.0;
                 s.sobrecarga_media_us = (s.sobrecarga_media_us * (rodada - 1) as f64
                     + inicio.elapsed().as_micros() as f64) / rodada as f64;
-                // sobreposição das janelas de envio (prova de simultaneidade)
-                let dur_a = t_env_a.elapsed();
-                let sobre = dur_a.as_micros();
-                if sobre > s.maior_sobreposicao_us {
-                    s.maior_sobreposicao_us = sobre;
+                // M14: INTERSEÇÃO REAL das janelas [ja.0, ja.1] ∩ [jb.0, jb.1]
+                let ini_max = ja.0.max(jb.0);
+                let fim_min = ja.1.min(jb.1);
+                if fim_min > ini_max {
+                    let sobre = (fim_min - ini_max).as_micros();
+                    if sobre > s.maior_sobreposicao_us {
+                        s.maior_sobreposicao_us = sobre;
+                    }
                 }
                 Ok((ma, mb))
             }

src/quantizador.rs

@@ -57,17 +57,26 @@ impl CustomOp3 for GsqSuave {
         _s2: &CpuStorage, _l2: &Layout,
         s3: &CpuStorage, l3: &Layout,
     ) -> Result<(CpuStorage, Shape)> {
-        if !(l1.is_contiguous() && _l2.is_contiguous() && l3.is_contiguous()) {
-            return Err(candle_core::Error::Msg(
-                "gsq_suave: tensors de entrada devem ser contíguos (chame .contiguous())".into(),
-            ));
-        }
-        let z = s1.as_slice::<f32>()?;
+        // CORREÇÃO (mesma classe do bug do ssd_scan): `as_slice` devolve o
+        // storage INTEIRO — usamos contiguous_offsets p/ respeitar offsets.
+        let (z1, z2) = l1.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("gsq_suave: z deve ser contíguo".into())
+        })?;
+        let (c1, c2) = _l2.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("gsq_suave: C deve ser contíguo".into())
+        })?;
+        let (r1, r2) = l3.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("gsq_suave: ruído deve ser contíguo".into())
+        })?;
+        let z_todos = s1.as_slice::<f32>()?;
+        let c_todos = _s2.as_slice::<f32>()?;
+        let ruido_todos = s3.as_slice::<f32>()?;
+        let z = &z_todos[z1..z2];
+        let c = &c_todos[c1..c2];
+        let ruido = &ruido_todos[r1..r2];
         let (n, d) = (l1.shape().dims()[0], l1.shape().dims()[1]);
-        let c = _s2.as_slice::<f32>()?;
         let (k, _dc) = (_l2.shape().dims()[0], _l2.shape().dims()[1]);
-        let ruido = s3.as_slice::<f32>()?;
-        debug_assert_eq!(ruido.len(), z.len() / d * k * d / d * k); // (n,k)
+        debug_assert_eq!(ruido.len(), n * k); // (n, k) — A30: assert correto
         // logits = z·Cᵀ/τ + g
         let mut logits = vec![0f32; n * k];
         for i in 0..n {
@@ -101,7 +110,7 @@ impl CustomOp3 for GsqSuave {
     ) -> Result<(Option<Tensor>, Option<Tensor>, Option<Tensor>)> {
         // recompute y (mesmo ruído — arg3): y = softmax(zCᵀ/τ + g)
         let logits = (&arg1.matmul(&arg2.transpose(0, 1)?)?.affine(1.0 / self.tau, 0.0)? + arg3)?;
-        let y = candle_nn::ops::softmax_last_dim(&logits)?;
+        let y = candle_nn::ops::softmax(&logits, D::Minus1)?;
         // gy = R·(g_·Cᵀ)
         let gy = (&grad_res.matmul(&arg2.transpose(0, 1)?)? * self.r)?;
         // gl = y ⊙ (gy − Σ(y⊙gy)) — media como coluna p/ broadcast (n,1)
@@ -132,11 +141,26 @@ pub struct QuantizadorNivel {
     pub uso: Vec<f64>,      // contagem de uso por código (telemetria/colapso)
     pub semente: u64,       // RNG dedicado do nível (pareamento — Teo 31.7)
     chamadas: std::cell::Cell<u64>, // contador p/ ruído fresco por chamada
+    /// A43: cache do codebook por passo (invalidado por `invalidar_cache`).
+    cache_codebook: std::cell::RefCell<Option<Tensor>>,
 }
 
 impl QuantizadorNivel {
     pub fn novo(k: usize, d: usize, modo: ModoQuant, ema: f64, escala_modo: &str, dev: &Device) -> Result<Self> {
+        Self::novo_nivel(k, d, modo, ema, escala_modo, 0, dev)
+    }
+
+    /// `nivel` (0-based) entra na semente (M11: a v0.1.11 usava apenas
+    /// (k, d) — IGUAIS em todos os níveis — e o ruído de Gumbel era
+    /// byte-idêntico entre níveis, contradizendo o i.i.d. do Teo A.4).
+    pub fn novo_nivel(k: usize, d: usize, modo: ModoQuant, ema: f64, escala_modo: &str, nivel: usize, dev: &Device) -> Result<Self> {
         let w0 = stiefel::init_stiefel(k, d, dev)?;
+        // M11: semente inclui o índice do nível (mix de Fibonacci hashing)
+        let semente = 0xC0FFEE_u64
+            .wrapping_mul(0x9E3779B97F4A7C15)
+            .wrapping_add((nivel as u64).wrapping_mul(0x9E3779B97F4A7C15))
+            ^ (k as u64).wrapping_mul(7919)
+            ^ (d as u64).wrapping_mul(104729);
         Ok(QuantizadorNivel {
             w: Var::from_tensor(&w0)?,
             r_escala: 1.0 / (k as f64).sqrt(),
@@ -147,16 +171,29 @@ impl QuantizadorNivel {
             iters_polar: 30,
             delta_ort_ultimo: 0.0,
             uso: vec![0.0; k],
-            semente: 0xC0FFEE + k as u64 * 7919 + d as u64,
+            semente,
             chamadas: std::cell::Cell::new(0),
+            cache_codebook: std::cell::RefCell::new(None),
         })
     }
 
+    /// A43: invalida o cache do codebook (chamar após cada passo do otimizador).
+    pub fn invalidar_cache(&self) {
+        *self.cache_codebook.borrow_mut() = None;
+    }
+
     /// Codebook C = R(Wᵀ)ᵀ com linhas ortonormais (diferenciável — Teo 26.3).
     /// SEMPRE contíguo (index_select/arquivo exigem layout padrão).
+    /// A43: memoizado dentro do passo (o codebook é recalculado ~5×/nível/passo
+    /// na v0.1.11 — ≈550 MMAC/passo redundantes).
     pub fn codebook(&self) -> Result<Tensor> {
-        let c = stiefel::codebook_stiefel(self.w.as_tensor(), self.iters_polar)?;
-        c.contiguous()
+        if let Some(c) = self.cache_codebook.borrow().as_ref() {
+            return Ok(c.clone());
+        }
+        let c = stiefel::codebook_stiefel(self.w.as_tensor(), self.iters_polar)?
+            .contiguous()?;
+        *self.cache_codebook.borrow_mut() = Some(c.clone());
+        Ok(c)
     }
 
     /// δ_ort do codebook corrente (V9).
@@ -198,9 +235,13 @@ impl QuantizadorNivel {
                 redimensionar_de_volta(&r, z)
             }
             ModoQuant::SteEma => {
-                let r_duro = self.valores_duros_int(z, &self.codebook()?.contiguous()?)?.detach();
-                // STE: z + (r_duro − z) com r_duro constante no grafo
-                Ok(z.add(&r_duro.sub(z)?)?)
+                let c = self.codebook()?;
+                let r_duro = self.valores_duros_int(z, &c)?.detach();
+                // M7: STE CORRETO — z + sg[r_duro − z]: forward = r_duro,
+                // gradiente w.r.t. z = 1 (a v0.1.11 computava z + (r−z) com
+                // AMBOS no grafo ⇒ ∂/∂z = 1 − 1 = 0: encoder sem sinal).
+                let d = (&r_duro - z)?.detach();
+                Ok(z.add(&d)?)
             }
         }
     }
@@ -233,6 +274,22 @@ impl QuantizadorNivel {
         Ok(linhas.affine(self.r_escala, 0.0)?)
     }
 
+    /// v0.3.0 — verificador algébrico soft: materializa DISTRIBUIÇÕES:
+    /// probs (…, K) → (…, d) com Σ_k q_k·R·c_k (diferenciável em q;
+    /// codebook congelado). Usado por L_alg (Teo G-1).
+    pub fn materializar_probs(&self, probs: &Tensor) -> Result<Tensor> {
+        let c = self.codebook()?.detach();
+        let k = c.dim(0)?;
+        let d = c.dim(1)?;
+        let forma: Vec<usize> = probs.dims().to_vec();
+        let plano = probs.reshape((probs.elem_count() / k, k))?;
+        let soft = plano.matmul(&c)?;
+        let mut alvo = forma;
+        alvo.pop();
+        alvo.push(d);
+        Ok(soft.affine(self.r_escala, 0.0)?.reshape(alvo)?)
+    }
+
     /// Atualiza R_ℓ por EMA da escala de projeção (Cor. A.1.1):
     /// "ema_projecao": R ← EMA(E[‖P_C z‖]); "otima_teo": R ← EMA(E[‖P_C z‖/√K]).
     pub fn atualizar_escala(&mut self, z: &Tensor) -> Result<()> {
@@ -349,12 +406,51 @@ mod testes {
             uso: vec![10.0, 10.0, 10.0, 10.0],
             semente: 7,
             chamadas: std::cell::Cell::new(0),
+            cache_codebook: std::cell::RefCell::new(None),
         };
         let p = q.perplexidade_uso();
         assert!((p - 4.0).abs() < 1e-9);
         q.uso = vec![40.0, 0.0, 0.0, 0.0];
         assert!(q.perplexidade_uso() < 1.01);
     }
+
+    /// M11: sementes de níveis distintos devem gerar ruídos distintos.
+    #[test]
+    fn sementes_por_nivel_distintas() -> Result<()> {
+        let dev = Device::Cpu;
+        let q0 = QuantizadorNivel::novo_nivel(64, 64, ModoQuant::GsqRco, 0.99, "ema_projecao", 0, &dev)?;
+        let q1 = QuantizadorNivel::novo_nivel(64, 64, ModoQuant::GsqRco, 0.99, "ema_projecao", 1, &dev)?;
+        assert_ne!(q0.semente, q1.semente, "M11: sementes devem diferir por nível");
+        let r0 = q0.ruido_gumbel(16, 64, &dev)?;
+        let r1 = q1.ruido_gumbel(16, 64, &dev)?;
+        let dif = (&r0 - &r1)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif > 0.0, "ruído de Gumbel não pode ser idêntico entre níveis");
+        Ok(())
+    }
+
+    /// M7: o STE transmite gradiente unitário ao encoder.
+    #[test]
+    fn ste_gradiente_unitario() -> Result<()> {
+        let dev = Device::Cpu;
+        let q = QuantizadorNivel::novo_nivel(8, 6, ModoQuant::SteEma, 0.99, "ema_projecao", 0, &dev)?;
+        let z = crate::rng::randn_semeado(1.0, &[5, 6], &dev)?;
+        let zv = Var::from_tensor(&z)?;
+        let r = q.quantizar_treino(zv.as_tensor())?;
+        // forward: r deve ser igual ao r_duro
+        let (_ids, r_duro) = q.quantizar_duro(zv.as_tensor())?;
+        let dif = (&r - &r_duro)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif < 1e-6, "STE forward = r_duro (dif {dif})");
+        // gradiente: perda = Σ w·r ⇒ ∂/∂z = via STE
+        let pesos = crate::rng::randn_semeado(1.0, &[5, 6], &dev)?;
+        let perda = (&r * &pesos)?.sum_all()?;
+        let gs = perda.backward()?;
+        let g = gs.get(&zv).unwrap().flatten_all()?.to_vec1::<f32>()?;
+        let pv = pesos.flatten_all()?.to_vec1::<f32>()?;
+        for i in 0..g.len() {
+            assert!((g[i] - pv[i]).abs() < 1e-5, "STE: grad deve ser dL/dr (got {} want {})", g[i], pv[i]);
+        }
+        Ok(())
+    }
 }
 
 #[cfg(test)]

src/rng.rs

@@ -0,0 +1,101 @@
+//! RNG global semeado (correção A19 da auditoria r-08): `Tensor::randn` do
+//! candle 0.11 usa `rand::rng()` (entropia do SO) ⇒ **nenhuma execução era
+//! reproduzível**. Este módulo fornece `randn_semeado` — amostragem normal a
+//! partir de um `StdRng` GLOBAL semeado uma vez por processo a partir de
+//! `treino.semente` (Teo 31.7 — RNG dedicado e auditável).
+//!
+//! **Teo R-1 (reprodutibilidade bit-a-bit).** Fixada a semente `s` e a
+//! sequência de chamadas de construção do modelo, o estado inicial de todos os
+//! parâmetros é uma função determinística de `(s, ordem de construção)`.
+//! *Prova:* `StdRng::seed_from_u64(s)` inicia um gerador PCG/BLS determinístico;
+//! cada chamada de `randn_semeado` consome um número fixo de `f32`'s (shape
+//! fixa por sítio de chamada) e o mutex serializa a ordem; a conversão
+//! Box–Muller é pura ⇒ mesmas entradas ⇒ mesmos bits. Com a mesma `(s, ordem)`,
+//! dois processos produzem estados iniciais idênticos bit-a-bit. ∎
+//!
+//! Uso: `inicializar_rng(semente)` UMA vez no início de cada treino/carregamento
+//! (fase A, fase B, gates), depois `randn_semeado(shape, dev)` no lugar de
+//! `Tensor::randn`.
+
+use candle_core::{Device, Result, Tensor};
+use rand::prelude::*;
+use std::sync::Mutex;
+use std::sync::OnceLock;
+
+static RNG_GLOBAL: OnceLock<Mutex<StdRng>> = OnceLock::new();
+
+/// Semente fixa para módulos auxiliares (SOM) — determinística.
+pub const SEMENTE_SOM: u64 = 0x50C0FFEE;
+
+/// Semente padrão da inicialização lazy (construções fora do treino).
+pub const SEMENTE_PADRAO: u64 = 2718281828;
+
+/// Inicializa (ou reinicializa) o RNG global com a semente dada.
+pub fn inicializar(semente: u64) {
+    // OnceLock não permite re-init; usamos get_or_init e trocamos o estado
+    // interno por re-seed quando já existe.
+    if let Some(m) = RNG_GLOBAL.get() {
+        if let Ok(mut g) = m.lock() {
+            *g = StdRng::seed_from_u64(semente);
+        }
+        return;
+    }
+    let _ = RNG_GLOBAL.set(Mutex::new(StdRng::seed_from_u64(semente)));
+}
+
+/// Amostra normal(0, desvio) com forma `shape` a partir do RNG global.
+/// Equivalente bit-a-bit determinístico de `Tensor::randn`.
+/// Se `inicializar` ainda não foi chamado, semeia com a semente padrão
+/// (à prova de pânico — construções fora do treino são determinísticas).
+pub fn randn_semeado(desvio: f32, shape: &[usize], dev: &Device) -> Result<Tensor> {
+    let n: usize = shape.iter().product();
+    if RNG_GLOBAL.get().is_none() {
+        // lazy-init com semente padrão (determinístico, sem pânico)
+        let _ = RNG_GLOBAL.set(Mutex::new(StdRng::seed_from_u64(SEMENTE_PADRAO)));
+    }
+    let m = RNG_GLOBAL
+        .get()
+        .expect("rng global (inicialização lazy acima garante)");
+    let mut guard = m.lock().map_err(|_| {
+        candle_core::Error::Msg("rng global envenenado".into())
+    })?;
+    let mut v = Vec::with_capacity(n);
+    // Box–Muller em pares; determinístico e independente de implementação do
+    // gerador de normais da rand (compatível entre versões).
+    let mut i = 0usize;
+    while i < n {
+        let u1: f32 = guard.gen::<f32>().clamp(1e-9, 1.0);
+        let u2: f32 = guard.gen::<f32>().clamp(1e-9, 1.0);
+        let r = (-2.0 * u1.ln()).sqrt();
+        let t = 2.0 * std::f32::consts::PI * u2;
+        v.push(r * t.cos() * desvio);
+        i += 1;
+        if i < n {
+            v.push(r * t.sin() * desvio);
+            i += 1;
+        }
+    }
+    Tensor::from_vec(v, shape, dev)
+}
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    #[test]
+    fn reprodutibilidade_bit_a_bit() -> Result<()> {
+        let dev = Device::Cpu;
+        inicializar(12345);
+        let a = randn_semeado(0.02, &[7, 11], &dev)?;
+        inicializar(12345);
+        let b = randn_semeado(0.02, &[7, 11], &dev)?;
+        let dif = (&a - &b)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert_eq!(dif, 0.0, "mesma semente deve dar init idêntico bit-a-bit");
+        // sementes diferentes devem diferir
+        inicializar(999);
+        let c = randn_semeado(0.02, &[7, 11], &dev)?;
+        let dif2 = (&a - &c)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif2 > 0.0);
+        Ok(())
+    }
+}

src/ssd.rs

@@ -1,69 +1,172 @@
 //! Slot Mamba-3 (1-de-6 do tronco 5:1) — scan recorrente diagonal seletivo
-//! (SSD) com adjunto EXATO via CustomOp2. Compatível com o Teo D.1(i):
+//! (SSD) com adjunto EXATO via CustomOp3. Compatível com o Teo D.1(i):
 //! fluxo estritamente esquerda→direita (a camada é causal por construção);
 //! a bidirecionalidade intra-nível vem das camadas ADBA (H_D1 — r-04 §3).
 //!
-//! Recorrência: h_t = a_t ⊙ h_{t−1} + (1 − a_t) ⊙ x_t;  y_t = h_t
-//! com a_t = σ(W_a·x_t + b_a) ∈ (0,1)^d (portas por canal).
+//! ## v0.3.0 — SSD-Δ (segunda ordem aditiva): percepção de inteiros e floats
 //!
-//! Adjunto (exato): dh_t = dy_t + a_{t+1} ⊙ dh_{t+1};
-//! dx_t = (1 − a_t) ⊙ dh_t;  da_t = ⟨dh_t, h_{t−1} − x_t⟩ (escalar por canal).
+//! Recorrência aumentada (canal j, tempo t):
+//!   h_t = a_t ⊙ h_{t−1} + (1 − a_t + η_t) ⊙ x_t ;  y_t = h_t
+//!   a_t = σ(W_a·x̂_t + b_a) ∈ (0,1)^d  (porta de memória — como na v0.1.11)
+//!   η_t = tanh(W_η·x̂_t + b_η) ∈ (−1,1)^d  (NOVA porta aditiva de 2ª ordem)
+//!
+//! **Teo S-1 (capacidade de acumulação — a porta η compra aritmética).**
+//! (i) Com `a_t ≡ 1, η_t ≡ 1`: `h_t = h_{t−1} + x_t` — o slot computa a SOMA
+//! ACUMULADA. Para entradas inteiras com `|Σ_{s≤t} x_s| < 2^24`, a aritmética
+//! f32 é EXATA (inteiros ≤ 2^24 são representáveis e a soma não arredonda)
+//! ⇒ o slot PERCEBE progressões aritméticas de inteiros bit-a-bit.
+//! (ii) Com `η_t = tanh(ρ)` constante: o erro de acumulação é
+//! `|h_t − Σ x_s| ≤ 2e^{−2ρ} · Σ_{s≤t} |x_s|` (pois `1−tanh(ρ) = 2e^{−2ρ}(1+o(1))`)
+//! — converge EXPONENCIALMENTE em ρ.
+//! (iii) Para entradas reais (ponto flutuante): o erro de arredondamento da
+//! soma seqüencial é limitado por `(t−1)·ε_mach·Σ|x_s|`, ε_mach = 2^−24 em f32 —
+//! a cota clássica da soma seqüencial, que o slot herda.
+//! (iv) **Contenção estrita**: a família antiga `h_t = a_t⊙h_{t−1} + (1−a_t)⊙x_t`
+//! NÃO contém o mapa soma: desenvolvendo, `h_t = Σ_s (1−a_s)x_s Π_{r>s} a_r`;
+//! exigir `h_t = Σ_s x_s` para todo t força `(1−a_t) = 1` (a_t = 0) e, no mesmo
+//! passo, `(1−a_{t−1})·a_t = 1` — contradição (0 = 1). Logo SSD-Δ ⊋ SSD.
+//! *Prova de (iv):* para t = 2, h_2 = x_2 + x_1 exige (1−a_2) = 1 ⇒ a_2 = 0 e
+//! (1−a_1)·a_2 = 1 ⇒ 0 = 1. Absurdo. ∎
+//! (v) **Nascimento neutro**: com `W_η = 0, b_η = 0` ⇒ η ≡ 0 ⇒ a recorrência é
+//! EXATAMENTE a da v0.1.11 (bit-a-bit: `1−a+0 = 1−a` em f32). O ganho é opt-in.
+//!
+//! ## v0.2.0 — estado transportado (M4)
+//! `cache_estado` (b, d) é USADO como h_0 e atualizado com h_n no fim — o slot
+//! volta a ser recorrente entre níveis (Teo D.1(i)). O adjunto inclui ∂L/∂h_0.
+//!
+//! Adjunto (exato; g_t := gradiente acumulado em h_t):
+//!   ∂L/∂x_t = (1 − a_t + η_t) ⊙ g_t
+//!   ∂L/∂a_t = g_t ⊙ (h_{t−1} − x_t)
+//!   ∂L/∂η_t = g_t ⊙ x_t
+//!   g_{t−1} = a_t ⊙ g_t ;  ∂L/∂h_0 = g_0 (acumulado no fim do backward)
 
-use candle_core::{CpuStorage, CustomOp2, Device, Layout, Result, Shape, Tensor, Var};
+use candle_core::{CpuStorage, CustomOp3, Device, Layout, Result, Shape, Tensor, Var};
 use crate::camadas::{Linear, RmsNorm, Swiglu};
 
-pub struct ScanDiagonal;
-
-impl CustomOp2 for ScanDiagonal {
-    fn name(&self) -> &'static str { "ssd_scan_diagonal" }
+/// CustomOp3: (gates (b·n, 2d) = [a | η], x (b·n, d), h0 (b, d)) → y (b·n, d).
+/// `b` e `n` são carregados no struct (inferidos pelo chamador).
+pub struct ScanDiagonal {
+    pub b: usize,
+    pub n: usize,
+}
 
-    fn cpu_fwd(&self, s1: &CpuStorage, l1: &Layout, s2: &CpuStorage, l2: &Layout) -> Result<(CpuStorage, Shape)> {
-        if !(l1.is_contiguous() && l2.is_contiguous()) {
-            return Err(candle_core::Error::Msg(
-                "ssd_scan: entradas devem ser contíguas (chame .contiguous())".into(),
-            ));
-        }
-        let x = s1.as_slice::<f32>()?; // (n, d)
-        let a = s2.as_slice::<f32>()?; // (n, d) em (0,1)
-        let (n, d) = (l1.shape().dims()[0], l1.shape().dims()[1]);
-        let mut y = vec![0f32; n * d];
+fn scan_fwd(
+    gates: &[f32],
+    x: &[f32],
+    h0: &[f32],
+    y: &mut [f32],
+    bi: usize,
+    b: usize,
+    n: usize,
+    d: usize,
+) {
+    let dois_d = 2 * d;
+    let base = bi * n;
+    let mut h = vec![0f32; d];
+    h.copy_from_slice(&h0[bi * d..(bi + 1) * d]);
+    for i in 0..n {
+        let row = (base + i) * d;
+        let grow = (base + i) * dois_d;
         for j in 0..d {
-            let mut h = 0f32;
-            for i in 0..n {
-                let ai = a[i * d + j];
-                h = ai * h + (1.0 - ai) * x[i * d + j];
-                y[i * d + j] = h;
-            }
+            let a = gates[grow + j];
+            let eta = gates[grow + d + j];
+            h[j] = a * h[j] + (1.0 - a + eta) * x[row + j];
+            y[i * d + j] = h[j];
+        }
+    }
+}
+
+impl CustomOp3 for ScanDiagonal {
+    fn name(&self) -> &'static str { "ssd_scan_delta" }
+
+    fn cpu_fwd(
+        &self,
+        s1: &CpuStorage, l1: &Layout,
+        s2: &CpuStorage, l2: &Layout,
+        s3: &CpuStorage, l3: &Layout,
+    ) -> Result<(CpuStorage, Shape)> {
+        // CORREÇÃO CRÍTICA (descoberta pelo gate G3): `as_slice` devolve o
+        // storage INTEIRO — layouts contíguos COM OFFSET (ex.: narrow de um
+        // tensor maior) começam em `start_offset() != 0`. Usamos
+        // `contiguous_offsets()` (o padrão dos custom ops do candle).
+        let (g1, g2) = l1.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("ssd_scan: gates deve ser contíguo".into())
+        })?;
+        let (x1, x2) = l2.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("ssd_scan: x deve ser contíguo".into())
+        })?;
+        let (h1, h2) = l3.contiguous_offsets().ok_or_else(|| {
+            candle_core::Error::Msg("ssd_scan: h0 deve ser contíguo".into())
+        })?;
+        let gates_todos = s1.as_slice::<f32>()?; // (b*n, 2d)
+        let x_todos = s2.as_slice::<f32>()?;    // (b*n, d)
+        let h0_todos = s3.as_slice::<f32>()?;   // (b, d)
+        let gates = &gates_todos[g1..g2];
+        let x = &x_todos[x1..x2];
+        let h0 = &h0_todos[h1..h2];
+        let (bn, dois_d) = (l1.shape().dims()[0], l1.shape().dims()[1]);
+        let d = dois_d / 2;
+        let (b, n) = (self.b, self.n);
+        debug_assert_eq!(bn, b * n);
+        debug_assert_eq!(l2.shape().dims()[0], bn);
+        debug_assert_eq!(l2.shape().dims()[1], d);
+        debug_assert_eq!(l3.shape().dims()[0], b);
+        let mut y = vec![0f32; bn * d];
+        // M17/A31: paralelo sobre o lote (rayon), canal-interno contíguo.
+        {
+            use rayon::prelude::*;
+            y.par_chunks_mut(n * d).enumerate().for_each(|(bi, fatia)| {
+                scan_fwd(gates, x, h0, fatia, bi, b, n, d);
+            });
         }
-        Ok((CpuStorage::F32(y), (n, d).into()))
+        Ok((CpuStorage::F32(y), (bn, d).into()))
     }
 
-    fn bwd(&self, arg1: &Tensor, arg2: &Tensor, _res: &Tensor, grad_res: &Tensor) -> Result<(Option<Tensor>, Option<Tensor>)> {
-        // recomputa h (forward sem gradiente) e percorre reverso
-        let (x, a) = (arg1, arg2);
-        let h = Tensor::apply_op2(x, a, ScanDiagonal)?.detach();
-        let x_v = x.flatten_all()?.to_vec1::<f32>()?;
-        let a_v = a.flatten_all()?.to_vec1::<f32>()?;
+    fn bwd(
+        &self,
+        arg1: &Tensor, arg2: &Tensor, arg3: &Tensor,
+        _res: &Tensor, grad_res: &Tensor,
+    ) -> Result<(Option<Tensor>, Option<Tensor>, Option<Tensor>)> {
+        let (gates_t, x_t, h0_t) = (arg1, arg2, arg3);
+        // recompute h (forward sem gradiente)
+        let h = Tensor::apply_op3(gates_t, x_t, h0_t, ScanDiagonal { b: self.b, n: self.n })?.detach();
+        let g_v = gates_t.flatten_all()?.to_vec1::<f32>()?;
+        let x_v = x_t.flatten_all()?.to_vec1::<f32>()?;
+        let h0_v = h0_t.flatten_all()?.to_vec1::<f32>()?;
         let h_v = h.flatten_all()?.to_vec1::<f32>()?;
         let dy_v = grad_res.flatten_all()?.to_vec1::<f32>()?;
-        let (n, d) = (x.dim(0)?, x.dim(1)?);
-        let mut dx = vec![0f32; n * d];
-        let mut da = vec![0f32; n * d];
-        let mut dh = vec![0f32; d];
-        for i in (0..n).rev() {
-            for j in 0..d {
-                let idx = i * d + j;
-                let g = dy_v[idx] + dh[j];
-                dx[idx] = (1.0 - a_v[idx]) * g;
-                let h_ant = if i > 0 { h_v[(i - 1) * d + j] } else { 0.0 };
-                da[idx] = g * (h_ant - x_v[idx]);
-                dh[j] = a_v[idx] * g;
+        let (b, n) = (self.b, self.n);
+        let bn = b * n;
+        let dois_d = gates_t.dim(1)?;
+        let d = dois_d / 2;
+        let mut dg = vec![0f32; bn * dois_d];
+        let mut dx = vec![0f32; bn * d];
+        let mut dh0 = vec![0f32; b * d];
+        for bi in 0..b {
+            let base = bi * n;
+            let mut gh = vec![0f32; d];
+            for i in (0..n).rev() {
+                let row = (base + i) * d;
+                let grow = (base + i) * dois_d;
+                for j in 0..d {
+                    let gg = dy_v[row + j] + gh[j];
+                    let a = g_v[grow + j];
+                    let eta = g_v[grow + d + j];
+                    dx[row + j] = (1.0 - a + eta) * gg;
+                    let h_ant = if i > 0 { h_v[(row - d) + j] } else { h0_v[bi * d + j] };
+                    dg[grow + j] = gg * (h_ant - x_v[row + j]);
+                    dg[grow + d + j] = gg * x_v[row + j];
+                    gh[j] = a * gg;
+                }
             }
+            // ∂L/∂h_0[bi] = gh após o tempo 0
+            dh0[bi * d..(bi + 1) * d].copy_from_slice(&gh);
         }
-        let dev = x.device();
-        let gx = Tensor::from_vec(dx, (n, d), dev)?;
-        let ga = Tensor::from_vec(da, (n, d), dev)?;
-        Ok((Some(gx), Some(ga)))
+        let dev = x_t.device();
+        let gg = Tensor::from_vec(dg, (bn, dois_d), dev)?;
+        let gx = Tensor::from_vec(dx, (bn, d), dev)?;
+        let gh0 = Tensor::from_vec(dh0, (b, d), dev)?;
+        Ok((Some(gg), Some(gx), Some(gh0)))
     }
 }
 
@@ -75,11 +178,24 @@ pub struct BlocoSsd {
     pub proj_o: Linear,  // d → d
     pub norm2: RmsNorm,
     pub ffn: Swiglu,
+    /// Porta aditiva de 2ª ordem (SSD-Δ): None = neutro (η ≡ 0, v0.1.11).
+    pub porta_eta: Option<Linear>,
 }
 
 impl BlocoSsd {
-    pub fn novo(d: usize, d_ff: usize, dev: &Device) -> Result<Self> {
+    pub fn novo(d: usize, d_ff: usize, segunda_ordem: bool, dev: &Device) -> Result<Self> {
         let desvio = 1.0 / ((d * 2) as f64).sqrt();
+        // Nascimento neutro: W_η = 0 e b_η = 0 ⇒ η = tanh(0) = 0.
+        let porta_eta = if segunda_ordem {
+            let mut l = Linear::novo(d, d, 0.0, dev)?;
+            if let Some(b) = &mut l.b {
+                let z = Tensor::zeros((d,), candle_core::DType::F32, dev)?;
+                b.set(&z)?;
+            }
+            Some(l)
+        } else {
+            None
+        };
         Ok(BlocoSsd {
             norm1: RmsNorm::novo(d, 1e-5, dev)?,
             porta_a: Linear::novo(d, d, desvio, dev)?,
@@ -87,33 +203,43 @@ impl BlocoSsd {
             proj_o: Linear::sem_vies(d, d, desvio, dev)?,
             norm2: RmsNorm::novo(d, 1e-5, dev)?,
             ffn: Swiglu::novo(d, d_ff, dev)?,
+            porta_eta,
         })
     }
 
-    /// x (b, n, d) → (b, n, d). O scan é aplicado por elemento do lote.
-    /// `cache_estado`: estado h anterior (b, d) para streaming incremental.
+    /// x (b, n, d) → (b, n, d). Scan com ESTADO INICIAL h_0 (M4) e estado final
+    /// devolvido em `cache_estado` (b, d) para o próximo segmento/nível.
     pub fn fwd(&self, x: &Tensor, cache_estado: &mut Option<Tensor>) -> Result<Tensor> {
         let b = x.dim(0)?;
         let n = x.dim(1)?;
         let d = x.dim(2)?;
+        let dev = x.device();
         let xb = self.norm1.fwd(x)?;
         let a = candle_nn::ops::sigmoid(&self.porta_a.fwd(&xb)?)?;
+        let eta = match &self.porta_eta {
+            Some(pe) => pe.fwd(&xb)?.tanh()?,
+            None => Tensor::zeros((b, n, d), candle_core::DType::F32, dev)?,
+        };
         let xp = self.proj_x.fwd(&xb)?;
-        // achata (b·n, d), aplica o scan por lote e recompõe
-        let xf = xp.reshape((b * n, d))?.contiguous()?;
+        // gates = [a | η] (b·n, 2d) — contíguo
         let af = a.reshape((b * n, d))?.contiguous()?;
-        // pré-estado: se houver cache, subtrai efeito — simplificação: scan
-        // independente por segmento com estado inicial zero (documentado; o
-        // estado cruzado entre segmentos é ponto de extensão do streaming).
-        let _ = cache_estado;
-        let mut saidas = Vec::with_capacity(b);
-        for i in 0..b {
-            let xi = xf.narrow(0, i * n, n)?;
-            let ai = af.narrow(0, i * n, n)?;
-            let yi = Tensor::apply_op2(&xi, &ai, ScanDiagonal)?;
-            saidas.push(yi);
+        let ef = eta.reshape((b * n, d))?.contiguous()?;
+        let gates = Tensor::cat(&[&af, &ef], 1)?.contiguous()?;
+        let xf = xp.reshape((b * n, d))?.contiguous()?;
+        // h_0: do cache (M4) ou zeros
+        let h0 = match cache_estado {
+            Some(h) => h.reshape((b, d))?.contiguous()?,
+            None => Tensor::zeros((b, d), candle_core::DType::F32, dev)?,
+        };
+        let y = Tensor::apply_op3(&gates, &xf, &h0, ScanDiagonal { b, n })?;
+        // estado final h_n por elemento do lote: linhas (bi*n + n−1)
+        let mut estados = Vec::with_capacity(b);
+        for bi in 0..b {
+            estados.push(y.narrow(0, bi * n + n - 1, 1)?.reshape((1, d))?);
         }
-        let y = Tensor::cat(&saidas, 0)?.reshape((b, n, d))?;
+        let hn = Tensor::cat(&estados, 0)?.detach();
+        *cache_estado = Some(hn);
+        let y = y.reshape((b, n, d))?;
         let y = self.proj_o.fwd(&y)?;
         let x2 = (x + &y)?;
         let f = self.ffn.fwd(&self.norm2.fwd(&x2)?)?;
@@ -121,10 +247,14 @@ impl BlocoSsd {
     }
 
     pub fn vars(&self) -> Vec<Var> {
-        [
+        let mut v: Vec<Var> = [
             self.norm1.vars(), self.porta_a.vars(), self.proj_x.vars(),
             self.proj_o.vars(), self.norm2.vars(), self.ffn.vars(),
-        ].concat()
+        ].concat();
+        if let Some(pe) = &self.porta_eta {
+            v.extend(pe.vars());
+        }
+        v
     }
 }
 
@@ -134,50 +264,158 @@ mod testes {
 
     #[test]
     fn adjunto_do_scan_vs_finitas_diferencas() -> Result<()> {
+        crate::rng::inicializar(20260101);
         let dev = Device::Cpu;
-        let n = 9;
-        let d = 5;
-        let xv = Var::from_tensor(&Tensor::randn(0f32, 1f32, (n, d), &dev)?)?;
-        let av = Var::from_tensor(&candle_nn::ops::sigmoid(&Tensor::randn(0f32, 1f32, (n, d), &dev)?)?)?;
-        let pesos = Tensor::randn(0f32, 1f32, (n, d), &dev)?;
-        let y = Tensor::apply_op2(xv.as_tensor(), &av.as_tensor(), ScanDiagonal)?;
+        let (b, n, d) = (2usize, 9, 5);
+        let x0 = crate::rng::randn_semeado(1.0, &[b * n, d], &dev)?;
+        let h00 = crate::rng::randn_semeado(1.0, &[b, d], &dev)?;
+        // gates em (0,1)/(−1,1) para o teste
+        let a = candle_nn::ops::sigmoid(&crate::rng::randn_semeado(1.0, &[b * n, d], &dev)?)?;
+        let e = crate::rng::randn_semeado(1.0, &[b * n, d], &dev)?.tanh()?;
+        let pesos = crate::rng::randn_semeado(1.0, &[b * n, d], &dev)?;
+        let gv = Var::from_tensor(&a)?;
+        let ev = Var::from_tensor(&e)?;
+        let hv = Var::from_tensor(&h00)?;
+        let gates = Tensor::cat(&[gv.as_tensor(), ev.as_tensor()], 1)?.contiguous()?;
+        let y = Tensor::apply_op3(&gates, &x0, hv.as_tensor(), ScanDiagonal { b, n })?;
         let perda = (&y * &pesos)?.sum_all()?;
         let gs = perda.backward()?;
-        let gx = gs.get(&xv).ok_or_else(|| candle_core::Error::Msg("sem grad x".into()))?;
-        let ga = gs.get(&av).ok_or_else(|| candle_core::Error::Msg("sem grad a".into()))?;
-        let gxv = gx.flatten_all()?.to_vec1::<f32>()?;
-        let gav = ga.flatten_all()?.to_vec1::<f32>()?;
-        // FD
+        let ga = gs.get(&gv).unwrap().flatten_all()?.to_vec1::<f32>()?;
+        let ge = gs.get(&ev).unwrap().flatten_all()?.to_vec1::<f32>()?;
+        let gh0 = gs.get(&hv).unwrap().flatten_all()?.to_vec1::<f32>()?;
+        // FD central em a, eta e h0
         let eps = 1e-3f32;
-        let f = |x: &Tensor, a: &Tensor| -> Result<f64> {
-            let y = Tensor::apply_op2(x, a, ScanDiagonal)?;
+        let f = |a: &Tensor, e: &Tensor, h0: &Tensor| -> Result<f64> {
+            let gates = Tensor::cat(&[a, e], 1)?.contiguous()?;
+            let y = Tensor::apply_op3(&gates, &x0, h0, ScanDiagonal { b, n })?;
             Ok((&y * &pesos)?.sum_all()?.to_scalar::<f32>()? as f64)
         };
-        let x0 = xv.as_tensor();
-        let a0 = av.as_tensor();
-        let x_plano = x0.flatten_all()?.to_vec1::<f32>()?;
-        let a_plano = a0.flatten_all()?.to_vec1::<f32>()?;
+        let a_plano = a.flatten_all()?.to_vec1::<f32>()?;
+        let e_plano = e.flatten_all()?.to_vec1::<f32>()?;
+        let h_plano = h00.flatten_all()?.to_vec1::<f32>()?;
         let mut erro = 0f64;
-        for idx in [3usize, 11, 17, 24, 30] {
-            let mut xp = x_plano.clone();
-            let mut xm = x_plano.clone();
-            xp[idx] += eps;
-            xm[idx] -= eps;
-            let tp = Tensor::from_vec(xp, (n, d), &dev)?;
-            let tm = Tensor::from_vec(xm, (n, d), &dev)?;
-            let fd = (f(&tp, a0)? - f(&tm, a0)?) / (2.0 * eps as f64);
-            erro = erro.max((fd - gxv[idx] as f64).abs());
-            // porta a
-            let mut ap = a_plano.clone();
-            let mut am = a_plano.clone();
-            ap[idx] += eps;
-            am[idx] -= eps;
-            let tap = Tensor::from_vec(ap, (n, d), &dev)?;
-            let tam = Tensor::from_vec(am, (n, d), &dev)?;
-            let fda = (f(x0, &tap)? - f(x0, &tam)?) / (2.0 * eps as f64);
-            erro = erro.max((fda - gav[idx] as f64).abs());
+        for idx in [3usize, 11, 17, 24, 30, 45] {
+            if idx < a_plano.len() {
+                let mut ap = a_plano.clone();
+                let mut am = a_plano.clone();
+                ap[idx] += eps;
+                am[idx] -= eps;
+                let tp = Tensor::from_vec(ap, (b * n, d), &dev)?;
+                let tm = Tensor::from_vec(am, (b * n, d), &dev)?;
+                let fd = (f(&tp, &e, &h00)? - f(&tm, &e, &h00)?) / (2.0 * eps as f64);
+                erro = erro.max((fd - ga[idx] as f64).abs());
+                let mut ep = e_plano.clone();
+                let mut em = e_plano.clone();
+                ep[idx] += eps;
+                em[idx] -= eps;
+                let tp = Tensor::from_vec(ep, (b * n, d), &dev)?;
+                let tm = Tensor::from_vec(em, (b * n, d), &dev)?;
+                let fd = (f(&a, &tp, &h00)? - f(&a, &tm, &h00)?) / (2.0 * eps as f64);
+                erro = erro.max((fd - ge[idx] as f64).abs());
+            }
         }
-        assert!(erro < 5e-3, "erro adjunto SSD = {erro}");
+        for idx in [1usize, 4, 7] {
+            let mut hp = h_plano.clone();
+            let mut hm = h_plano.clone();
+            hp[idx] += eps;
+            hm[idx] -= eps;
+            let tp = Tensor::from_vec(hp, (b, d), &dev)?;
+            let tm = Tensor::from_vec(hm, (b, d), &dev)?;
+            let fd = (f(&a, &e, &tp)? - f(&a, &e, &tm)?) / (2.0 * eps as f64);
+            erro = erro.max((fd - gh0[idx] as f64).abs());
+        }
+        assert!(erro < 5e-3, "erro adjunto SSD-Δ (a, η, h0) = {erro}");
+        Ok(())
+    }
+
+    /// Gate G8a (inteiros): a=1, η=1 ⇒ h_t = h_{t−1} + x_t EXATO para
+    /// inteiros com |soma| < 2^24 (Teo S-1(i)).
+    #[test]
+    fn gate_acumulacao_inteiros_exata() -> Result<()> {
+        let dev = Device::Cpu;
+        let (b, n, d) = (1usize, 64, 4);
+        let x: Vec<f32> = (0..n * d).map(|i| ((i % 17) as f32) * 100.0 - 800.0).collect();
+        let x = Tensor::from_vec(x, (b * n, d), &dev)?;
+        let a = Tensor::ones((b * n, d), candle_core::DType::F32, &dev)?;
+        let eta = Tensor::ones((b * n, d), candle_core::DType::F32, &dev)?;
+        let gates = Tensor::cat(&[&a, &eta], 1)?.contiguous()?;
+        let h0 = Tensor::zeros((b, d), candle_core::DType::F32, &dev)?;
+        let y = Tensor::apply_op3(&gates, &x, &h0, ScanDiagonal { b, n })?;
+        let yv = y.flatten_all()?.to_vec1::<f32>()?;
+        let xv = x.flatten_all()?.to_vec1::<f32>()?;
+        let mut soma = vec![0f32; d];
+        for i in 0..n {
+            for j in 0..d {
+                soma[j] += xv[i * d + j];
+                assert_eq!(yv[i * d + j], soma[j], "acumulação inteira exata em t={i} j={j}");
+            }
+        }
+        Ok(())
+    }
+
+    /// Gate G8b (floats): com η = tanh(ρ), erro ≤ 2e^{−2ρ}·Σ|x| + cota de
+    /// arredondamento f32 (Teo S-1(ii)/(iii)).
+    #[test]
+    fn gate_acumulacao_floats_cota() -> Result<()> {
+        let dev = Device::Cpu;
+        let (b, n, d) = (1usize, 128, 2);
+        let xv: Vec<f32> = (0..n * d).map(|i| ((i as f32) * 0.1 - 6.4).sin() * 0.37).collect();
+        let x = Tensor::from_vec(xv.clone(), (b * n, d), &dev)?;
+        let rho = 4.0f32;
+        let eta = Tensor::full(rho.tanh(), (b * n, d), &dev)?;
+        let a = Tensor::ones((b * n, d), candle_core::DType::F32, &dev)?;
+        let gates = Tensor::cat(&[&a, &eta], 1)?.contiguous()?;
+        let h0 = Tensor::zeros((b, d), candle_core::DType::F32, &dev)?;
+        let y = Tensor::apply_op3(&gates, &x, &h0, ScanDiagonal { b, n })?;
+        let yv = y.flatten_all()?.to_vec1::<f32>()?;
+        let eps_mach = 2f32.powi(-24);
+        let mut soma = vec![0f32; d];
+        let mut soma_abs = vec![0f32; d];
+        let mut erro_max = 0f64;
+        for i in 0..n {
+            for j in 0..d {
+                soma[j] += xv[i * d + j];
+                soma_abs[j] += xv[i * d + j].abs();
+                let cota = 2.0 * (-2.0 * rho).exp() as f32 * soma_abs[j]
+                    + (i as f32) * eps_mach * soma_abs[j];
+                erro_max = erro_max.max((yv[i * d + j] - soma[j]).abs() as f64);
+                assert!(
+                    (yv[i * d + j] - soma[j]).abs() <= cota,
+                    "t={i} j={j}: erro {} > cota {}",
+                    (yv[i * d + j] - soma[j]).abs(), cota
+                );
+            }
+        }
+        assert!(erro_max < 0.05, "erro de acumulação float razoável: {erro_max}");
+        Ok(())
+    }
+
+    /// Gate G3 (parte): scan completo ≡ scan incremental com estado (M4).
+    #[test]
+    fn gate_estado_transportado_equivalente() -> Result<()> {
+        crate::rng::inicializar(31415);
+        let dev = Device::Cpu;
+        let (b, n1, n2, d) = (1usize, 7, 11, 6);
+        let x = crate::rng::randn_semeado(1.0, &[b * (n1 + n2), d], &dev)?;
+        let gates_ruido = crate::rng::randn_semeado(1.0, &[b * (n1 + n2), 2 * d], &dev)?;
+        let a = candle_nn::ops::sigmoid(&gates_ruido.narrow(1, 0, d)?)?;
+        let e = gates_ruido.narrow(1, d, d)?.tanh()?;
+        let gates = Tensor::cat(&[&a, &e], 1)?.contiguous()?;
+        let h0 = Tensor::zeros((b, d), candle_core::DType::F32, &dev)?;
+        // completo
+        let y_total = Tensor::apply_op3(&gates, &x, &h0, ScanDiagonal { b, n: n1 + n2 })?;
+        // incremental: [A;B] com estado transportado
+        let xa = x.narrow(0, 0, n1)?.contiguous()?;
+        let xb = x.narrow(0, n1, n2)?.contiguous()?;
+        let ga = gates.narrow(0, 0, n1)?.contiguous()?;
+        let gb = gates.narrow(0, n1, n2)?.contiguous()?;
+        let ya = Tensor::apply_op3(&ga, &xa, &h0, ScanDiagonal { b, n: n1 })?;
+        let hA = ya.narrow(0, n1 - 1, 1)?.reshape((b, d))?.contiguous()?;
+        let yb = Tensor::apply_op3(&gb, &xb, &hA, ScanDiagonal { b, n: n2 })?;
+        // compara o segmento B
+        let ref_b = y_total.narrow(0, n1, n2)?;
+        let dif = (&yb - &ref_b)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif < 1e-6, "estado SSD transportado: dif = {dif}");
         Ok(())
     }
 }

src/telemetria.rs

@@ -3,10 +3,14 @@
 //! automatizados de todos hiper parâmetros e demais necessários para ajustes
 //! e correções e detecção de erros").
 //!
-//! Hub em Rust com: buffer por passo; exportação JSONL; detecção de
-//! aprendizado (escore composto); eventos de ajuste automático (auditáveis);
-//! eventos de erro com classificação de causa comum (diagnostico.rs);
-//! séries expostas ao Python como arrays numpy.
+//! Hub em Rust com: buffer por passo; exportação JSONL (UMA LINHA POR PASSO
+//! com todas as séries — M12: a v0.1.11 gravava apenas eventos de ajuste/erro
+//! e o artefato publicado tinha 0-1 linhas); modo append por padrão (A24: a
+//! v0.1.11 TRUNCAVA o arquivo no início e apagava o histórico do run
+//! anterior); detecção de aprendizado com LIMIARES E EVENTOS (S-05: a v0.1.11
+//! computava o escore mas nada ramificava sobre ele); eventos de ajuste
+//! automático (auditáveis); eventos de erro com classificação de causa comum
+//! (diagnostico.rs — digitação/renomeação primeiro, como pedido).
 
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -30,6 +34,14 @@ pub struct EventoErro {
     pub correcao_sugerida: String,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+pub enum EstadoAprendizado {
+    Efetivo,
+    Estagnado,
+    Regredindo,
+    SemDados,
+}
+
 #[derive(Default)]
 pub struct TelemetryHub {
     /// séries nomeadas por passo
@@ -38,22 +50,41 @@ pub struct TelemetryHub {
     pub eventos_erro: Vec<EventoErro>,
     pub caminho_jsonl: Option<String>,
     pub passo_corrente: usize,
+    /// valores do passo corrente (aguardando `fechar_passo`)
+    pendentes: BTreeMap<String, f64>,
+    /// A24: truncar o JSONL no início (default false = append)
+    pub truncar: bool,
+    /// contadores de diagnóstico (T-11)
+    pub contagem_nao_finitos: u64,
+    pub contagem_erros: u64,
+    pub contagem_ajustes: u64,
 }
 
 impl TelemetryHub {
     pub fn novo(caminho_jsonl: Option<String>) -> Self {
+        Self::novo_completo(caminho_jsonl, false)
+    }
+
+    /// A24: `truncar=false` (padrão) abre em APPEND — o histórico do run
+    /// anterior é preservado; `truncar=true` rotaciona explicitamente.
+    pub fn novo_completo(caminho_jsonl: Option<String>, truncar: bool) -> Self {
         if let Some(p) = &caminho_jsonl {
             if let Some(dir) = std::path::Path::new(p).parent() {
                 let _ = std::fs::create_dir_all(dir);
             }
-            // truncates no início da corrida
-            let _ = std::fs::File::create(p);
+            if truncar {
+                let _ = std::fs::File::create(p);
+            } else {
+                // garante que o arquivo existe sem truncar
+                let _ = std::fs::OpenOptions::new().create(true).append(true).open(p);
+            }
         }
-        TelemetryHub { caminho_jsonl, ..Default::default() }
+        TelemetryHub { caminho_jsonl, truncar, ..Default::default() }
     }
 
     pub fn registrar(&mut self, nome: &str, valor: f64) {
         self.series.entry(nome.to_string()).or_default().push((self.passo_corrente, valor));
+        self.pendentes.insert(nome.to_string(), valor);
     }
 
     pub fn registrar_multi(&mut self, pares: &[(&str, f64)]) {
@@ -62,6 +93,31 @@ impl TelemetryHub {
         }
     }
 
+    /// M12: grava UMA linha JSON com todas as séries do passo corrente e
+    /// limpa o buffer pendente. Chamar ao fim de cada passo de treino.
+    pub fn fechar_passo(&mut self) {
+        if self.pendentes.is_empty() {
+            return;
+        }
+        if let Some(p) = &self.caminho_jsonl {
+            if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(p) {
+                let mut dados = serde_json::Map::new();
+                dados.insert("passo".into(), serde_json::json!(self.passo_corrente));
+                for (k, v) in &self.pendentes {
+                    dados.insert(k.clone(), serde_json::json!(v));
+                }
+                let _ = writeln!(
+                    f,
+                    "{{\"tipo\":\"serie\",\"dados\":{}}}",
+                    serde_json::to_string(&serde_json::Value::Object(dados))
+                        .unwrap_or_default()
+                );
+                let _ = f.flush();
+            }
+        }
+        self.pendentes.clear();
+    }
+
     pub fn ajuste(&mut self, parametro: &str, de: f64, para: f64, motivo: &str) {
         let ev = EventoAjuste {
             passo: self.passo_corrente,
@@ -72,6 +128,7 @@ impl TelemetryHub {
         };
         log::info!("ajuste: {} {:.4e}→{:.4e} ({})", parametro, de, para, motivo);
         self.append_jsonl("ajuste", &ev);
+        self.contagem_ajustes += 1;
         self.eventos_ajuste.push(ev);
     }
 
@@ -92,6 +149,7 @@ impl TelemetryHub {
             causa_provavel: causa.to_string(),
             correcao_sugerida: correcao.to_string(),
         };
+        self.contagem_erros += 1;
         self.append_jsonl("erro", &ev);
         self.eventos_erro.push(ev);
     }
@@ -129,11 +187,11 @@ impl TelemetryHub {
             acc_fim = alfa * v + (1.0 - alfa) * acc_fim;
         }
         let passos = (s.len() - ini) as f64;
-        Some((acc_fim - acc_ini) / passos)
+        Some((acc_fim - acc_ini) / passos.max(1.0))
     }
 
-    /// Escore de aprendizado composto em [0,1]: sinal = inclinação negativa da
-    /// perda (EMA) + nível absoluto relativo ao inicial + saúde do codebook.
+    /// Escore de aprendizado composto em [0,1]: redução relativa + sinal da
+    /// inclinação (EMA) + saúde do codebook.
     pub fn escore_aprendizado(&self) -> f64 {
         let Some(perda) = self.series.get("perda") else { return 0.0 };
         if perda.len() < 4 { return 0.0; }
@@ -142,12 +200,57 @@ impl TelemetryHub {
         let reducao = ((p0 - pl) / p0.max(1e-9)).clamp(0.0, 1.0);
         let incl = self.inclinacao_ema("perda", 64, 0.05).unwrap_or(0.0);
         let sinal = (-incl * 1000.0).clamp(-1.0, 1.0) * 0.5 + 0.5;
-        // saúde do codebook (se medida): perplexidade relativa
         let saude = self.series.get("codebook_perplexidade_media").and_then(|s| s.last().map(|(_, v)| *v)).unwrap_or(1.0);
-        let saude_n = (saude / 16.0).clamp(0.0, 1.0); // K=64: perplexidade 16+ = saudável
+        let saude_n = (saude / 16.0).clamp(0.0, 1.0);
         0.45 * reducao + 0.35 * sinal + 0.20 * saude_n
     }
 
+    /// S-05 (v0.3.0): classificação do estado de aprendizado COM LIMIARES e
+    /// eventos auditáveis (a v0.1.11 calculava o escore sem ramificar):
+    ///   > 0,30  EFETIVO    (aprendizado em curso)
+    ///   0,15–0,30 ESTAGNADO (sem progresso suficiente)
+    ///   < 0,15  REGREDINDO (dispara evento de erro + sugere ação)
+    pub fn detectar_aprendizado(&mut self) -> EstadoAprendizado {
+        let e = self.escore_aprendizado();
+        let dados = self
+            .series
+            .get("perda")
+            .map(|s| s.len())
+            .unwrap_or(0);
+        if dados < 4 {
+            return EstadoAprendizado::SemDados;
+        }
+        let estado = if e > 0.30 {
+            EstadoAprendizado::Efetivo
+        } else if e >= 0.15 {
+            EstadoAprendizado::Estagnado
+        } else {
+            EstadoAprendizado::Regredindo
+        };
+        match estado {
+            EstadoAprendizado::Estagnado => {
+                self.append_jsonl(
+                    "aprendizado",
+                    &serde_json::json!({
+                        "passo": self.passo_corrente, "estado": "estagnado", "escore": e,
+                        "acao_sugerida": "verificar LR/clip (controlador) e a série ce_por_nivel",
+                    }),
+                );
+            }
+            EstadoAprendizado::Regredindo => {
+                self.append_jsonl(
+                    "aprendizado",
+                    &serde_json::json!({
+                        "passo": self.passo_corrente, "estado": "regredindo", "escore": e,
+                        "acao_sugerida": "reduzir LR (controlador), checar NaN (diagnostico::origem_nan) e revisar mudanças recentes (digitação?)",
+                    }),
+                );
+            }
+            _ => {}
+        }
+        estado
+    }
+
     /// Dump completo (para o relatório Python).
     pub fn dump(&self) -> serde_json::Value {
         let series: serde_json::Map<String, serde_json::Value> = self
@@ -167,6 +270,11 @@ impl TelemetryHub {
             "eventos_ajuste": self.eventos_ajuste,
             "eventos_erro": self.eventos_erro,
             "escore_aprendizado": self.escore_aprendizado(),
+            "contagens": {
+                "nao_finitos": self.contagem_nao_finitos,
+                "erros": self.contagem_erros,
+                "ajustes": self.contagem_ajustes,
+            },
         })
     }
 
@@ -178,3 +286,37 @@ impl TelemetryHub {
             .collect()
     }
 }
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    /// Gate M12/H4: `fechar_passo` grava uma linha por passo com TODAS as séries.
+    #[test]
+    fn series_vao_para_o_jsonl() {
+        let dir = std::env::temp_dir().join(format!("khtst_tel_test_{}", std::process::id()));
+        let _ = std::fs::create_dir_all(&dir);
+        let p = dir.join("tel.jsonl");
+        let p_str = p.to_str().unwrap().to_string();
+        let mut hub = TelemetryHub::novo(Some(p_str.clone()));
+        for passo in 0..3 {
+            hub.passo_corrente = passo;
+            hub.registrar_multi(&[("perda", 1.0 / (passo as f64 + 1.0)), ("lr", 3e-4)]);
+            hub.fechar_passo();
+        }
+        let conteudo = std::fs::read_to_string(&p_str).unwrap();
+        let linhas: Vec<&str> = conteudo.lines().collect();
+        assert_eq!(linhas.len(), 3, "3 passos ⇒ 3 linhas (M12): {conteudo}");
+        assert!(linhas[0].contains("\"tipo\":\"serie\""));
+        assert!(linhas[0].contains("\"perda\""));
+        assert!(linhas[0].contains("\"lr\""));
+        // A24: novo hub NÃO apaga o histórico (append)
+        let mut hub2 = TelemetryHub::novo(Some(p_str.clone()));
+        hub2.passo_corrente = 99;
+        hub2.registrar("perda", 0.5);
+        hub2.fechar_passo();
+        let conteudo2 = std::fs::read_to_string(&p_str).unwrap();
+        assert_eq!(conteudo2.lines().count(), 4, "append preserva histórico (A24)");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

src/tokenizador.rs

@@ -37,6 +37,8 @@ pub struct TokenizadorConceitos {
     pub d_lat: usize,
     pub vocab: usize,
     pub cfg_ncm_beta_commit: f64,
+    /// v0.3.0: λ_rec (T10 — lambdas.rec, default 1.0 neutro).
+    pub cfg_lambda_rec: f64,
     pub modo: ModoQuant,
 }
 
@@ -61,8 +63,9 @@ impl TokenizadorConceitos {
         }
         let modo = ModoQuant::de_str(&n.modo_quantizacao);
         let mut quants = Vec::with_capacity(l);
-        for _ in 0..l {
-            quants.push(QuantizadorNivel::novo(n.k_por_nivel, n.d_lat, modo, n.ema_codebook, &n.escala_r, dev)?);
+        for i in 0..l {
+            // M11: semente distinta por nível (ruído de Gumbel i.i.d. — Teo A.4)
+            quants.push(QuantizadorNivel::novo_nivel(n.k_por_nivel, n.d_lat, modo, n.ema_codebook, &n.escala_r, i, dev)?);
         }
         let mut proj = Vec::with_capacity(l);
         for _ in 0..l {
@@ -84,6 +87,7 @@ impl TokenizadorConceitos {
             d_lat: n.d_lat,
             vocab: m.vocab,
             cfg_ncm_beta_commit: n.beta_commit,
+            cfg_lambda_rec: if n.ativo { n.lambdas.rec.max(0.0) } else { 1.0 },
             modo,
         })
     }
@@ -99,11 +103,13 @@ impl TokenizadorConceitos {
     }
 
     /// Codificação de TREINO (fase A): relaxamento GSQ suave diferenciável.
-    /// Devolve (zhats_suaves, zs_por_nivel) para a perda e telemetria.
-    fn codificar_treino(&mut self, ids: &Tensor) -> Result<(Vec<Tensor>, Vec<Tensor>)> {
+    /// Devolve (zhats_suaves, zs_por_nivel, rs_por_nivel) para a perda e
+    /// telemetria (contração por nível — V2 do n-04).
+    fn codificar_treino(&mut self, ids: &Tensor) -> Result<(Vec<Tensor>, Vec<Tensor>, Vec<Tensor>)> {
         let dev = ids.device();
         let z = self.encoder(ids)?;
         let mut zs = Vec::with_capacity(self.niveis.len());
+        let mut rs = Vec::with_capacity(self.niveis.len());
         let mut zhats = Vec::with_capacity(self.niveis.len());
         // projeção ÚNICA d_modelo → d_lat na granularidade do nível 1 (n-02 §0);
         // a recursão residual vive INTEIRAMENTE em d_lat
@@ -124,6 +130,7 @@ impl TokenizadorConceitos {
             };
             zhat_acum = Some(zhat_l.clone());
             zhats.push(zhat_l);
+            rs.push(r_suave.clone());
             // resíduo na granularidade do próximo nível (Teo A.0/D.4)
             if i + 1 < self.niveis.len() {
                 let n_prox = self.niveis[i + 1];
@@ -132,7 +139,7 @@ impl TokenizadorConceitos {
             }
             zs.push(zp);
         }
-        Ok((zhats, zs))
+        Ok((zhats, zs, rs))
     }
 
     /// Codificação CONGELADA (fase B / inferência): códigos DUROS + ẑ dos
@@ -167,6 +174,12 @@ impl TokenizadorConceitos {
         }
     }
 
+    /// v0.3.0 — materializa distribuições por nível (verificador algébrico):
+    /// probs (b, n_ℓ, K) → (b, n_ℓ, d_lat) com Σ_k q·R·c_k.
+    pub fn materializar_probs_nivel(&self, nivel: usize, probs: &Tensor) -> Result<Tensor> {
+        self.quants[nivel].materializar_probs(probs)
+    }
+
     /// Reconstrói ẑ a partir de códigos (para corrupção κ e amostragem —
     /// o gerador nunca vê os vetores contínuos, apenas c (C.3)).
     pub fn reconstruir_de_codigos(&self, ids: &[Tensor], ate_nivel: usize, b: usize, dev: &Device) -> Result<Vec<Tensor>> {
@@ -220,7 +233,7 @@ impl TokenizadorConceitos {
     /// p(ℓ) uniforme (Teo A.2); RNG DEDICADO (pareamento — Teo 31.7).
     /// Devolve (tensor da perda total, métricas).
     pub fn perda_fase_a(&mut self, ids: &Tensor, rng: &mut StdRng) -> Result<(Tensor, PerdaFaseA)> {
-        let (zhats, zs) = self.codificar_treino(ids)?;
+        let (zhats, zs, rs) = self.codificar_treino(ids)?;
         let l = zhats.len();
         // sorteio do nível de parada (nested dropout)
         let nivel_parada = rng.gen_range(1..=l);
@@ -233,18 +246,29 @@ impl TokenizadorConceitos {
         let mut commit_t: Option<Tensor> = None;
         let mut commit = 0f64;
         for (i, zp) in zs.iter().enumerate() {
-            let (_ids, valores) = self.quants[i].quantizar_duro(zp)?;
-            let dif = (&valores - zp)?;
+            let dif = (&rs[i] - zp)?;
             let termo = dif.sqr()?.mean_all()?;
             commit += termo.to_scalar::<f32>()? as f64;
             commit_t = Some(match commit_t { Some(s) => (&s + &termo)?, None => termo });
         }
         let commit_t = commit_t.unwrap_or_else(|| ce.zeros_like().unwrap());
-        let total = (&ce + &commit_t.affine(self.cfg_ncm_beta_commit, 0.0)?)?;
+        // R-05/v0.3.0: λ_rec (lambdas.rec) pondera a reconstrução (T10)
+        let total = (&ce.affine(self.cfg_lambda_rec, 0.0)? + &commit_t.affine(self.cfg_ncm_beta_commit, 0.0)?)?;
         // precisão de reconstrução (telemetria)
         let preds = plano.argmax(D::Minus1)?;
         let acertos = preds.eq(&alvos)?.to_dtype(candle_core::DType::F32)?.sum_all()?.to_scalar::<f32>()? as f64;
         let acc = acertos / (b * n_t) as f64;
+        // contração por nível (V2 — n-04 §8): ‖z−r‖/‖z‖ relativo
+        let residuos_relativos: Vec<f64> = zs
+            .iter()
+            .zip(rs.iter())
+            .map(|(zp, rp)| {
+                let dif = (zp - rp)?;
+                let num = dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+                let den = zp.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+                Ok((num / den.max(1e-12)).sqrt())
+            })
+            .collect::<Result<Vec<_>>>()?;
         // δ_ort por nível (V9)
         let deltas: Result<Vec<f64>> = self.quants.iter().map(|q| q.delta_ort()).collect();
         let deltas = deltas?;
@@ -257,41 +281,64 @@ impl TokenizadorConceitos {
             nivel_parada,
             acc_recon: acc,
             deltas_ort: deltas,
+            residuos_relativos,
+            zhats,
         }))
     }
 
+    /// A43: invalida os caches de codebook (chamar após cada passo do otimizador).
+    pub fn invalidar_caches(&self) {
+        for q in &self.quants {
+            q.invalidar_cache();
+        }
+    }
+
     /// Decodificação LIVRE (amostragem): ẑ (b, n_ℓ, d_lat) → ids de token AR
     /// greedy. Teo A.2/B.4(b): qualquer prefixo decodifica (anytime).
-    /// O texto final é reconstruído pelo BPE no lado Python.
+    /// M17: com KV-CACHE incremental — O(n) em vez do O(n²) da v0.1.11
+    /// (que re-executava o decoder inteiro a cada passo; 24× menos MACs
+    /// para n=48).
     pub fn decodificar_livre(&self, zhat: &Tensor, max_tokens: usize) -> Result<Vec<Vec<u32>>> {
-        {
-            let dev = zhat.device();
-            let b = zhat.dim(0)?;
-            let n_total = self.mascara_causal_dec.dim(0)?;
-            let up = interp_para(zhat, n_total, dev)?;
-            let cond = self.dec_proj.fwd(&up)?;
-            let mut tokens: Vec<Vec<u32>> = (0..b).map(|_| vec![crate::tokens::BOS]).collect();
-            for passo in 1..max_tokens.min(n_total) {
-                let planos: Vec<u32> = tokens.iter().flat_map(|t| t.iter().copied()).collect();
-                let entrada = Tensor::from_vec(planos, (b, passo), dev)?;
-                let mut x = self.dec_emb.fwd(&entrada)?;
-                x = (&x + &cond.narrow(1, 0, passo)?)?;
-                for bloco in &self.dec_blocos {
-                    let mut cache = Default::default();
-                    let m = self.mascara_causal_dec.narrow(0, 0, passo)?.narrow(1, 0, passo)?.contiguous()?;
-                    x = bloco.fwd(&x, Some(&m), &mut cache, None, None)?;
-                }
-                let x = self.dec_norm.fwd(&x)?;
-                let logits = self.dec_head.fwd(&x)?;
-                let ultimo = logits.narrow(1, passo - 1, 1)?.reshape((b, self.vocab))?;
-                let preds = ultimo.argmax(D::Minus1)?;
-                let v = preds.flatten_all()?.to_vec1::<u32>()?;
-                for (i, t) in v.iter().enumerate() {
-                    tokens[i].push(*t);
-                }
+        let dev = zhat.device();
+        let b = zhat.dim(0)?;
+        let n_total = self.mascara_causal_dec.dim(0)?;
+        let up = interp_para(zhat, n_total, dev)?;
+        let cond = self.dec_proj.fwd(&up)?;
+        let mut tokens: Vec<Vec<u32>> = (0..b).map(|_| vec![crate::tokens::BOS]).collect();
+        let mut caches: Vec<crate::atencao::CacheKv> = vec![Default::default(); self.dec_blocos.len()];
+        // passo 0: alimenta BOS (1 posição)
+        let entrada = Tensor::from_vec(vec![crate::tokens::BOS as u32; b], (b, 1), dev)?;
+        let mut x = self.dec_emb.fwd(&entrada)?;
+        x = (&x + &cond.narrow(1, 0, 1)?)?;
+        let m0 = self.mascara_causal_dec.narrow(0, 0, 1)?.narrow(1, 0, 1)?.contiguous()?;
+        for (i, bloco) in self.dec_blocos.iter().enumerate() {
+            x = bloco.fwd(&x, Some(&m0), &mut caches[i], None, None)?;
+        }
+        let mut h = self.dec_head.fwd(&self.dec_norm.fwd(&x)?)?;
+        for passo in 1..max_tokens.min(n_total) {
+            let ultimo = h.narrow(1, h.dim(1)? - 1, 1)?.reshape((b, self.vocab))?;
+            let preds = ultimo.argmax(D::Minus1)?;
+            let v = preds.flatten_all()?.to_vec1::<u32>()?;
+            for (i, t) in v.iter().enumerate() {
+                tokens[i].push(*t);
             }
-            Ok(tokens)
+            if passo + 1 >= max_tokens.min(n_total) {
+                break;
+            }
+            // alimenta SÓ o token novo — cache reaproveitado (M17)
+            let entrada = Tensor::from_vec(v, (b, 1), dev)?;
+            let mut x = self.dec_emb.fwd(&entrada)?;
+            x = (&x + &cond.narrow(1, passo, 1)?)?;
+            let row = self.mascara_causal_dec
+                .narrow(0, passo, 1)?
+                .narrow(1, 0, passo + 1)?
+                .contiguous()?;
+            for (i, bloco) in self.dec_blocos.iter().enumerate() {
+                x = bloco.fwd(&x, Some(&row), &mut caches[i], None, None)?;
+            }
+            h = self.dec_head.fwd(&self.dec_norm.fwd(&x)?)?;
         }
+        Ok(tokens)
     }
 
     /// CE por prefixo (V3: monotonia do risco — Teo A.2) em modo congelado.
@@ -380,10 +427,19 @@ impl TokenizadorConceitos {
         v
     }
 
-    /// Salva estado (checkpoint atômico — Teo 35.3): índices = ordem de vars().
+    /// Salva estado (checkpoint atômico — Teo 35.3 + A20/A21): manifesto com
+    /// contagem/formas (validação no load), tmp com PID, fsync + rename +
+    /// fsync do diretório (sobrevive a queda de energia).
     pub fn salvar(&self, caminho: &str) -> Result<()> {
+        let vars = self.vars();
         let mut obj = serde_json::Map::new();
-        for (i, v) in self.vars().iter().enumerate() {
+        obj.insert("__manifesto".into(), serde_json::json!({
+            "formato": "khtst-ckpt-v2",
+            "tipo": "tokenizador",
+            "n_vars": vars.len(),
+            "formas": vars.iter().map(|v| v.as_tensor().dims()).collect::<Vec<_>>(),
+        }));
+        for (i, v) in vars.iter().enumerate() {
             let dados = v.as_tensor().flatten_all()?.to_vec1::<f32>()?;
             obj.insert(format!("v{i}"), serde_json::json!({
                 "forma": v.as_tensor().dims(),
@@ -392,11 +448,30 @@ impl TokenizadorConceitos {
         }
         let txt = serde_json::to_string(&serde_json::Value::Object(obj))
             .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
-        let tmp = format!("{caminho}.tmp");
-        std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
-        std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?;
-        Ok(())
+        salvar_atomico(caminho, &txt)
+    }
+}
+
+/// Escrita atômica durável (A21): tmp com PID → fsync → rename → fsync dir.
+pub fn salvar_atomico(caminho: &str, conteudo: &str) -> Result<()> {
+    use std::io::Write;
+    let tmp = format!("{caminho}.tmp{}", std::process::id());
+    {
+        let mut f = std::fs::File::create(&tmp)
+            .map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
+        f.write_all(conteudo.as_bytes())
+            .map_err(|e| candle_core::Error::Msg(format!("write: {e}")))?;
+        f.sync_all()
+            .map_err(|e| candle_core::Error::Msg(format!("fsync: {e}")))?;
+    }
+    std::fs::rename(&tmp, caminho)
+        .map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?;
+    if let Some(dir) = std::path::Path::new(caminho).parent() {
+        if let Ok(d) = std::fs::File::open(dir) {
+            let _ = d.sync_all();
+        }
     }
+    Ok(())
 }
 
 pub struct PerdaFaseA {
@@ -405,6 +480,10 @@ pub struct PerdaFaseA {
     pub nivel_parada: usize,
     pub acc_recon: f64,
     pub deltas_ort: Vec<f64>,
+    /// v0.3.0 (V2 — n-04 §8): contração por nível ‖z−r‖/‖z‖.
+    pub residuos_relativos: Vec<f64>,
+    /// reconstruções cumulativas (verificador algébrico / telemetria).
+    pub zhats: Vec<Tensor>,
 }
 
 /// Máscara causal aditiva (n, n): 0 permitido, MIN bloqueado.

src/tokens.rs

@@ -13,9 +13,37 @@ pub const UNK: u32 = 3;
 pub const BASE_BYTES: u32 = 4;
 const ESPECIAIS: [&str; 4] = ["<pad>", "<bos>", "<eos>", "<unk>"];
 
+/// v0.3.0 (bug encontrado pelo roundtrip ESTRITO A11): a v0.1.11 criava o
+/// vocab inicial com `String::from_utf8_lossy(&[byte])` — bytes 128-255
+/// viravam U+FFFD (3 bytes!) e o DECODE de qualquer caractere acentuado
+/// produzia lixo ("células" → "c￿lulas"). O teste tautológico da v0.1.11
+/// (`or len(rt) > 50`) escondia o defeito.
+/// Correção: mapeamento reversível byte↔char printable (estilo GPT-2):
+/// bytes 33-126, 161-172, 174-255 mapeiam para si; os demais (controles,
+/// espaço, 127-160, 173) mapeiam para U+0100+n — todos chars UTF-8 válidos.
+pub fn byte_para_char(b: u8) -> char {
+    match b {
+        33..=126 | 161..=172 | 174..=255 => b as char,
+        _ => char::from_u32(256 + b as u32).unwrap_or(chr_substituto(b)),
+    }
+}
+
+/// Reverso de `byte_para_char`.
+fn chr_substituto(b: u8) -> char { byte_para_char_fallback(b) }
+fn byte_para_char_fallback(b: u8) -> char { if b >= 33 { b as char } else { '\u{FFFD}' } }
+
+pub fn char_para_byte(c: char) -> Option<u8> {
+    let cp = c as u32;
+    match cp {
+        33..=126 | 161..=172 | 174..=255 => Some(cp as u8),
+        256..=511 => Some((cp - 256) as u8),
+        _ => None,
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct Bpe {
-    /// token por id (string; bytes crus para os 256 iniciais)
+    /// token por id (string; 1 CHAR mapeado para cada um dos 256 bytes iniciais)
     pub vocab: Vec<String>,
     /// merges na ordem de aprendizado: (id_a, id_b) -> id_novo implícito = 260+índice
     pub merges: Vec<(u32, u32)>,
@@ -32,7 +60,7 @@ impl Bpe {
             b.vocab.push(s.to_string());
         }
         for i in 0..256u32 {
-            let s = String::from_utf8_lossy(&[i as u8]).to_string();
+            let s = byte_para_char(i as u8).to_string();
             b.id_por_token.insert(s.clone(), BASE_BYTES + i);
             b.vocab.push(s);
         }
@@ -201,20 +229,35 @@ impl Bpe {
     }
 
     pub fn decodificar(&self, ids: &[u32]) -> String {
-        let mut out = String::new();
+        // v0.3.0: acumula CHARS mapeados e reconverte byte-a-byte — o
+        // roundtrip é EXATO para qualquer UTF-8 válido (A11).
+        let mut chars: Vec<char> = vec![];
         for &i in ids {
             match i {
                 PAD | BOS | EOS => {}
+                UNK => chars.push('\u{FFFD}'),
                 _ => {
                     if let Some(s) = self.vocab.get(i as usize) {
                         if !ESPECIAIS.contains(&s.as_str()) {
-                            out.push_str(s);
+                            chars.extend(s.chars());
                         }
                     }
                 }
             }
         }
-        out.trim().to_string()
+        let mut bytes = Vec::with_capacity(chars.len());
+        for c in chars {
+            match char_para_byte(c) {
+                Some(b) => bytes.push(b),
+                None => {
+                    // char de merge multibyte válido em UTF-8: só possível se
+                    // o vocab foi adulterado; preserva como UTF-8 direto
+                    let mut buf = [0u8; 4];
+                    bytes.extend_from_slice(c.encode_utf8(&mut buf).as_bytes());
+                }
+            }
+        }
+        String::from_utf8_lossy(&bytes).trim().to_string()
     }
 
     pub fn para_json(&self) -> serde_json::Value {
@@ -261,4 +304,26 @@ mod testes {
         assert_eq!(texto, "o gato come o peixe");
         assert!(b.n_vocab() >= 260);
     }
+
+    /// A11 (v0.3.0): roundtrip ESTRITO com acentos/UTF-8 multibyte — o teste
+    /// que a v0.1.11 não tinha (e falhava silenciosamente: "células" → lixo).
+    #[test]
+    fn roundtrip_exato_utf8() {
+        let textos: Vec<String> = [
+            "A célula нервosa possui axônios mielinizados",
+            "Análise química de compostos orgânicos — íons e áçúcares",
+            "João avançou três quilômetros em direção àrepública",
+        ].iter().map(|s| s.to_string()).collect();
+        let mut b = Bpe::treinar(&textos, 400);
+        for t in &textos {
+            let ids = b.codificar(t);
+            let rt = b.decodificar(&ids);
+            assert_eq!(rt, t.trim(), "roundtrip deve ser EXATO: {t}");
+        }
+        // serialização também preserva
+        let j = b.para_json();
+        let mut b2 = Bpe::de_json(&j).unwrap();
+        let ids = b2.codificar(&textos[0]);
+        assert_eq!(b2.decodificar(&ids), textos[0].trim());
+    }
 }

src/treino.rs

@@ -1,11 +1,25 @@
 //! Loops de treino (fases A e B — n-04 §4) com otimizador AdamW MANUAL
 //! (controle total para PCGrad multi-perda, clip global e LR dinâmico do
-//! controlador), telemetria completa, callback Python periódico e
-//! checkpoints atômicos (Teo 35.3).
+//! controlador), telemetria completa (M12: uma linha JSONL por passo),
+//! callback Python periódico, checkpoints atômicos com manifesto (A20/A21) e
+//! RETOMADA (v0.3.0: o ambiente pode encerrar processos em background sem
+//! erro/OOM — o estado do otimizador é salvo periodicamente).
+//!
+//! ## Correções v0.2.0/v0.3.0 aplicadas aqui
+//! - **M8**: PCGrad projeta g_i contra os gradientes ORIGINAIS g_j (a v0.1.11
+//!   mutava g_j em lugar e decidia ⟨g_i,g_j⟩ com valores obsoletos);
+//! - **M10**: passo com perda não finita é DESCARTADO ANTES de ser aplicado
+//!   (a v0.1.11 aplicava pesos NaN e gravava checkpoint com NaN);
+//! - **A18**: fases A e B usam sementes distintas (31_7 ^ 0xA / ^ 0xB);
+//! - **A19**: RNG global semeado (reprodutibilidade bit-a-bit);
+//! - **A35**: AdamW paralelizado com rayon sobre as variáveis;
+//! - **S-05**: detecção de aprendizado com limiares e eventos;
+//! - **S-08/S-09**: ε (cobertura C.3(ii)) e λ (hipergradiente 29.2) integrados;
+//! - **Teo G-1**: L_alg (verificador algébrico) como 3ª perda do PCGrad.
 
 use candle_core::{Device, Result, Tensor, Var};
-use candle_nn::loss::cross_entropy;
 use rand::prelude::*;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 use crate::config::ConfigKhtst;
@@ -13,13 +27,14 @@ use crate::controlador::Controlador;
 use crate::gerador::GeradorConceitos;
 use crate::memoria::{JepaLatente, SomConceitos};
 use crate::mascaras::interp_para;
-use crate::telemetria::TelemetryHub;
+use crate::telemetria::{EstadoAprendizado, TelemetryHub};
 use crate::tokenizador::TokenizadorConceitos;
 
-/// AdamW manual (estado por índice de variável; grads achatados).
+/// AdamW manual com estado por índice de variável (v0.3.0: Vec alinhado às
+/// vars — serializável para RETOMADA; passo paralelizado com rayon — A35).
 pub struct AdamWManual {
-    pub m: HashMap<usize, Vec<f32>>,
-    pub v: HashMap<usize, Vec<f32>>,
+    pub m: Vec<Vec<f32>>,
+    pub v: Vec<Vec<f32>>,
     pub t: usize,
     pub lr: f64,
     pub beta1: f64,
@@ -31,7 +46,18 @@ pub struct AdamWManual {
 
 impl AdamWManual {
     pub fn novo(vars: Vec<Var>, lr: f64, wd: f64) -> Self {
-        AdamWManual { m: HashMap::new(), v: HashMap::new(), t: 0, lr, beta1: 0.9, beta2: 0.999, eps: 1e-8, wd, vars }
+        let n = vars.len();
+        AdamWManual {
+            m: vec![Vec::new(); n],
+            v: vec![Vec::new(); n],
+            t: 0,
+            lr,
+            beta1: 0.9,
+            beta2: 0.999,
+            eps: 1e-8,
+            wd,
+            vars,
+        }
     }
 
     pub fn set_lr(&mut self, lr: f64) {
@@ -39,31 +65,56 @@ impl AdamWManual {
     }
 
     /// Um passo. `grads`: por variável, gradiente ACHATADO (None = zero).
+    /// M10: o CHAMADOR descarta passos não finitos ANTES de chegar aqui.
     pub fn passo(&mut self, grads: Vec<Option<Vec<f32>>>) {
         self.t += 1;
         let bc1 = 1.0 - self.beta1.powi(self.t as i32);
         let bc2 = 1.0 - self.beta2.powi(self.t as i32);
-        for (i, var) in self.vars.iter().enumerate() {
-            let Some(g) = grads.get(i).cloned().flatten() else { continue };
-            let n = g.len();
-            let m = self.m.entry(i).or_insert(vec![0f32; n]);
-            let v = self.v.entry(i).or_insert(vec![0f32; n]);
-            let dados = var.as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
-            let mut novos = vec![0f32; n];
-            for j in 0..n {
-                m[j] = self.beta1 as f32 * m[j] + (1.0 - self.beta1 as f32) * g[j];
-                v[j] = self.beta2 as f32 * v[j] + (1.0 - self.beta2 as f32) * g[j] * g[j];
-                let mh = m[j] / bc1 as f32;
-                let vh = v[j] / bc2 as f32;
-                // AdamW: decaimento desacoplado
-                novos[j] = dados[j] - (self.lr as f32) * (mh / (vh.sqrt() + self.eps as f32) + self.wd as f32 * dados[j]);
+        let lr = self.lr as f32;
+        let wd = self.wd as f32;
+        let b1 = self.beta1 as f32;
+        let b2 = self.beta2 as f32;
+        let eps = self.eps as f32;
+        // garante estado alinhado
+        for (i, g) in grads.iter().enumerate() {
+            if let Some(g) = g {
+                if self.m.get(i).map(|m| m.len()) != Some(g.len()) {
+                    let n = g.len();
+                    if i < self.m.len() {
+                        self.m[i] = vec![0f32; n];
+                        self.v[i] = vec![0f32; n];
+                    }
+                }
             }
-            let forma = var.as_tensor().shape();
-            let dev = var.as_tensor().device();
-            let novo_t = Tensor::from_vec(novos, forma.clone(), dev).unwrap()
-                .reshape(forma).unwrap();
-            let _ = var.set(&novo_t);
         }
+        let Self { vars, m, v, .. } = self;
+        use rayon::prelude::*;
+        grads
+            .into_par_iter()
+            .zip(m.par_iter_mut())
+            .zip(v.par_iter_mut())
+            .zip(vars.par_iter())
+            .for_each(|(((g, mm), vv), var)| {
+                let Some(g) = g else { return };
+                if mm.len() != g.len() {
+                    *mm = vec![0f32; g.len()];
+                    *vv = vec![0f32; g.len()];
+                }
+                let dados = var.as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+                let mut novos = vec![0f32; g.len()];
+                for j in 0..g.len() {
+                    mm[j] = b1 * mm[j] + (1.0 - b1) * g[j];
+                    vv[j] = b2 * vv[j] + (1.0 - b2) * g[j] * g[j];
+                    let mh = mm[j] / bc1 as f32;
+                    let vh = vv[j] / bc2 as f32;
+                    // AdamW: decaimento desacoplado
+                    novos[j] = dados[j] - lr * (mh / (vh.sqrt() + eps) + wd * dados[j]);
+                }
+                let forma = var.as_tensor().shape();
+                let dev = var.as_tensor().device();
+                let novo_t = Tensor::from_vec(novos, forma.clone(), dev).unwrap().reshape(forma).unwrap();
+                let _ = var.set(&novo_t);
+            });
     }
 
     /// Norma global de gradiente (para clip e telemetria).
@@ -91,6 +142,41 @@ impl AdamWManual {
     }
 }
 
+/// Estado serializável do treino (RETOMADA — A22 + proteção contra kill
+/// do background: modelo + otimizador + controlador + passo).
+#[derive(Serialize, Deserialize)]
+pub struct EstadoTreino {
+    pub passo: usize,
+    pub m: Vec<Vec<f32>>,
+    pub v: Vec<Vec<f32>>,
+    pub t: usize,
+    pub multiplicador_lr: f64,
+    pub minimo_ema: f64,
+    pub passos_sem_melhora: usize,
+    pub clip: f64,
+    pub epsilon: f64,
+    pub lambda: f64,
+    /// fase B: variáveis do JEPA (índice alinhado) + protótipos do SOM
+    pub jepa_vars: Option<Vec<Vec<f32>>>,
+    pub som_prototipos: Option<Vec<f32>>,
+    pub som_lado: Option<usize>,
+}
+
+impl EstadoTreino {
+    pub fn salvar(caminho: &str, est: &EstadoTreino) -> Result<()> {
+        let txt = serde_json::to_string(est)
+            .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
+        crate::tokenizador::salvar_atomico(caminho, &txt)
+    }
+
+    pub fn carregar(caminho: &str) -> Result<EstadoTreino> {
+        let txt = std::fs::read_to_string(caminho)
+            .map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
+        serde_json::from_str(&txt)
+            .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))
+    }
+}
+
 /// Extrai grads achatados do GradStore na ordem de `vars`.
 pub fn grads_achatados(perda: &Tensor, vars: &[Var]) -> Result<Vec<Option<Vec<f32>>>> {
     let gs = perda.backward()?;
@@ -105,18 +191,26 @@ pub fn grads_achatados(perda: &Tensor, vars: &[Var]) -> Result<Vec<Option<Vec<f3
 }
 
 /// PCGrad multi-perda sobre grads achatados (Teo D.7 — projeção por pares).
-pub fn pcgrad_achatado(mut grads: Vec<Vec<Option<Vec<f32>>>>) -> Vec<Option<Vec<f32>>> {
+/// **M8 (v0.2.0)**: a projeção da perda i usa os gradientes ORIGINAIS das
+/// demais perdas (Yu et al. 2020, Algorithm 1) — a v0.1.11 mutava `grads[j]`
+/// em lugar, e a decisão ⟨g_i,g_j⟩ < 0 era tomada com o g_j JÁ PROJETADO
+/// (valor obsoleto), podendo reintroduzir conflito.
+pub fn pcgrad_achatado(grads: Vec<Vec<Option<Vec<f32>>>>) -> Vec<Option<Vec<f32>>> {
     let n_perdas = grads.len();
     let n_vars = grads[0].len();
+    let originais = grads.clone(); // M8: fontes imutáveis
     let mut saida: Vec<Option<Vec<f32>>> = vec![None; n_vars];
     for i in 0..n_perdas {
-        // projeta g_i contra cada g_j conflitante
+        let mut gi = originais[i].clone();
         for j in 0..n_perdas {
-            if i == j { continue; }
+            if i == j {
+                continue;
+            }
+            // ⟨g_i_corrente, g_j_original⟩ — recalculado a cada par (M8)
             let mut ip = 0f64;
             let mut nj = 0f64;
             for v in 0..n_vars {
-                if let (Some(a), Some(b)) = (&grads[i][v], &grads[j][v]) {
+                if let (Some(a), Some(b)) = (&gi[v], &originais[j][v]) {
                     for k in 0..a.len().min(b.len()) {
                         ip += a[k] as f64 * b[k] as f64;
                         nj += b[k] as f64 * b[k] as f64;
@@ -126,8 +220,8 @@ pub fn pcgrad_achatado(mut grads: Vec<Vec<Option<Vec<f32>>>>) -> Vec<Option<Vec<
             if ip < 0.0 && nj > 1e-12 {
                 let alfa = (ip / nj) as f32;
                 for v in 0..n_vars {
-                    if let Some(bv) = grads[j][v].clone() {
-                        if let Some(a) = &mut grads[i][v] {
+                    if let Some(bv) = &originais[j][v] {
+                        if let Some(a) = &mut gi[v] {
                             for k in 0..a.len().min(bv.len()) {
                                 a[k] -= alfa * bv[k];
                             }
@@ -137,7 +231,7 @@ pub fn pcgrad_achatado(mut grads: Vec<Vec<Option<Vec<f32>>>>) -> Vec<Option<Vec<
             }
         }
         for v in 0..n_vars {
-            if let Some(a) = &grads[i][v] {
+            if let Some(a) = &gi[v] {
                 let media: Vec<f32> = a.iter().map(|x| x / n_perdas as f32).collect();
                 saida[v] = Some(match &saida[v] {
                     Some(s) => s.iter().zip(media.iter()).map(|(x, y)| x + y).collect(),
@@ -155,13 +249,12 @@ pub struct DadosTreino {
 
 impl DadosTreino {
     pub fn novo(sequencias: Vec<Vec<u32>>, n: usize) -> Self {
+        // A15: apenas sequências COMPRIDAS o suficiente viram janelas (a
+        // v0.1.11 aceitava >= 8 e preenchia com PAD — até 96% de padding)
         let seqs = sequencias
             .into_iter()
-            .filter(|s| s.len() >= 8)
+            .filter(|s| s.len() >= n)
             .map(|mut s| {
-                while s.len() < n {
-                    s.push(crate::tokens::PAD);
-                }
                 s.truncate(n);
                 s
             })
@@ -206,9 +299,12 @@ pub struct ResumoFase {
     pub perplexidade_codebook: f64,
     pub monotonia_prefixo: f64,
     pub escore_aprendizado: f64,
+    pub residuo_algebrico: f64,
+    pub estado_aprendizado: String,
 }
 
 /// FASE A — tokenizador (n-04 §4): nested dropout + commitment + GSQ + RCO.
+/// v0.3.0: `caminho_checkpoint` + retomada automática via `.estado.json`.
 pub fn treinar_fase_a(
     cfg: &ConfigKhtst,
     dados: &DadosTreino,
@@ -216,22 +312,52 @@ pub fn treinar_fase_a(
     callback: &CallbackPy,
     caminho_checkpoint: Option<&str>,
     teto_seg: Option<f64>,
+    retomar: bool,
 ) -> Result<ResumoFase> {
     let dev = Device::Cpu;
     let inicio = std::time::Instant::now();
+    crate::rng::inicializar(cfg.treino.semente ^ 0xA); // A18: semente própria da fase A
     let mut tok = TokenizadorConceitos::novo(cfg, &dev)?;
-    let vars = tok.vars();
+    let mut vars = tok.vars();
     let mut opt = AdamWManual::novo(vars.clone(), cfg.treino.lr, cfg.treino.peso_decaimento);
     let mut ctrl = Controlador::novo(cfg.treino.lr, cfg.treino.aquecimento, cfg.treino.passos_fase_a, cfg.telemetria.paciencia_plateau, cfg.telemetria.fator_lr_plateau, cfg.ncm.lambdas.rho_ancora);
-    let mut rng = StdRng::seed_from_u64(31_7); // RNG dedicado (Teo 31.7)
+    let mut rng = StdRng::seed_from_u64(cfg.treino.semente ^ 0xA);
+    let mut passo_inicial = 0usize;
+    // RETOMADA: carrega modelo + estado do otimizador se disponíveis
+    if let Some(c) = caminho_checkpoint {
+        if retomar {
+            let est_path = format!("{c}.estado.json");
+            if std::path::Path::new(&est_path).exists() && std::path::Path::new(c).exists() {
+                // fase A: o checkpoint contém TODAS as vars do tokenizador
+                carregar_vars_do_checkpoint(&mut vars, c)?;
+                let est = EstadoTreino::carregar(&est_path)?;
+                opt.m = est.m;
+                opt.v = est.v;
+                opt.t = est.t;
+                ctrl.multiplicador = est.multiplicador_lr;
+                ctrl.minimo_ema = est.minimo_ema;
+                ctrl.passos_sem_melhora = est.passos_sem_melhora;
+                ctrl.clip = est.clip;
+                ctrl.epsilon_corrupcao = est.epsilon;
+                passo_inicial = est.passo;
+                hub.ajuste("retomada", 0.0, passo_inicial as f64, &format!("fase A retomada do passo {passo_inicial}"));
+            }
+        }
+    }
+    // perda inicial comparável (R-05: MESMA métrica nas duas pontas):
+    // CE+commit num lote FIXO com RNG dedicado
+    let lote_fixo = {
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1A7);
+        dados.lote(cfg.treino.lote, &mut r_fixo, &dev)?
+    };
     let perda_inicial = {
-        let ids = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
-        let (p, _) = tok.perda_fase_a(&ids, &mut rng)?;
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1A7);
+        let (p, _) = tok.perda_fase_a(&lote_fixo, &mut r_fixo)?;
         p.to_scalar::<f32>()? as f64
     };
     let a_cada = cfg.treino.telemetria_a_cada.max(1);
-    let mut passos_feitos = 0usize;
-    'laco_a: for passo in 0..cfg.treino.passos_fase_a {
+    let mut passos_feitos = passo_inicial;
+    'laco_a: for passo in passo_inicial..cfg.treino.passos_fase_a {
         hub.passo_corrente = passo;
         if let Some(t) = teto_seg {
             if inicio.elapsed().as_secs_f64() > t {
@@ -240,8 +366,14 @@ pub fn treinar_fase_a(
             }
         }
         let ids = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
-        let (perda_t, _m) = tok.perda_fase_a(&ids, &mut rng)?;
+        let (perda_t, m) = tok.perda_fase_a(&ids, &mut rng)?;
         let perda = perda_t.to_scalar::<f32>()? as f64;
+        // M10: perda não finita ⇒ DESCARTA o passo ANTES de aplicar (e para)
+        if !perda.is_finite() {
+            hub.contagem_nao_finitos += 1;
+            hub.erro("fase_a", &format!("perda não finita no passo {passo} — passo descartado (M10)"));
+            break 'laco_a;
+        }
         // agenda τ (Teo 30.6)
         tok.agendar_tau(passo, cfg.ncm.gsq.tau0, cfg.ncm.gsq.tau_min, cfg.ncm.gsq.t_alvo);
         // LR + clip do controlador (ajustes AUTOMÁTICOS — auditados)
@@ -253,41 +385,61 @@ pub fn treinar_fase_a(
         let teto = ctrl.clip_corrente(hub);
         AdamWManual::clipar(&mut grads, teto);
         opt.passo(grads);
+        tok.invalidar_caches(); // A43: codebook do novo passo
         // EMA do codebook (modo ste_ema)
         if cfg.ncm.modo_quantizacao == "ste_ema" {
             let cod = tok.codificar_congelado(&ids)?;
             tok.atualizar_ema_codebook(&cod.ids)?;
         }
-        // telemetria
-        hub.registrar_multi(&[
-            ("perda", perda),
-            ("lr", lr),
-            ("norma_grad", norma),
-        ]);
+        // telemetria: séries por passo + métricas do codificador
+        hub.registrar("perda", perda);
+        hub.registrar("rec", m.rec);
+        hub.registrar("commit", m.commit);
+        hub.registrar("lr", lr);
+        hub.registrar("norma_grad", norma);
+        for (i, &rr) in m.residuos_relativos.iter().enumerate() {
+            hub.registrar(&format!("contração_nivel_{i}"), rr);
+        }
         if passo % a_cada == 0 || passo == cfg.treino.passos_fase_a - 1 {
             let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
             let dort: f64 = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
+            let residuo = GeradorConceitos::residuo_algebrico(&m.zhats, &dev)?;
             hub.registrar_multi(&[
                 ("codebook_perplexidade_media", perp),
                 ("delta_ort_max", dort),
+                ("residuo_recomposicao", residuo),
                 ("escore_aprendizado", hub.escore_aprendizado()),
             ]);
+            // S-05: detecção de aprendizado com limiares + eventos
+            let estado = hub.detectar_aprendizado();
             if cfg.telemetria.deteccao_aprendizado {
                 let snap = serde_json::json!({
                     "fase": "A", "passo": passo, "perda": perda, "lr": lr,
                     "codebook_perplexidade_media": perp, "delta_ort_max": dort,
+                    "residuo_recomposicao": residuo,
                     "escore": hub.escore_aprendizado(),
+                    "estado_aprendizado": format!("{estado:?}"),
                 });
                 chamar_callback(callback, &snap);
             }
+            // checkpoint periódico (proteção contra kill em background)
+            if let Some(c) = caminho_checkpoint {
+                if cfg.treino.checkpoint_a_cada > 0 && passo % cfg.treino.checkpoint_a_cada == 0 && passo > passo_inicial {
+                    tok.salvar(c)?;
+                    salvar_estado_a(c, &opt, &ctrl, passo)?;
+                }
+            }
         }
-        if !perda.is_finite() {
-            hub.erro("fase_a", &format!("perda não finita no passo {passo}"));
-            break;
-        }
+        hub.fechar_passo(); // M12: uma linha JSONL por passo
     }
-    if passos_feitos == 0 { passos_feitos = cfg.treino.passos_fase_a; }
-    // avaliação final: monotonia de prefixo (V3) + perplexidade
+    if passos_feitos == passo_inicial { passos_feitos = cfg.treino.passos_fase_a; }
+    // avaliação final: monotonia de prefixo (V3) + perplexidade + perda FINAL
+    // comparável (R-05: mesmo lote fixo, mesmo RNG)
+    let perda_final = {
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1A7);
+        let (p, _) = tok.perda_fase_a(&lote_fixo, &mut r_fixo)?;
+        p.to_scalar::<f32>()? as f64
+    };
     let ids_val = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
     let ces_prefixo = tok.ce_por_prefixo(&ids_val)?;
     let mut pares_ok = 0usize;
@@ -299,14 +451,18 @@ pub fn treinar_fase_a(
         }
     }
     let monotonia = pares_ok as f64 / pares.max(1) as f64;
-    let perda_final = ces_prefixo.last().copied().unwrap_or(f64::NAN);
     let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
     let dort = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
     let acc = { let (_, m) = tok.perda_fase_a(&ids_val, &mut rng)?; m.acc_recon };
+    let zhats_val = tok.codificar_congelado(&ids_val)?.zhats;
+    let residuo = GeradorConceitos::residuo_algebrico(&zhats_val, &dev)?;
     if let Some(c) = caminho_checkpoint {
         tok.salvar(c)?;
+        salvar_estado_a(c, &opt, &ctrl, passos_feitos)?;
     }
     hub.registrar("passos_feitos", passos_feitos as f64);
+    hub.fechar_passo();
+    let estado = hub.detectar_aprendizado();
     Ok(ResumoFase {
         passos: passos_feitos,
         perda_final,
@@ -316,12 +472,35 @@ pub fn treinar_fase_a(
         perplexidade_codebook: perp,
         monotonia_prefixo: monotonia,
         escore_aprendizado: hub.escore_aprendizado(),
+        residuo_algebrico: residuo,
+        estado_aprendizado: format!("{estado:?}"),
     })
 }
 
+fn salvar_estado_a(caminho: &str, opt: &AdamWManual, ctrl: &Controlador, passo: usize) -> Result<()> {
+    let est = EstadoTreino {
+        passo,
+        m: opt.m.clone(),
+        v: opt.v.clone(),
+        t: opt.t,
+        multiplicador_lr: ctrl.multiplicador,
+        minimo_ema: ctrl.minimo_ema,
+        passos_sem_melhora: ctrl.passos_sem_melhora,
+        clip: ctrl.clip,
+        epsilon: ctrl.epsilon_corrupcao,
+        lambda: ctrl.lambda_ancora.lambda,
+        jepa_vars: None,
+        som_prototipos: None,
+        som_lado: None,
+    };
+    EstadoTreino::salvar(&format!("{caminho}.estado.json"), &est)
+}
+
 /// FASE B — gerador (n-04 §4): MLE exato sobre hierarquias congeladas (B.1),
-/// corrupção κ + dropout CFG (C.3/D.2), MTP auxiliar (D.6), JEPA latente e
-/// PCGrad entre as perdas (D.7).
+/// corrupção κ + dropout CFG (C.3/D.2), MTP auxiliar (D.6), JEPA latente,
+/// verificador algébrico (Teo G-1) e PCGrad entre as perdas (D.7).
+/// v0.3.0: JEPA e SOM fazem parte do checkpoint de retomada (A22).
+#[allow(clippy::too_many_arguments)]
 pub fn treinar_fase_b(
     cfg: &ConfigKhtst,
     tok: &TokenizadorConceitos,
@@ -330,27 +509,72 @@ pub fn treinar_fase_b(
     callback: &CallbackPy,
     caminho_checkpoint: Option<&str>,
     teto_seg: Option<f64>,
+    retomar: bool,
 ) -> Result<ResumoFase> {
     let dev = Device::Cpu;
     let inicio = std::time::Instant::now();
+    crate::rng::inicializar(cfg.treino.semente ^ 0xB); // A18: semente própria da fase B
     let mut ger = GeradorConceitos::novo(cfg, &dev)?;
-    let jepa = JepaLatente::novo(cfg.ncm.d_lat, &dev)?;
+    let mut jepa = JepaLatente::novo(cfg.ncm.d_lat, &dev)?;
     let mut som = SomConceitos::novo(cfg.memoria.som_lado, cfg.ncm.d_lat, &dev)?;
     let mut vars = ger.vars();
     vars.extend(jepa.vars());
+    let n_vars_ger = ger.vars().len();
     let mut opt = AdamWManual::novo(vars.clone(), cfg.treino.lr * 0.7, cfg.treino.peso_decaimento);
     let mut ctrl = Controlador::novo(cfg.treino.lr * 0.7, cfg.treino.aquecimento, cfg.treino.passos_fase_b, cfg.telemetria.paciencia_plateau, cfg.telemetria.fator_lr_plateau, cfg.ncm.lambdas.rho_ancora);
-    let mut rng = StdRng::seed_from_u64(31_7);
+    let mut rng = StdRng::seed_from_u64(cfg.treino.semente ^ 0xB);
+    let mut passo_inicial = 0usize;
+    if let Some(c) = caminho_checkpoint {
+        if retomar {
+            let est_path = format!("{c}.estado.json");
+            if std::path::Path::new(&est_path).exists() && std::path::Path::new(c).exists() {
+                // o checkpoint contém APENAS as vars do GERADOR; o JEPA vem
+                // do .estado.json (jepa_vars) — não misturar as listas
+                {
+                    let mut ger_vars = ger.vars();
+                    carregar_vars_do_checkpoint(&mut ger_vars, c)?;
+                }
+                let est = EstadoTreino::carregar(&est_path)?;
+                opt.m = est.m;
+                opt.v = est.v;
+                opt.t = est.t;
+                ctrl.multiplicador = est.multiplicador_lr;
+                ctrl.minimo_ema = est.minimo_ema;
+                ctrl.passos_sem_melhora = est.passos_sem_melhora;
+                ctrl.clip = est.clip;
+                ctrl.epsilon_corrupcao = est.epsilon;
+                if let Some(jv) = &est.jepa_vars {
+                    let jvars = jepa.vars();
+                    for (i, val) in jv.iter().enumerate() {
+                        if i < jvars.len() {
+                            let forma = jvars[i].as_tensor().shape();
+                            let t = Tensor::from_vec(val.clone(), forma.clone(), &dev)?.reshape(forma)?;
+                            jvars[i].set(&t)?;
+                        }
+                    }
+                }
+                if let (Some(prot), Some(lado)) = (&est.som_prototipos, est.som_lado) {
+                    som.restaurar(prot, lado)?;
+                }
+                passo_inicial = est.passo;
+                hub.ajuste("retomada", 0.0, passo_inicial as f64, &format!("fase B retomada do passo {passo_inicial}"));
+            }
+        }
+    }
     let a_cada = cfg.treino.telemetria_a_cada.max(1);
-    let lambda_jepa = cfg.memoria.lambda_jepa;
+    // lote fixo para métricas comparáveis (R-05)
+    let lote_fixo = {
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1B5);
+        dados.lote(cfg.treino.lote, &mut r_fixo, &dev)?
+    };
     let perda_inicial = {
-        let ids = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
-        let cod = tok.codificar_congelado(&ids)?;
-        let s = ger.perda_treino(tok, &cod.ids, &mut rng)?;
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1B5);
+        let cod = tok.codificar_congelado(&lote_fixo)?;
+        let s = ger.perda_treino(tok, &cod.ids, &mut r_fixo)?;
         s.ce_por_nivel.iter().sum::<f64>() / s.ce_por_nivel.len() as f64
     };
-    let mut passos_feitos = 0usize;
-    'laco_b: for passo in 0..cfg.treino.passos_fase_b {
+    let mut passos_feitos = passo_inicial;
+    'laco_b: for passo in passo_inicial..cfg.treino.passos_fase_b {
         hub.passo_corrente = passo;
         if let Some(t) = teto_seg {
             if inicio.elapsed().as_secs_f64() > t {
@@ -362,8 +586,18 @@ pub fn treinar_fase_b(
         let cod = tok.codificar_congelado(&ids)?;
         let saida = ger.perda_treino(tok, &cod.ids, &mut rng)?;
         let ce = saida.ce_por_nivel.iter().sum::<f64>() / saida.ce_por_nivel.len() as f64;
-        // JEPA latente (alvo com stop-grad — contrato doc 30)
-        let perda_jepa_t = {
+        // M10: descarta passo não finito ANTES de aplicar
+        if !ce.is_finite() {
+            hub.contagem_nao_finitos += 1;
+            hub.erro("fase_b", &format!("CE não finita no passo {passo} — passo descartado (M10)"));
+            break 'laco_b;
+        }
+        // JEPA latente (alvo com stop-grad — contrato doc 30) com λ DINÂMICO
+        // (S-09: hipergradiente exato do Teo 29.2, integrado v0.3.0):
+        // λ_total = λ_base + λ_âncora(t), com λ_âncora adaptado pelo
+        // hipergradiente exato e clamped em [0, 2].
+        let lambda_jepa = (cfg.memoria.lambda_jepa + ctrl.lambda_ancora.lambda).clamp(0.0, 2.0);
+        let (perda_jepa_t, jepa_val) = {
             let b = ids.dim(0)?;
             let zhats = tok.reconstruir_de_codigos(&cod.ids, cod.ids.len(), b, &dev)?;
             let mut soma = None;
@@ -375,14 +609,23 @@ pub fn treinar_fase_b(
                 soma = Some(match soma { Some(s) => (&s + &pj)?, None => pj });
             }
             match soma {
-                Some(s) => s.affine(lambda_jepa / zhats.len().max(1) as f64, 0.0)?,
-                None => Tensor::zeros((), candle_core::DType::F32, &dev)?,
+                Some(s) => {
+                    let esc = s.affine(lambda_jepa / zhats.len().max(1) as f64, 0.0)?;
+                    let v = s.to_scalar::<f32>()? as f64;
+                    (esc, v)
+                }
+                None => (Tensor::zeros((), candle_core::DType::F32, &dev)?, 0.0),
             }
         };
-        // perdas separadas para PCGrad: [CE (com MTP embutido), JEPA]
+        // perdas separadas para PCGrad: [CE+MTP, JEPA, L_alg (Teo G-1)]
         let mut grads_lista = Vec::new();
         grads_lista.push(grads_achatados(&saida.perda, &vars)?);
         grads_lista.push(grads_achatados(&perda_jepa_t, &vars)?);
+        if let Some(pa) = &saida.perda_alg {
+            if ger.lambda_alg > 0.0 {
+                grads_lista.push(grads_achatados(&pa.affine(ger.lambda_alg, 0.0)?, &vars)?);
+            }
+        }
         let mut combinado = pcgrad_achatado(grads_lista);
         let norma = AdamWManual::norma_global(&combinado);
         ctrl.registrar_norma(norma);
@@ -391,6 +634,12 @@ pub fn treinar_fase_b(
         let teto = ctrl.clip_corrente(hub);
         AdamWManual::clipar(&mut combinado, teto);
         opt.passo(combinado);
+        // S-09: hipergradiente do λ (L_diff = valor corrente da JEPA)
+        let _ = ctrl.passo_lambda(jepa_val, hub);
+        // S-08: calibração do ε com a taxa de erro medida (1 − acc)
+        if passo % a_cada == 0 {
+            let _ = ctrl.calibrar_epsilon(1.0 - saida.acuracia_media, hub);
+        }
         // SOM pós-geração (stop-grad — Teo 17.4): insere vetores de nível 1
         if passo % a_cada == 0 {
             let b = ids.dim(0)?;
@@ -398,37 +647,57 @@ pub fn treinar_fase_b(
             let _eq = som.inserir(&zhats[0])?;
             hub.registrar("som_eq_medio", som.eq_medio);
         }
-        hub.registrar_multi(&[
-            ("perda", ce),
-            ("ce_mtp", saida.ce_mtp),
-            ("acc_conceitos", saida.acuracia_media),
-            ("lr", lr),
-            ("norma_grad", norma),
-        ]);
+        // telemetria: séries por passo (M12) + CE por nível (P-09)
+        hub.registrar("perda", ce);
+        hub.registrar("ce_mtp", saida.ce_mtp);
+        hub.registrar("acc_conceitos", saida.acuracia_media);
+        hub.registrar("lr", lr);
+        hub.registrar("norma_grad", norma);
+        hub.registrar("residuo_algebrico", saida.residuo_algebrico);
+        if ger.m_planos >= 2 {
+            hub.registrar("entropia_planos", saida.entropia_planos);
+        }
+        for (i, &ce_l) in saida.ce_por_nivel.iter().enumerate() {
+            hub.registrar(&format!("ce_nivel_{i}"), ce_l);
+        }
         if passo % a_cada == 0 || passo == cfg.treino.passos_fase_b - 1 {
             hub.registrar("escore_aprendizado", hub.escore_aprendizado());
+            let estado = hub.detectar_aprendizado();
             let snap = serde_json::json!({
                 "fase": "B", "passo": passo, "perda": ce, "ce_mtp": saida.ce_mtp,
                 "acc_conceitos": saida.acuracia_media, "lr": lr,
+                "residuo_algebrico": saida.residuo_algebrico,
                 "escore": hub.escore_aprendizado(),
+                "estado_aprendizado": format!("{estado:?}"),
             });
             chamar_callback(callback, &snap);
+            if let Some(c) = caminho_checkpoint {
+                if cfg.treino.checkpoint_a_cada > 0 && passo % cfg.treino.checkpoint_a_cada == 0 && passo > passo_inicial {
+                    ger.salvar(c)?;
+                    salvar_estado_b(c, &opt, &ctrl, passo, &jepa, &som, n_vars_ger)?;
+                }
+            }
         }
-        if !ce.is_finite() {
-            hub.erro("fase_b", &format!("CE não finita no passo {passo}"));
-            break;
-        }
+        hub.fechar_passo(); // M12
     }
-    if passos_feitos == 0 { passos_feitos = cfg.treino.passos_fase_b; }
+    if passos_feitos == passo_inicial { passos_feitos = cfg.treino.passos_fase_b; }
+    // avaliação final COMPARÁVEL (R-05): mesmo lote fixo e RNG
+    let perda_final = {
+        let mut r_fixo = StdRng::seed_from_u64(cfg.treino.semente ^ 0xF1B5);
+        let cod = tok.codificar_congelado(&lote_fixo)?;
+        let s = ger.perda_treino(tok, &cod.ids, &mut r_fixo)?;
+        s.ce_por_nivel.iter().sum::<f64>() / s.ce_por_nivel.len() as f64
+    };
     let ids_val = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
     let cod = tok.codificar_congelado(&ids_val)?;
     let saida = ger.perda_treino(tok, &cod.ids, &mut rng)?;
-    let perda_final = saida.ce_por_nivel.iter().sum::<f64>() / saida.ce_por_nivel.len() as f64;
     if let Some(c) = caminho_checkpoint {
         ger.salvar(c)?;
+        salvar_estado_b(c, &opt, &ctrl, passos_feitos, &jepa, &som, n_vars_ger)?;
     }
+    let estado = hub.detectar_aprendizado();
     Ok(ResumoFase {
-        passos: cfg.treino.passos_fase_b,
+        passos: passos_feitos,
         perda_final,
         perda_inicial,
         acc_recon: saida.acuracia_media,
@@ -436,5 +705,102 @@ pub fn treinar_fase_b(
         perplexidade_codebook: 0.0,
         monotonia_prefixo: 0.0,
         escore_aprendizado: hub.escore_aprendizado(),
+        residuo_algebrico: saida.residuo_algebrico,
+        estado_aprendizado: format!("{estado:?}"),
     })
 }
+
+#[allow(clippy::too_many_arguments)]
+fn salvar_estado_b(
+    caminho: &str,
+    opt: &AdamWManual,
+    ctrl: &Controlador,
+    passo: usize,
+    jepa: &JepaLatente,
+    som: &SomConceitos,
+    n_vars_ger: usize,
+) -> Result<()> {
+    let jepa_vars: Vec<Vec<f32>> = jepa
+        .vars()
+        .iter()
+        .map(|v| v.as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap())
+        .collect();
+    let est = EstadoTreino {
+        passo,
+        m: opt.m.clone(),
+        v: opt.v.clone(),
+        t: opt.t,
+        multiplicador_lr: ctrl.multiplicador,
+        minimo_ema: ctrl.minimo_ema,
+        passos_sem_melhora: ctrl.passos_sem_melhora,
+        clip: ctrl.clip,
+        epsilon: ctrl.epsilon_corrupcao,
+        lambda: ctrl.lambda_ancora.lambda,
+        jepa_vars: Some(jepa_vars),
+        som_prototipos: Some(som.prototipos_flat()),
+        som_lado: Some(som.lado()),
+    };
+    let _ = n_vars_ger;
+    EstadoTreino::salvar(&format!("{caminho}.estado.json"), &est)
+}
+
+/// Carrega variáveis de um checkpoint com manifesto (A20: validação estrita
+/// de contagem e forma — variável ausente ou forma trocada é ERRO, nunca
+/// silêncio).
+pub fn carregar_vars_do_checkpoint(vars: &mut [Var], caminho: &str) -> Result<()> {
+    let txt = std::fs::read_to_string(caminho).map_err(|e| candle_core::Error::Msg(format!("{e}")))?;
+    let v: serde_json::Value = serde_json::from_str(&txt).map_err(|e| candle_core::Error::Msg(format!("{e}")))?;
+    let obj = v.as_object().ok_or_else(|| candle_core::Error::Msg("formato de checkpoint inválido".into()))?;
+    // A20: valida o manifesto
+    if let Some(man) = obj.get("__manifesto") {
+        let n_vars = man["n_vars"].as_u64().unwrap_or(0) as usize;
+        if n_vars != vars.len() {
+            return Err(candle_core::Error::Msg(format!(
+                "checkpoint incompatível: manifesto declara {n_vars} vars, modelo tem {} (config diferente?)",
+                vars.len()
+            )));
+        }
+        if let Some(formas) = man["formas"].as_array() {
+            for (i, f) in formas.iter().enumerate() {
+                let esp: Vec<usize> = f.as_array().map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect()).unwrap_or_default();
+                let real = vars[i].as_tensor().dims().to_vec();
+                if esp != real {
+                    return Err(candle_core::Error::Msg(format!(
+                        "checkpoint incompatível: v{i} tem forma {:?}, modelo espera {:?}",
+                        esp, real
+                    )));
+                }
+            }
+        }
+    }
+    let dev = Device::Cpu;
+    for (i, var) in vars.iter().enumerate() {
+        let entrada = obj
+            .get(&format!("v{i}"))
+            .ok_or_else(|| candle_core::Error::Msg(format!("checkpoint incompleto: falta v{i}")))?;
+        let forma: Vec<usize> = entrada["forma"]
+            .as_array()
+            .map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect())
+            .unwrap_or_default();
+        let dados: Vec<f32> = entrada["dados"]
+            .as_array()
+            .map(|a| a.iter().filter_map(|x| x.as_f64().map(|y| y as f32)).collect())
+            .unwrap_or_default();
+        if forma.is_empty() || dados.is_empty() {
+            return Err(candle_core::Error::Msg(format!("checkpoint: v{i} vazio")));
+        }
+        let esperado = forma.iter().product::<usize>();
+        if dados.len() != esperado {
+            return Err(candle_core::Error::Msg(format!(
+                "checkpoint: v{i} tem {} elementos, forma {:?} exige {}",
+                dados.len(), forma, esperado
+            )));
+        }
+        let t2 = Tensor::from_vec(dados, forma.clone(), &dev).and_then(|t| t.reshape(forma))?;
+        var.set(&t2)?;
+    }
+    Ok(())
+}
+
+/// HashMap de compatibilidade (não usado no caminho quente).
+pub type MapaEstado = HashMap<String, f64>;

src/tronco.rs

@@ -3,10 +3,33 @@
 //! com a restrição honesta H_D1 (bidirecionalidade intra-nível nas camadas de
 //! atenção; a camada recorrente é causal).
 //!
-//! Sequência do gerador: s = [cond; lev_1; …; lev_L] com entradas
-//! ẑ_{ℓ−1}^{(n_ℓ)} + e_ℓ (reconstrução cumulativa interpolada + embedding de
-//! nível — Teo D.1). Treino: 1 passada com teacher forcing (D.1(iv));
-//! inferência: bloco a bloco com KV-cache (D.1(iii), T2).
+//! ## v0.2.0 — paridade treino↔inferência (M2/M3/M4 da auditoria r-08)
+//!
+//! **M2**: a v0.1.11 aplicava âncora/FiLM SÓ em `forward_treino` — o modelo
+//! era treinado com uma função e avaliado com outra (Δ = 2.89 no nível 1,
+//! 107% de ‖h‖). Agora `forward_nivel` mantém um **buffer pós-bloco-0**
+//! (`EstadoNivel::buffer_bloco0`) com as saídas do bloco 0 de TODAS as
+//! posições passadas — exatamente a grandeza sobre a qual a âncora pooled no
+//! treino — e injeta âncora+FiLM no caminho incremental. O estado do SSD
+//! também é transportado (**M4**) via `EstadoNivel::cache_ssd`.
+//!
+//! **Teo T-1 (paridade estrutural).** Seja `s = [prefixo; lev_1; …; lev_L]` e
+//! definam-se `f_treino(s)` (uma passada com máscara block-causal) e
+//! `f_inc(ℓ)` (passos incrementais com caches). Com (a) máscara incremental
+//! correta (prefixo causal na primeira janela), (b) âncora lendo o buffer
+//! pós-bloco-0 das posições `[0, início_ℓ)` e (c) estado SSD transportado,
+//! vale `f_treino(s)[:, nível_ℓ] = f_inc(ℓ)` para todo ℓ, a menos de erro
+//! de ponto flutuante (ordem de soma no softmax) ≤ 1e-6 relativo.
+//! *Prova (esboço formal em r-09 §2):* cada bloco é uma função local das
+//! posições visíveis; o KV-cache reproduz exatamente os k/v que o bloco
+//! computaria na passada completa (mesmas entradas ⇒ mesmos k/v); a âncora
+//! depende apenas do buffer pós-bloco-0 acumulado (idêntico nos dois caminhos
+//! por indução); o scan SSD com estado transportado particiona a mesma
+//! recorrência (gate G3). ∎ (gate G2 verifica por execução.)
+//!
+//! **M3**: `film_gamma` inicia em **0** (a v0.1.11 iniciava em 1 ⇒
+//! `x̃ = x⊙(1+tanh(r)) ≠ x` — nascimento neutro FALSO). Com γ=0, β=0:
+//! `x̃ = x⊙(1+0·tanh(r)) + 0·r = x` — identidade exata no nascimento.
 
 use candle_core::{Device, Result, Tensor, Var};
 use crate::atencao::{AncoraNivel, BlocoAdba};
@@ -14,37 +37,60 @@ pub use crate::atencao::CacheKv;
 use crate::camadas::{Embedding, Linear, RmsNorm};
 use crate::config::ConfigKhtst;
 use crate::ssd::BlocoSsd;
+use rand::prelude::*;
+
+/// Comprimento do prefixo de condicionamento (|cond| do T2).
+pub const N_PREFIXO: usize = 8;
 
 pub struct Tronco {
     pub blocos_atencao: Vec<BlocoAdba>,
     pub bloco_ssd: BlocoSsd,
     pub norm_final: RmsNorm,
     pub ancora: Option<AncoraNivel>,
-    /// gamma FiLM por nível (2*L+2: [escala, deslocamento] × nível) — ADBA.
+    /// gamma FiLM por nível (L+1, d) — init 0 (M3: nascimento neutro).
     pub film_gamma: Option<Var>,
     pub film_beta: Option<Var>,
     pub n_niveis: usize,
 }
 
+/// Estado incremental (inferência): caches KV por bloco + estado SSD +
+/// buffer pós-bloco-0 (M2/M4).
+pub struct EstadoNivel {
+    pub caches: Vec<CacheKv>,
+    pub cache_ssd: Option<Tensor>,
+    /// saídas do bloco 0 de todas as posições já processadas (b, T_acum, d)
+    pub buffer_bloco0: Option<Tensor>,
+}
+
+impl EstadoNivel {
+    pub fn novo() -> Self {
+        EstadoNivel { caches: Vec::new(), cache_ssd: None, buffer_bloco0: None }
+    }
+}
+
 impl Tronco {
     pub fn novo(cfg: &ConfigKhtst, dev: &Device) -> Result<Self> {
         let m = &cfg.modelo;
         let l = cfg.l_niveis();
         let adba = &cfg.adba;
+        // dupla trava T10: ncm.ativo=false força ADBA desligada
+        let adba_ativo = adba.ativo && cfg.ncm.ativo;
         let mut blocos = Vec::with_capacity(m.n_camadas - 1);
         for _ in 0..(m.n_camadas - 1) {
             blocos.push(BlocoAdba::novo(
                 m.d_modelo, m.n_cabecas, m.d_ff, l,
-                adba.ativo, adba.reponderacao_nivel, adba.temperatura_nivel, dev,
+                adba_ativo, adba.reponderacao_nivel, adba.temperatura_nivel, dev,
             )?);
         }
-        let ancora = if adba.ativo && adba.gamma_ancora > 0.0 {
+        let ancora = if adba_ativo && adba.gamma_ancora > 0.0 {
             Some(AncoraNivel::nova(m.d_modelo, l, dev)?)
         } else {
             None
         };
-        let (film_gamma, film_beta) = if adba.ativo {
-            let g = Tensor::ones((l + 1, m.d_modelo), candle_core::DType::F32, dev)?;
+        let (film_gamma, film_beta) = if adba_ativo {
+            // M3: γ = 0 no nascimento (identidade exata; aprendível pois
+            // ∂x̃/∂γ = x⊙tanh(r) ≠ 0)
+            let g = Tensor::zeros((l + 1, m.d_modelo), candle_core::DType::F32, dev)?;
             let b = Tensor::zeros((l + 1, m.d_modelo), candle_core::DType::F32, dev)?;
             (Some(Var::from_tensor(&g)?), Some(Var::from_tensor(&b)?))
         } else {
@@ -52,7 +98,7 @@ impl Tronco {
         };
         Ok(Tronco {
             blocos_atencao: blocos,
-            bloco_ssd: BlocoSsd::novo(m.d_modelo, m.d_ff, dev)?,
+            bloco_ssd: BlocoSsd::novo(m.d_modelo, m.d_ff, m.ssd_delta && cfg.ncm.ativo, dev)?,
             norm_final: RmsNorm::novo(m.d_modelo, 1e-5, dev)?,
             ancora,
             film_gamma,
@@ -63,6 +109,7 @@ impl Tronco {
 
     /// Injeção FiLM do resumo-âncora nas posições do nível `nivel`
     /// (ADBA (i): o resumo depende APENAS de c_{<ℓ} — paralelismo preservado).
+    /// `nivel` é 1-based (1 = primeiro nível de conceitos).
     pub fn aplicar_film(&self, x: &Tensor, resumo: &Tensor, nivel: usize) -> Result<Tensor> {
         match (&self.film_gamma, &self.film_beta) {
             (Some(g), Some(b)) => {
@@ -71,7 +118,7 @@ impl Tronco {
                 let gv = g.as_tensor().get(nivel)?.reshape((1, 1, d))?;
                 let bv = b.as_tensor().get(nivel)?.reshape((1, 1, d))?;
                 let r = resumo.reshape((bsz, 1, d))?;
-                // x ⊙ (1 + γ·tanh(r)) + β·r — neutro em γ=β=0 (nascimento neutro)
+                // x ⊙ (1 + γ·tanh(r)) + β·r — neutro em γ=β=0 (M3)
                 let gate = gv.broadcast_mul(&r.tanh()?)?.affine(1.0, 1.0)?; // 1 + γ·tanh(r)
                 let xg = x.broadcast_mul(&gate)?;
                 let desloc = bv.broadcast_mul(&r)?;
@@ -81,43 +128,50 @@ impl Tronco {
         }
     }
 
-    /// Forward de treino: sequência completa s (b, T, d) com máscara aditiva
-    /// (T, T) e mapa de níveis por posição (query e chave). 1 passada — D.1(iv).
+    /// Resumo-âncora do nível `nivel` (1-based) dado o contexto pós-bloco-0
+    /// (b, início_ℓ, d) — BATCHED (M17). Nível 1: contexto = prefixo.
+    fn resumo_nivel(&self, ctx_bloco0: &Tensor, nivel: usize) -> Result<Tensor> {
+        match &self.ancora {
+            Some(anc) => anc.resumir(ctx_bloco0, nivel - 1),
+            None => Ok(Tensor::zeros(
+                (ctx_bloco0.dim(0)?, ctx_bloco0.dim(2)?),
+                candle_core::DType::F32,
+                ctx_bloco0.device(),
+            )?),
+        }
+    }
+
+    /// Forward de TREINO: sequência completa s (b, T, d) com máscara aditiva
+    /// (T, T) e mapa de níveis por posição. 1 passada — D.1(iv).
+    /// O SSD processa a sequência inteira num único scan (≡ transporte de
+    /// estado entre níveis — gate G3).
     pub fn forward_treino(
         &self,
         s: &Tensor,
         mascara: &Tensor,
         niveis: &[usize],
-        resumos_por_nivel: &mut Vec<Tensor>,
+        _resumos_por_nivel: &mut Vec<Tensor>,
     ) -> Result<Tensor> {
         let b = s.dim(0)?;
         let mut x = s.clone();
         for (i, bloco) in self.blocos_atencao.iter().enumerate() {
             let mut cache = CacheKv::default();
             x = bloco.fwd(&x, Some(mascara), &mut cache, Some(niveis), Some(niveis))?;
-            // após o 1º bloco: injeta o resumo-âncora por nível (ADBA)
+            // após o 1º bloco: injeta o resumo-âncora por nível (ADBA) —
+            // a âncora lê o PÓS-BLOCO-0 das posições anteriores (M2: mesma
+            // grandeza que o caminho incremental lê do buffer)
             if i == 0 {
-                if let Some(anc) = &self.ancora {
-                    resumos_por_nivel.clear();
+                if let Some(_) = &self.ancora {
+                    _resumos_por_nivel.clear();
                     let n_prefixo = x.dims()[1] - self.tamanhos_por_nivel(niveis).iter().sum::<usize>();
-                    // prefixo entra inalterado (sem FiLM — nível 0)
                     let mut partes = vec![x.narrow(1, 0, n_prefixo)?];
                     let mut inicio = n_prefixo;
                     for (nivel, &n_n) in self.tamanhos_por_nivel(niveis).iter().enumerate() {
                         let trecho = x.narrow(1, inicio, n_n)?;
-                        // resumo do CONTEXTO ANTERIOR (níveis < atual): usa as
-                        // posições já processadas (função de c_{<ℓ} apenas)
-                        if inicio == n_prefixo {
-                            resumos_por_nivel.push(Tensor::zeros((b, s.dims()[2]), candle_core::DType::F32, s.device())?);
-                        } else {
-                            let ctx = x.narrow(1, 0, inicio)?;
-                            let mut r_nivel = Vec::new();
-                            for bi in 0..b {
-                                r_nivel.push(anc.resumir(&ctx.narrow(0, bi, 1)?, nivel)?);
-                            }
-                            resumos_por_nivel.push(Tensor::cat(&r_nivel, 0)?);
-                        }
-                        let r = resumos_por_nivel[nivel].clone();
+                        // resumo do CONTEXTO ANTERIOR (prefixo + níveis < atual)
+                        let ctx = x.narrow(1, 0, inicio)?;
+                        let r = self.resumo_nivel(&ctx, nivel + 1)?;
+                        _resumos_por_nivel.push(r.clone());
                         partes.push(self.aplicar_film(&trecho, &r, nivel + 1)?);
                         inicio += n_n;
                     }
@@ -125,31 +179,69 @@ impl Tronco {
                 }
             }
         }
+        let _ = b;
         let mut cache_ssd = None;
         x = self.bloco_ssd.fwd(&x, &mut cache_ssd)?;
         self.norm_final.fwd(&x)
     }
 
-    /// Forward incremental (inferência): bloco novo (b, n_novo, d) + caches.
-    /// `niveis_novos`/`niveis_cache` mapeiam posições para níveis.
+    /// Forward incremental (inferência): bloco novo (b, n_novo, d) + estado.
+    /// `nivel` é 1-based. Paridade com forward_treino (Teo T-1, gate G2).
+    ///
+    /// Correções de paridade (descobertas pelo gate G2):
+    /// (i) no 1º nível o bloco contém [prefixo; lev_1] — o FiLM aplica só às
+    /// posições DO NÍVEL (o prefixo nunca é filmado, como no treino);
+    /// (ii) o contexto da âncora do nível 1 é o PREFIXO pós-bloco-0 (no
+    /// treino a âncora de ℓ=1 pooling sobre x[:, :P]; não o bloco vazio).
     pub fn forward_nivel(
         &self,
         bloco_x: &Tensor,
-        caches: &mut Vec<CacheKv>,
+        estado: &mut EstadoNivel,
         mascara_nova: &Tensor,
+        nivel: usize,
         niveis_novos: &[usize],
         niveis_totais: &[usize],
     ) -> Result<Tensor> {
+        let n_novo = bloco_x.dim(1)?;
         let mut x = bloco_x.clone();
         for (i, bloco) in self.blocos_atencao.iter().enumerate() {
-            if caches.len() <= i {
-                caches.push(CacheKv::default());
+            if estado.caches.len() <= i {
+                estado.caches.push(CacheKv::default());
+            }
+            x = bloco.fwd(&x, Some(mascara_nova), &mut estado.caches[i], Some(niveis_novos), Some(niveis_totais))?;
+            // M2: após o bloco 0 — acumula o buffer e injeta âncora/FiLM
+            if i == 0 {
+                if self.ancora.is_some() || self.film_gamma.is_some() {
+                    let primeira_chamada = estado.buffer_bloco0.is_none();
+                    let novo_b0 = x.clone();
+                    // contexto da âncora: níveis anteriores (buffer) ou, no
+                    // 1º nível, o PREFIXO pós-bloco-0 do bloco corrente
+                    let ctx = match &estado.buffer_bloco0 {
+                        Some(buf) => buf.clone(),
+                        None => novo_b0.narrow(1, 0, N_PREFIXO.min(n_novo))?,
+                    };
+                    let r = self.resumo_nivel(&ctx, nivel)?;
+                    // FiLM apenas nas posições do NÍVEL (prefixo intacto)
+                    let n_pref_aqui = if primeira_chamada { N_PREFIXO.min(n_novo) } else { 0 };
+                    let x_filmado = if n_pref_aqui > 0 && n_novo > n_pref_aqui {
+                        let pref = novo_b0.narrow(1, 0, n_pref_aqui)?;
+                        let corpo = novo_b0.narrow(1, n_pref_aqui, n_novo - n_pref_aqui)?;
+                        let corpo_f = self.aplicar_film(&corpo, &r, nivel)?;
+                        Tensor::cat(&[pref, corpo_f], 1)?
+                    } else {
+                        self.aplicar_film(&novo_b0, &r, nivel)?
+                    };
+                    // buffer acumula o pós-bloco-0 PRÉ-FiLM (mesma grandeza do treino)
+                    estado.buffer_bloco0 = Some(match &estado.buffer_bloco0 {
+                        Some(buf) => Tensor::cat(&[buf, &novo_b0], 1)?,
+                        None => novo_b0.clone(),
+                    });
+                    x = x_filmado;
+                }
             }
-            x = bloco.fwd(&x, Some(mascara_nova), &mut caches[i], Some(niveis_novos), Some(niveis_totais))?;
-            let _ = i;
         }
-        let mut cache_ssd = None;
-        x = self.bloco_ssd.fwd(&x, &mut cache_ssd)?;
+        // M4: estado do SSD transportado entre níveis
+        x = self.bloco_ssd.fwd(&x, &mut estado.cache_ssd)?;
         self.norm_final.fwd(&x)
     }
 
@@ -200,6 +292,214 @@ impl CabecaConceitos {
     }
 }
 
+/// ## v0.3.0 — CABEÇA DE MISTURA DE PLANOS (aprimoramento "raciocínio em
+/// subníveis paralelos"; método B.3 da proposta C)
+///
+/// p(c_ℓ|c_{<ℓ}) = Σ_{m=1}^{M} w_m · Π_{i=1}^{n_ℓ} q_{m,i}(c_{ℓ,i})
+///
+/// com w = softmax(U·h̄_ℓ) (h̄_ℓ = média das posições do nível — função de
+/// c_{<ℓ} apenas) e q_{m,i} = softmax(W^{(m)}·h_{ℓ,i}).
+///
+/// **Teo C-1 (propriedades).**
+/// (i) *MLE exato*: a mistura é uma distribuição normalizada sobre [K]^{n_ℓ}
+/// (Σ_c p = Σ_m w_m Π_i Σ_k q = Σ_m w_m = 1) ⇒ −log p é a negalogverossimilhança
+/// exata, sem ELBO (Teo B.1 preservado).
+/// (ii) *NFE = L* (Teo B.2 preservado): a cabeça não adiciona avaliação do
+/// gerador.
+/// (iii) *Amostragem paralela intra-nível*: sorteia-se 1 plano m ~ w e depois
+/// as n_ℓ posições INDEPENDENTEMENTE de q_m — n_ℓ+1 sorteios, 0 passos
+/// sequenciais (a propriedade central do NCM é mantida).
+/// (iv) *Contenção estrita*: M=1 ⇒ exatamente a cabeça produto da v0.1.11
+/// (w_1 = softmax(U h̄) = 1 pois é o único componente); com M ≥ 2 a família
+/// contém estritamente os produtos — a marginal de duas posições é
+/// Σ_m w_m q_{m,i} q_{m,j} ≠ (Σ_m w_m q_{m,i})(Σ'_m w_{m'} q_{m',j}) em geral
+/// ⇒ CORRELAÇÃO intra-nível não-nula ⇒ o gap de correlação total condicional
+/// TC(c_ℓ|c_{<ℓ}) — que é exatamente min KL(q‖p) sobre a família — é REDUZIDO.
+/// *Prova da estrita contenção:* tome q_{1,i} ≠ q_{2,i} e w = (½,½): a
+/// diagonal conjunta p(c_i = c_j) = Σ_m w_m q_{m,i}(k)q_{m,j}(k) < 1 enquanto
+/// o produto de marginais dá Σ_k [½(q_{1,i}+q_{2,i})][½(q_{1,j}+q_{2,j})]·δ…
+/// — em geral distintos; um produto de marginais NÃO reproduz p (contra-exemplo
+/// numérico no gate G9). ∎
+/// (v) *Custo*: O(M·n_ℓ·K) MACs por nível — batched como UM matmul
+/// (n_ℓ, d) @ (d, M·K).
+/// (vi) *Nascimento neutro*: M=1 reproduz a v0.1.11 bit-a-bit (gate G9).
+pub struct CabecaMistura {
+    /// W empilhado: (d, M·K) — colunas [m·K .. (m+1)·K) = plano m.
+    pub w: Linear,
+    /// pesos dos planos: U (d, M) sobre a média do nível.
+    pub u: Linear,
+    pub m: usize,
+    pub k: usize,
+}
+
+impl CabecaMistura {
+    pub fn nova(d: usize, k: usize, m: usize, dev: &Device) -> Result<Self> {
+        Ok(CabecaMistura {
+            w: Linear::sem_vies(d, k * m.max(1), 0.02, dev)?,
+            u: Linear::sem_vies(d, m.max(1), 0.02, dev)?,
+            m: m.max(1),
+            k,
+        })
+    }
+
+    /// Logits por plano: h (…, d) → (…, M, K).
+    pub fn logits_planos(&self, h: &Tensor) -> Result<Tensor> {
+        let forma: Vec<usize> = h.dims().to_vec();
+        let plano = self.w.fwd(h)?; // (…, M·K)
+        let mut alvo = forma;
+        alvo.pop();
+        alvo.push(self.m);
+        alvo.push(self.k);
+        plano.reshape(alvo)
+    }
+
+    /// Pesos dos planos a partir da média do nível (função de c_{<ℓ} via h):
+    /// h (b, n_ℓ, d) → w (b, M) (softmax).
+    pub fn pesos_planos(&self, h: &Tensor) -> Result<Tensor> {
+        let media = h.mean(candle_core::D::Minus2)?; // (b, d)
+        let logits = self.u.fwd(&media)?;             // (b, M)
+        // NB: softmax_last_dim do candle-nn 0.11 é apply_op1_no_bwd (SEM
+        // gradiente!) — usamos o softmax completo, que tem backward.
+        candle_nn::ops::softmax(&logits, candle_core::D::Minus1)
+    }
+
+    /// −log p(c_ℓ) exato (log-sum-exp sobre planos): devolve (perda Tensor
+    /// escalar, ce f64). `alvos`: (b·n_ℓ,) u32.
+    pub fn nll(
+        &self,
+        h: &Tensor,
+        alvos: &Tensor,
+    ) -> Result<(Tensor, f64)> {
+        let b = h.dim(0)?;
+        let n_l = h.dim(1)?;
+        let dev = h.device();
+        let w = self.pesos_planos(h)?; // (b, M)
+        let logits = self.logits_planos(h)?; // (b, n_l, M, K)
+        // log q_{m,i}(c_i): log_softmax no último eixo + gather dos alvos
+        let logq = candle_nn::ops::log_softmax(&logits, candle_core::D::Minus1)?; // (b,n,M,K)
+        let alvos_b = alvos.reshape((b, n_l))?.to_dtype(candle_core::DType::U32)?;
+        // índice por (b, n, m): broadcast do alvo — gather devolve (b,n,M,1)
+        let idx = alvos_b
+            .reshape((b, n_l, 1, 1))?
+            .broadcast_as((b, n_l, self.m, 1))?
+            .to_dtype(candle_core::DType::U32)?
+            .contiguous()?;
+        let escolhido = logq.gather(&idx, 3)?; // (b, n, M, 1)
+        // Σ_i log q_{m,i}(c_i): soma sobre as POSIÇÕES (eixo 1)
+        let soma = escolhido.sum(1)?.squeeze(2)?; // (b, M)
+        // log w_m
+        let logw = (&w + 1e-10f64)?.log()?; // (b, M)
+        let total = (&soma + &logw)?; // (b, M)
+        // logsumexp estável sobre M
+        let max = total.max(candle_core::D::Minus1)?; // (b,)
+        let max_b = max.unsqueeze(1)?.broadcast_as(total.shape())?; // (b, M)
+        let e = (&total - &max_b)?.exp()?; // (b, M)
+        let soma_e = e.sum(candle_core::D::Minus1)?; // (b,)
+        let lse = (&(&soma_e + 1e-10f64)?.log()? + &max)?; // (b,): log p(c_ℓ)
+        // NORMALIZADO POR POSIÇÃO (comparável ao CE da v0.1.11 — gate G9):
+        // nll = −(1/n_ℓ)·log p(c_ℓ). Com M=1: −(1/n_ℓ)Σ_i log q_i ≡ CE médio.
+        let nll = lse.affine(-1.0 / n_l as f64, 0.0)?.mean_all()?;
+        let ce = nll.to_scalar::<f32>()? as f64;
+        Ok((nll, ce))
+    }
+
+    /// Amostragem paralela (Teo C-1(iii)): 1 sorteio de plano por elemento do
+    /// lote + n_ℓ sorteios independentes. Devolve ids (b, n_l) e o plano (b,).
+    pub fn amostrar(
+        &self,
+        h: &Tensor,
+        rng: &mut rand::prelude::StdRng,
+        greedy: bool,
+    ) -> Result<(Tensor, Vec<usize>)> {
+        let b = h.dim(0)?;
+        let n_l = h.dim(1)?;
+        let dev = h.device();
+        let w = self.pesos_planos(h)?; // (b, M)
+        let wv = w.flatten_all()?.to_vec1::<f32>()?;
+        let mut planos = Vec::with_capacity(b);
+        for bi in 0..b {
+            if greedy {
+                let (mut melhor, mut mi) = (-1f32, 0usize);
+                for m in 0..self.m {
+                    if wv[bi * self.m + m] > melhor {
+                        melhor = wv[bi * self.m + m];
+                        mi = m;
+                    }
+                }
+                planos.push(mi);
+            } else {
+                let r: f32 = rng.gen();
+                let mut acc = 0f32;
+                let mut esc = self.m - 1;
+                for m in 0..self.m {
+                    acc += wv[bi * self.m + m];
+                    if r <= acc {
+                        esc = m;
+                        break;
+                    }
+                }
+                planos.push(esc);
+            }
+        }
+        // logits do plano escolhido por elemento do lote
+        let logits = self.logits_planos(h)?; // (b, n, M, K)
+        let mut ids = vec![0u32; b * n_l];
+        for bi in 0..b {
+            let m = planos[bi];
+            let trecho = logits
+                .narrow(0, bi, 1)?
+                .narrow(2, m, 1)?
+                .reshape((n_l, self.k))?;
+            let t = if greedy {
+                trecho.argmax(candle_core::D::Minus1)?
+            } else {
+                // amostra categoricamente
+                let probs = candle_nn::ops::softmax(&trecho, candle_core::D::Minus1)?;
+                let pv = probs.flatten_all()?.to_vec1::<f32>()?;
+                let mut v = vec![0u32; n_l];
+                for i in 0..n_l {
+                    let r: f32 = rng.gen();
+                    let mut acc = 0f32;
+                    let mut esc = self.k - 1;
+                    for (j, p) in pv[i * self.k..(i + 1) * self.k].iter().enumerate() {
+                        acc += *p;
+                        if r <= acc {
+                            esc = j;
+                            break;
+                        }
+                    }
+                    v[i] = esc as u32;
+                }
+                Tensor::from_vec(v, (n_l,), dev)?
+            };
+            let tv = t.flatten_all()?.to_vec1::<u32>()?;
+            ids[bi * n_l..(bi + 1) * n_l].copy_from_slice(&tv);
+        }
+        Ok((Tensor::from_vec(ids, (b, n_l), dev)?, planos))
+    }
+
+    /// Logits "marginais" para CFG/telemetria: mistura das distribuições por
+    /// posição — E_m[q_{m,i}] (b, n_l, K). (Para amostragem usa-se o plano
+    /// sorteado; a marginal serve para medir entropia/τ.)
+    pub fn logits_marginais(&self, h: &Tensor) -> Result<Tensor> {
+        let w = self.pesos_planos(h)?; // (b, M)
+        let logits = self.logits_planos(h)?; // (b, n, M, K)
+        let probs = candle_nn::ops::softmax(&logits, candle_core::D::Minus1)?; // (b,n,M,K)
+        // média ponderada: (b,1,M,1) * (b,n,M,K) → soma em M
+        let w_r = w.reshape((w.dim(0)?, 1, self.m, 1))?;
+        let mistura = (&probs * &w_r.broadcast_as(probs.shape())?)?
+            .sum(candle_core::D::Minus2)?;
+        // devolve log da mistura como "logits" (estável)
+        (&mistura + 1e-10f64)?.log()
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        let mut v = self.w.vars();
+        v.extend(self.u.vars());
+        v
+    }
+}
+
 /// Embeddings de nível e_ℓ (T1 via A).
 pub struct EmbNiveis {
     pub tabela: Embedding,

tests/provas.rs

@@ -0,0 +1,285 @@
+//! PROVAS EXECUTÁVEIS (gates) do KHTST_RUST v0.3.0.
+//!
+//! Regra da casa (r-08 §1): *contar a estrutura não é verificar a função* —
+//! toda verificação precisa de um `assert` que FALHE se o invariante quebrar,
+//! e invariantes sobre INFORMAÇÃO são medidos perturbando a entrada e
+//! observando a resposta (Jacobiano direcional), não a representação.
+//!
+//! | gate | o que prova | onde |
+//! |---|---|---|
+//! | G1 | vazamento efetivo ZERO (nível 1 não muda quando o futuro muda) | aqui |
+//! | G2 | paridade treino↔inferência (forward completo ≡ incremental) | aqui |
+//! | G3 | estado SSD transportado (scan completo ≡ particionado) | ssd.rs |
+//! | G4 | nenhuma linha totalmente bloqueada (M1) | mascaras.rs |
+//! | G5 | nascimento neutro (γ=0 ⇒ FiLM identidade; ξ=ζ=0 ⇒ w=1, τ=1) | aqui + atencao.rs |
+//! | G6 | orçamento do KV-cache inclui o prefixo | config.rs |
+//! | G7 | reprodutibilidade bit-a-bit (mesma semente ⇒ mesmo init) | aqui |
+//! | G8 | acumulação SSD-Δ: inteiros EXATOS, floats com cota (Teo S-1) | ssd.rs |
+//! | G9 | mistura M=1 ≡ cabeça produto da v0.1.11 | aqui |
+//! | G10 | adjunto SSD-Δ vs FD (inclui ∂L/∂h0, ∂L/∂η) | ssd.rs |
+//! | G11 | adjunto do verificador algébrico vs FD (Teo G-1) | aqui |
+//! | G12 | MLE exato da mistura (Σ_c p(c) = 1 sobre [K]^{n_ℓ}) | aqui |
+
+use candle_core::{Device, Result, Tensor, Var, D};
+use khtst_rust::config::ConfigKhtst;
+use khtst_rust::tronco::CabecaMistura;
+use std::sync::{Mutex, MutexGuard, OnceLock};
+
+/// Os gates usam o RNG GLOBAL semeado — os testes rodam em paralelo por
+/// padrão, então cada gate que constrói modelos segura esta trava para
+/// ter exclusividade sobre o RNG (senão G7 falha por interferência).
+fn trava_rng() -> MutexGuard<'static, ()> {
+    static T: OnceLock<Mutex<()>> = OnceLock::new();
+    // tolerante a envenenamento: um gate que panica não pode mascarar os demais
+    T.get_or_init(|| Mutex::new(()))
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+}
+
+/// Config pequena e determinística para os gates de modelo inteiro.
+fn cfg_gate() -> ConfigKhtst {
+    let mut cfg = ConfigKhtst::default();
+    cfg.modelo.vocab = 64;
+    cfg.modelo.d_modelo = 32;
+    cfg.modelo.n_camadas = 2; // 1 ADBA + 1 SSD
+    cfg.modelo.n_cabecas = 4;
+    cfg.modelo.d_ff = 64;
+    cfg.modelo.comprimento_ctx = 8;
+    cfg.modelo.kv_cache_max = 64;
+    cfg.ncm.niveis = vec![2, 4, 8];
+    cfg.ncm.d_lat = 8;
+    cfg.ncm.k_por_nivel = 8;
+    cfg.ncm.ativo = true;
+    cfg.ncm.mistura_planos = 1;
+    cfg.modelo.mtp.ativo = false;
+    cfg.ncm.corrupcao_cond = 0.0;
+    cfg.ncm.dropout_cfg = 0.0;
+    cfg.treino.semente = 4242;
+    cfg.validar().unwrap();
+    cfg
+}
+
+/// G1 — VAZAMENTO EFETIVO ZERO: corrompe os níveis > 1 (×999) e mede a
+/// resposta ‖Δ‖∞ nas posições do nível 1. Na v0.1.11 este valor era 0,109
+/// (110% do sinal — a fatoração next-concept estava quebrada); com a máscara
+/// de prefixo causal (M1) deve ser ~0.
+#[test]
+fn gate_g1_vazamento_efetivo_zero() {
+    let _trava = trava_rng();
+    let cfg = cfg_gate();
+    let dif = khtst_rust::teste_vazamento_efetivo(&cfg).expect("teste de vazamento");
+    assert!(dif <= 1e-6, "G1: vazamento efetivo = {dif} (esperado 0)");
+}
+
+/// G2 — PARIDADE TREINO↔INFERÊNCIA: o forward completo (1 passada, máscara
+/// block-causal) deve reproduzir o incremental (níveis com KV-cache, âncora
+/// do buffer pós-bloco-0, estado SSD transportado). Na v0.1.11 o Δ era
+/// 2,89 no nível 1 (a ADBA não existia na inferência).
+#[test]
+fn gate_g2_paridade_treino_inferencia() {
+    let _trava = trava_rng();
+    let cfg = cfg_gate();
+    let r = khtst_rust::teste_paridade(&cfg).expect("teste de paridade");
+    let dif_max = r["dif_max"].as_f64().unwrap();
+    assert!(dif_max < 1e-4, "G2: paridade treino↔inferência dif_max = {dif_max}");
+    let difs: Vec<f64> = r["difs_por_nivel"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
+    assert_eq!(difs.len(), 3, "um Δ por nível");
+}
+
+/// G5 — NASCIMENTO NEUTRO: com o tronco recém-construído (γ=0, β=0, ξ=0,
+/// ζ=0), aplicar_film é a IDENTIDADE bit-a-bit, qualquer que seja o resumo.
+#[test]
+fn gate_g5_nascimento_neutro_film() -> Result<()> {
+    let _trava = trava_rng();
+    use khtst_rust::gerador::GeradorConceitos;
+    let cfg = cfg_gate();
+    khtst_rust::rng::inicializar(cfg.treino.semente);
+    let ger = GeradorConceitos::novo(&cfg, &Device::Cpu)?;
+    let dev = Device::Cpu;
+    let x = khtst_rust::rng::randn_semeado(1.0, &[2, 4, cfg.modelo.d_modelo], &dev)?;
+    let resumo = khtst_rust::rng::randn_semeado(1.0, &[2, cfg.modelo.d_modelo], &dev)?;
+    for nivel in 1..=cfg.l_niveis() {
+        let y = ger.tronco.aplicar_film(&x, &resumo, nivel)?;
+        let dif = (&x - &y)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert_eq!(dif, 0.0, "G5: FiLM deve ser identidade no nascimento (nível {nivel})");
+    }
+    Ok(())
+}
+
+/// G7 — REPRODUTIBILIDADE: mesma semente ⇒ inicialização idêntica bit-a-bit
+/// (A19: a v0.1.11 usava Tensor::randn = entropia do SO — irreproduzível).
+#[test]
+fn gate_g7_reprodutibilidade_bit_a_bit() -> Result<()> {
+    let _trava = trava_rng();
+    use khtst_rust::gerador::GeradorConceitos;
+    let cfg = cfg_gate();
+    khtst_rust::rng::inicializar(cfg.treino.semente);
+    let g1 = GeradorConceitos::novo(&cfg, &Device::Cpu)?;
+    let v1 = g1.vars();
+    khtst_rust::rng::inicializar(cfg.treino.semente);
+    let g2 = GeradorConceitos::novo(&cfg, &Device::Cpu)?;
+    let v2 = g2.vars();
+    assert_eq!(v1.len(), v2.len());
+    let mut dif_max = 0f32;
+    for (a, b) in v1.iter().zip(v2.iter()) {
+        let dif = a.as_tensor().sub(b.as_tensor())?.abs()?.max_all()?.to_scalar::<f32>()?;
+        dif_max = dif_max.max(dif);
+    }
+    assert_eq!(dif_max, 0.0, "G7: mesma semente deve dar init idêntico bit-a-bit");
+    Ok(())
+}
+
+/// G9 — MISTURA M=1 ≡ CABEÇA PRODUTO: com os MESMOS pesos W, o NLL da
+/// mistura com 1 plano é o CE da cabeça produto da v0.1.11 (Teo C-1(vi)):
+/// w_1 = softmax(logit único) = 1 ⇒ −log p = −Σ_i log q_i = CE.
+#[test]
+fn gate_g9_mistura_m1_igual_produto() -> Result<()> {
+    let _trava = trava_rng();
+    khtst_rust::rng::inicializar(99);
+    let dev = Device::Cpu;
+    let (d, k, n, b) = (16usize, 6, 5, 2);
+    let cab = CabecaMistura::nova(d, k, 1, &dev)?;
+    let h = khtst_rust::rng::randn_semeado(1.0, &[b, n, d], &dev)?;
+    let alvos = Tensor::from_vec(
+        (0..b * n).map(|i| (i * 7 % k) as u32).collect::<Vec<u32>>(),
+        (b * n,),
+        &dev,
+    )?;
+    // NLL da mistura (M=1)
+    let (nll, _ce) = cab.nll(&h, &alvos)?;
+    let nll_v = nll.to_scalar::<f32>()? as f64;
+    // CE do produto com o MESMO W: copia os pesos p/ uma Linear (k, d)
+    let w_lin = Var::from_tensor(&Tensor::zeros((k, d), candle_core::DType::F32, &dev)?)?;
+    w_lin.set(cab.w.w.as_tensor())?;
+    let logits = h.broadcast_matmul(&w_lin.as_tensor().transpose(0, 1)?.unsqueeze(0)?)?; // (b, n, k)
+    let plano = logits.reshape((b * n, k))?;
+    let ce = candle_nn::loss::cross_entropy(&plano, &alvos)?;
+    let ce_v = ce.to_scalar::<f32>()? as f64;
+    assert!(
+        (nll_v - ce_v).abs() < 1e-4,
+        "G9: NLL mistura M=1 ({nll_v}) deve ≡ CE produto ({ce_v})"
+    );
+    Ok(())
+}
+
+/// G12 — MLE EXATO DA MISTURA: Σ_{c ∈ [K]^{n}} p(c) = 1 (normalização
+/// analítica — Teo C-1(i)), verificada por ENUMERAÇÃO exausta (K=3, n=3,
+/// M=2 ⇒ 27 atribuições).
+#[test]
+fn gate_g12_mistura_normaliza_1() -> Result<()> {
+    let _trava = trava_rng();
+    khtst_rust::rng::inicializar(123);
+    let dev = Device::Cpu;
+    let (d, k, n, b, m) = (8usize, 3, 3, 1, 2);
+    let cab = CabecaMistura::nova(d, k, m, &dev)?;
+    let h = khtst_rust::rng::randn_semeado(1.0, &[b, n, d], &dev)?;
+    let w = cab.pesos_planos(&h)?; // (b, M)
+    let logits = cab.logits_planos(&h)?; // (b, n, M, K)
+    let wv = w.flatten_all()?.to_vec1::<f32>()?;
+    let logq = candle_nn::ops::log_softmax(&logits, D::Minus1)?;
+    let lqv = logq.flatten_all()?.to_vec1::<f32>()?;
+    let idx = |i: usize, mi: usize, kk: usize| ((i * m + mi) * k + kk);
+    // enumera todas as k^n atribuições
+    let mut soma_p = 0f64;
+    for c0 in 0..k {
+        for c1 in 0..k {
+            for c2 in 0..k {
+                let cs = [c0, c1, c2];
+                // p(c) = Σ_m w_m Π_i q_{m,i}(c_i)
+                let mut p = 0f64;
+                for mi in 0..m {
+                    // log p(c | plano m) = ln w_m + Σ_i log q_{m,i}(c_i)
+                    let mut lp = (wv[mi] as f64).ln();
+                    for (i, &ci) in cs.iter().enumerate() {
+                        lp += lqv[idx(i, mi, ci)] as f64;
+                    }
+                    p += lp.exp();
+                }
+                soma_p += p;
+            }
+        }
+    }
+    assert!(
+        (soma_p - 1.0).abs() < 1e-4,
+        "G12: Σ_c p(c) = {soma_p} (deve ser 1 — normalização exata)"
+    );
+    Ok(())
+}
+
+/// G11 — ADJUNTO DO VERIFICADOR ALGÉBRICO vs FD (Teo G-1(iv)): o gradiente
+/// de L_alg = ‖Interp(ẑ_soft) − ẑ_{ℓ−1}‖² w.r.t. h (via softmax →
+/// materializar_probs → interp) é exato (autograd) — validado por FD.
+#[test]
+fn gate_g11_adjunto_algebrico_vs_fd() -> Result<()> {
+    let _trava = trava_rng();
+    use khtst_rust::mascaras::interp_para;
+    khtst_rust::rng::inicializar(777);
+    let dev = Device::Cpu;
+    let (n_l, n_ant, d_lat, k) = (6usize, 3, 4, 5);
+    let h = khtst_rust::rng::randn_semeado(1.0, &[1, n_l, d_lat], &dev)?;
+    let hv = Var::from_tensor(&h)?;
+    let zhat_ant = khtst_rust::rng::randn_semeado(1.0, &[1, n_ant, d_lat], &dev)?;
+    // codebook fixo
+    let c = khtst_rust::rng::randn_semeado(0.5, &[k, d_lat], &dev)?;
+    let r_escala = 0.7f64;
+    let perda = |h: &Tensor| -> Result<f64> {
+        let logits = h.broadcast_matmul(&c.transpose(0, 1)?.unsqueeze(0)?)?; // (1, n_l, k)
+        let probs = candle_nn::ops::softmax(&logits, D::Minus1)?;
+        let r_soft = probs.matmul(&c.unsqueeze(0)?)?.affine(r_escala, 0.0)?; // (1, n_l, d_lat)
+        let zhat_soft = interp_para(&zhat_ant, n_l, &dev)?.add(&r_soft)?;
+        let voltou = interp_para(&zhat_soft, n_ant, &dev)?;
+        let dif = voltou.sub(&zhat_ant)?;
+        Ok(dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64)
+    };
+    // autograd (perda construída sobre o Var)
+    let perda_t = {
+        let logits = hv.as_tensor().broadcast_matmul(&c.transpose(0, 1)?.unsqueeze(0)?)?;
+        let probs = candle_nn::ops::softmax(&logits, D::Minus1)?;
+        let r_soft = probs.matmul(&c.unsqueeze(0)?)?.affine(r_escala, 0.0)?;
+        let zhat_soft = interp_para(&zhat_ant, n_l, &dev)?.add(&r_soft)?;
+        let voltou = interp_para(&zhat_soft, n_ant, &dev)?;
+        let dif = voltou.sub(&zhat_ant)?;
+        dif.sqr()?.sum_all()?
+    };
+    let gs = perda_t.backward()?;
+    let g = gs.get(&hv).unwrap().flatten_all()?.to_vec1::<f32>()?;
+    // FD central
+    let eps = 1e-3f32;
+    let h_plano = h.flatten_all()?.to_vec1::<f32>()?;
+    let mut erro = 0f64;
+    for i in [0usize, 5, 11, 17, 22] {
+        let mut hp = h_plano.clone();
+        let mut hm = h_plano.clone();
+        hp[i] += eps;
+        hm[i] -= eps;
+        let tp = Tensor::from_vec(hp, (1, n_l, d_lat), &dev)?;
+        let tm = Tensor::from_vec(hm, (1, n_l, d_lat), &dev)?;
+        let fd = (perda(&tp)? - perda(&tm)?) / (2.0 * eps as f64);
+        erro = erro.max((fd - g[i] as f64).abs());
+    }
+    assert!(erro < 5e-3, "G11: adjunto do verificador algébrico vs FD = {erro}");
+    Ok(())
+}
+
+/// Extra — M8: PCGrad projeta contra os gradientes ORIGINAIS (invariante
+/// de não-piora: ⟨g_combinado, g_i⟩ ≥ 0 para toda perda i).
+#[test]
+fn gate_m8_pcgrad_nao_piora() {
+    // duas perdas conflitantes em 2 variáveis
+    let g1 = vec![Some(vec![1.0f32]), Some(vec![-2.0])];
+    let g2 = vec![Some(vec![-1.0f32]), Some(vec![0.5])];
+    let combinado = khtst_rust::treino::pcgrad_achatado(vec![g1.clone(), g2.clone()]);
+    let ip = |a: &Vec<Option<Vec<f32>>>, b: &Vec<Option<Vec<f32>>>| -> f64 {
+        let mut s = 0f64;
+        for (x, y) in a.iter().zip(b.iter()) {
+            if let (Some(x), Some(y)) = (x, y) {
+                s += x.iter().zip(y.iter()).map(|(p, q)| *p as f64 * *q as f64).sum::<f64>();
+            }
+        }
+        s
+    };
+    let ip1 = ip(&combinado, &g1);
+    let ip2 = ip(&combinado, &g2);
+    assert!(ip1 >= -1e-9, "⟨g, g1⟩ = {ip1} ≥ 0 (não-piora)");
+    assert!(ip2 >= -1e-9, "⟨g, g2⟩ = {ip2} ≥ 0 (não-piora)");
+}