v0.10.0: análise/prova/teste das críticas de engenharia Qwen3.8 lote 3 (r-35) — divisão SRP dos monólitos jepa/pensamento/moe/python em 26 submódulos (API estável via re-exports; 'Amdahl de compilação' refutada por experimento controlado, builds frios neutros), checkpoints atômicos SHA-256 puro FIPS 180-4 + fsync + rename + manifesto (CP-1..CP-3; correções da proposta: sem destruir estado anterior, manifesto com barreira, sem bincode/unwrap), TemperaturaInversa T-V3 (fronteira tipada da convexidade N-2; alegação compile-time corrigida), trait CamadaKhtst+CamadaHomeostatica (premissa do controlador refutada no fonte; Vec<Var>; adaptador MoeComPapel bit-a-bit), CLI Typer 75 (fachada aditiva com resume verificado por hash) — 123/123 cargo, 107/107 gates, treino real Wikipédia PT-BR com checkpoints íntegros

Cargo.lock

@@ -723,7 +723,7 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "khtst-rust"
-version = "0.9.0"
+version = "0.10.0"
 dependencies = [
  "anyhow",
  "built",

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "khtst-rust"
-version = "0.9.0"
+version = "0.10.0"
 edition = "2021"
-description = "KHTST_RUST — análise/prova/teste das críticas Qwen3.8 v2 (r-34): skew O(n²) diferenciável via index_add, calibrar vetorial bit-a-bit, forward canônico (bug v080-1 fora da API pública), FFI isolada em feature python, newtypes de domínio"
+description = "KHTST_RUST — críticas Qwen3.8 lote 3 (r-35): divisão SRP dos monólitos, checkpoints atômicos SHA-256+fsync+rename, newtype TemperaturaInversa (fronteira tipada N-2), trait CamadaKhtst + CamadaHomeostatica, CLI unificada Typer"
 license = "Apache-2.0"
 
 [lib]

docs/memorias/r-35-analise-provas-qwen-v010.md

@@ -0,0 +1,360 @@
+# r-35 — Análise, Provas e Testes das Críticas de Engenharia do Agente Qwen3.8 (v0.10.0, lote 3)
+
+**Escopo**: o usuário pediu *analisar, provar e testar* o terceiro lote de
+críticas do agente Qwen3.8 (anti-padrões de engenharia de software que
+"comprometem a escalabilidade": monólitos Rust, scripts Python
+sequenciais, checkpointing não-atômico, invariantes apenas em
+comentários), mantendo as regras da casa: **nenhuma funcionalidade SOTA
+eficaz é removida**; toda mudança com prova matemática, lógica e de
+lógica computacional; provas em markdown; validação com dataset real;
+autocrítica (inclusive das minhas próprias correções).
+
+**Metodologia** (herdada da r-34): (i) verificação simbólica/lógica de
+cada crítica e proposta ANTES do código; (ii) confronto com oráculos
+independentes (medições frias em target dir separado, experimento
+controlado com grupo de controle, vetores oficiais FIPS 180-4); (iii)
+implementação apenas do que sobrevive a (i)+(ii), como **adição**; (iv)
+testes de regressão + suíte consolidada; (v) validação fim-a-fim com
+dataset real (Wikipédia PT-BR, streaming controlado).
+
+**Veredito sumário**:
+
+| # | Crítica / Proposta | Veredito | Ação v0.10.0 | Ganho medido |
+|---|--------------------|----------|--------------|--------------|
+| 1 | Monólitos jepa.rs (58,4 kB), pensamento.rs (53,4 kB), moe_redirecionavel.rs (50,6 kB) violam SRP; "Lei de Amdahl p/ compilação": split ⇒ T_inc ≈ O(N/k) | **SRP VÁLIDO; a "prova" é uma APLICAÇÃO ERRADA de Amdahl e a alegação O(N/k) é REFUTADA por experimento controlado** | divisão em 26 submódulos coesos com re-exports (API estável); +python.rs 112 kB (pior monólito — acrescentado por autocrítica) | 61 arquivos, maior agora 57,6 kB (fnh.rs); 107/107 gates herdados preservados; compilação incremental ~1,1 s ANTES E DEPOIS (ruído); builds frios neutros (70→68 s, 85→86 s) |
+| 2 | "Scripts Python sequenciais" (39_coletar…74) ⇒ substituir por CLI Typer | **PARCIALMENTE VÁLIDA como desejo de unificação; a SUBSTITUIÇÃO é REJEITADA** (quebra rastreabilidade r-XX↔scripts e remove funcionalidade) | `scripts/75_cli.py` — fachada Typer que delega aos scripts canônicos + política de resume com integridade + gestão de estados | 1 entry point p/ todo o pipeline; resume com prova SHA-256; drill de corrupção 3/3 |
+| 3 | Checkpointing não-atômico (`os.path.exists` vulnerável a queda de energia) | **VÁLIDA no problema; a proposta tem 3 falhas** (destrói o estado anterior; manifesto sem fsync; bincode+`unwrap`) | `src/checkpoint.rs`: SHA-256 puro (FIPS 180-4) + tmp→fsync→rename→fsync(dir) p/ conteúdo E manifesto; `carregar_verificado`; bindings Python | 2 checkpoints do treino real verificados (240,9 MB e 59,5 MB, manifesto 141 B); adulteração/truncamento/manifesto-trocado detectados; estado anterior preservado sob falha simulada |
+| 4 | "Invariantes apenas em comentários" (convexidade em γ=1/T) ⇒ newtype `TemperaturaInversa` | **VÁLIDA no padrão; a alegação "garantia em tempo de COMPILAÇÃO" é FALSA** (a validação é de runtime na fronteira) | `tipos::TemperaturaInversa` (T-V3) + fronteira tipada no verificador (`nll_temperatura_tipado`, setter/getter, saída do otimizador validada) | T* do ajuste validada por construção; equivalência bit-a-bit com o caminho cru (tv3d); pré-condição do Teo N-2 carregada no tipo |
+| P1 | Trait `CamadaKhtst` c/ `forward`+`parametros`+`gate_ativacao` | **IDEIA VÁLIDA; PREMISSA FALSA (controlador NÃO conhece Fnh/Moe/Jepa — verificado no fonte) e assinatura quebraria o otimizador** | trait corrigido (`Vec<Var>`; gate segregado em `CamadaHomeostatica`; adaptador `MoeComPapel` captura o papel) | composição heterogênea preserva B×T (CK-1); delegação bit-a-bit (CK-1c); despacho homeostático tipado (CK-2a) |
+| P3 | Checkpoint atômico com "prova criptográfica" | ver #3 acima | idem | idem |
+| P4 | CLI Typer declarativo | ver #2 acima | idem | idem |
+
+**Contagem**: 4 críticas + 4 propostas analisadas; **2 aceitas com
+correções substanciais**, **1 aceita parcialmente (substância sim,
+substituição não)**, **1 com premissa refutada por experimento**, e **todas
+as 4 propostas de código continham erros** catalogados abaixo. 16 testes
+novos; suíte consolidada **107/107**; cargo **123/123**.
+
+---
+
+## §1 — Ambiente, baseline e higiene (pré-requisitos do usuário)
+
+- **Processos de fundo**: nenhum processo residual de treino encontrado
+  (`ps aux` na abertura); toda execução em primeiro plano, como exige a
+  advertência de que o fundo mata processos sem erro/OOM (confirmado
+  empiricamente nas sessões anteriores — r-32 §"fase C com resume").
+- **Estados de treino**: varredura inicial (`*.pt`, `*.npz`, `*.ckpt`,
+  `*.safetensors`, `*.estado.json`) = **0 estados locais**; um
+  `telemetria_fase_c.jsonl` da v0.9.0 (estado residual de treino
+  anterior, exatamente o que o usuário manda procurar) foi **encontrado
+  e apagado** antes do treino fresco v0.10.0 (§5).
+- **Espaço**: 3,1 GB de alvos cargo obsoletos (`logs/tgt_full`,
+  `logs/tgt_domain` — artefatos de builds de sessões passadas) apagados
+  (96% → 64% de uso do disco).
+- **Baseline**: v0.9.0 reconstruída e verificada **107/107** antes de
+  qualquer mudança.
+
+## §2 — Crítica 1: "Monólitos em Rust" e a "Lei de Amdahl para Compilação"
+
+### 2.1 Análise da crítica
+
+**Válido (substância)**: `jepa.rs` (58.407 B), `pensamento.rs` (53.408 B)
+e `moe_redirecionavel.rs` (50.941 B) eram arquivos multi-responsabilidade
+— `jepa.rs` continha núcleo E/P/EMA, 6 famílias de máscara, 6
+embaralhamentos de patches, enum de 10 variantes + treinos especializados,
+SonicMoE E ReplaySSM. Violação real de SRP.
+
+**Inválido (rótulo)**: a "Prova Lógica (Lei de Amdahl para Compilação)"
+não é a Lei de Amdahl. A Lei de Amdahl limita o ganho de paralelização
+pela fração serial: S(n) = 1/((1−p) + p/n). O que a crítica quer invocar
+é a granularidade da **unidade de compilação** — e a afirmação
+"T_inc do monólito é O(N); dividir em módulos reduz T_inc ≈ O(N/k)" é
+**falsa na granularidade proposta**:
+
+**Teo CK-0 (granularidade de recompilação).** O cargo/rustc recompila por
+**crate**, não por arquivo. Dividir `jepa.rs` em `jepa/*.rs` não cria
+unidades de compilação novas: um toque em qualquer arquivo do diretório
+recompila o crate inteiro (com reuso incremental por queries/itens). Para
+obter T_inc ≈ O(N/k) seria necessário dividir em **k crates** (workspace),
+o que tem custos próprios: unificação de features entre crates, a `cdylib`
+única do PyO3 exigiria um crate só de FFI dependendo de crates de domínio,
+e qualquer mudança de API pública recompila os dependentes (o grafo de
+dependências domina — de novo Amdahl, agora corretamente aplicado: o ganho
+é limitado pelo caminho crítico do DAG de crates). ∎
+
+### 2.2 O que foi feito (divisão SRP aditiva)
+
+- `jepa.rs` → `jepa/{nucleo, mascaras, patches, variantes, sonic_moe,
+  replay_ssm, testes}.rs`
+- `pensamento.rs` → `pensamento/{motor, combinador, quebra_cabeca, testes}.rs`
+- `moe_redirecionavel.rs` → `moe_redirecionavel/{atencao, nucleo, treino,
+  testes, teste_integrado}.rs`
+- `python.rs` (112.410 B — o **pior** monólito, não citado pela crítica:
+  errata por autocrítica) → `python/{nucleo, treino_fases, som,
+  jepa_treinos, pensamento_demos, calibracao, moe, fnh_arvore, nlp_nlg,
+  demos_qwen}.rs`
+- Cada `mod.rs` re-exporta `pub use sub::*;` ⇒ **todos os caminhos
+  `crate::jepa::X` etc. permanecem válidos** (107/107 testes herdados
+  verdes = prova de preservação de comportamento).
+- Submódulos do python/ ganham `pub(crate)` nas pyfunctions/pyclasses (o
+  registro `#[pymodule]` referencia `sub::item`); helpers entre irmãos
+  (`distancia_eucl`, `carregar_tokenizador`, `ConfigPy`) promovidos a
+  `pub(crate)` — visibilidade mínima necessária, nada vira `pub`.
+
+**Aritmética da divisão**: 4 monólitos (275,2 kB) → 26 arquivos
+(maior submódulo: `python/demos_qwen.rs`; maior arquivo do projeto agora
+`fnh.rs` com 57,6 kB — abaixo do menor monólito criticado).
+
+### 2.3 Experimento controlado (refutação da alegação O(N/k)) ∎
+
+**Protocolo**: build aquecido; toque único (`os.utime`) no arquivo;
+`cargo build --no-default-features`; mediana de 3 execuções. Grupo de
+controle: `tipos.rs` (arquivo pequeno, inalterado pelo split).
+
+| arquivo tocado | v0.9.0 (monólito) | v0.10.0 (submódulo) |
+|---|---|---|
+| jepa (58,4 kB) | 1,06 s | 1,13 s (`jepa/variantes.rs`) |
+| pensamento (53,4 kB) | 1,13 s | 1,15 s (`pensamento/motor.rs`) |
+| moe (50,9 kB) | 1,05 s | 1,20 s (`moe/nucleo.rs`) |
+| **controle** tipos.rs | 1,21 s | 1,19 s |
+
+O controle varia tanto quanto os alvos (±0,15 s) — **o custo incremental
+é dominado pelo overhead fixo do rustc/cargo, não pelo tamanho do arquivo
+modificado**. A alegação O(N/k) é refutada nesta granularidade. Builds
+frios (target dir separado): domínio 70→68 s, completo 85→86 s —
+**neutros**; a divisão não degradou nada e o ganho é o SRP.
+
+### 2.4 O ganho real de compilação já estava capturado
+
+A separação que MUDA o tempo de compilação é a de **features** (v0.9.0,
+r-34 §5): domínio testa sem linkar Python. Overhead Python+ponte medido
+agora: 22,0% (68 s vs 86 s frios) — consistente com os 17,6% da r-34
+(mesmo protocolo, máquina com carga diferente).
+
+## §3 — Proposta 1: trait `CamadaKhtst` (polimorfismo de camadas)
+
+### 3.1 Análise e erratas da proposta
+
+1. **Premissa falsa** (verificada no fonte): `rg "fnh|moe|jepa" src/controlador.rs`
+   = **0 ocorrências**. O `Controlador` regula hiperparâmetros
+   (AutoAjustePensamento/Ucb1/AutoAjusteSom); ele NÃO conhece camadas
+   concretas. O problema que o trait resolveria não existe no sítio
+   alegado — mas o trait ainda tem valor como abstração de composição
+   (adotado).
+2. **Assinatura quebra o otimizador**: `fn parametros(&self) -> Vec<&Tensor>`
+   devolve visões somente-leitura; a partir de `&Tensor` não se recupera a
+   `Var` para `set()` in-place ⇒ qualquer otimizador via trait ficaria
+   **degradado a cópia-e-devolve** (ou não compila). Corrigido para
+   `Vec<Var>`.
+3. **Violação de segregação de interface**: `gate_ativacao` na base força
+   TODA camada a ter gate de punição. Movida para o trait separado
+   `CamadaHomeostatica`.
+4. **"Prova" mal tipada**: "a composição de funções lineares e ativações
+   preserva a dimensionalidade do batch" — falso para D (projeções mudam
+   D por definição). O invariante correto é sobre **B×T**, provado como
+   Teo CK-1 (em `camadas.rs`): reshape canônico fixa B·T; matmul age à
+   direita; ativações elemento-a-elemento. ∎
+5. **Casamento incompleto com a MoE**: `MoeRedirecionavel::forward(x, papel)`
+   é parametrizada por papel; forçar `forward(&self, x)` perderia o
+   parâmetro (proibido remover). Resolvido com o **adaptador zero-custo**
+   `MoeComPapel { moe, papel }` que captura o papel — os caminhos de
+   treino seguem usando o forward completo (com perda auxiliar e carga).
+
+### 3.2 Implementação (aditiva)
+
+`camadas.rs`: `trait CamadaKhtst { forward; parametros }`,
+`trait CamadaHomeostatica { gate_ativacao(&Probabilidade) -> GateAtivacao }`,
+impls para `Linear`, `MlpJepa`, `MoeComPapel`; `fnh.rs`: impl
+`CamadaHomeostatica` para `GatePunicao` (via `valor_tipado`, T-V2).
+
+### 3.3 Testes (4 novos, todos verdes)
+
+- **ck1a**: composição heterogênea `Vec<&dyn CamadaKhtst>` =
+  Linear→MlpJepa sobre (2,3,8): saída (2,3,32) — B×T preservado (CK-1);
+  MoE via adaptador sobre (6,32).
+- **ck1b**: `parametros()` não-vazio em todas as impls (otimizável).
+- **ck1c**: adaptador delega **bit-a-bit** (comparação `to_bits()` por
+  elemento) para `moe.forward(x, papel).saida`.
+- **ck2a**: despacho homeostático heterogêneo: zona morta exata em
+  π=0,2 < θ_π; gate > 0 em π=0,95.
+
+## §4 — Crítica 3 + Proposta 3: checkpoint atômico com prova de integridade
+
+### 4.1 Análise da crítica — VÁLIDA
+
+O padrão v0.9.0 era `fs::write(tmp)` + `rename` **sem fsync** e **sem
+verificação de integridade**; o Python decidia resume por
+`os.path.exists`. Janelas reais de falha: (a) queda de energia após o
+rename mas antes do flush dos dados ⇒ arquivo final existe com conteúdo
+zero/parcial (metadata journalizada, dados não — comportamento
+dependente do FS); (b) TOCTOU entre `exists()` e o carregamento;
+(c) corrupção silenciosa (bit rot, truncamento por ENOSPC parcial)
+indetectável — o carregador legado só falha SE o JSON quebrar, e um
+checkpoint truncado no meio de um array passa despercebido até o
+`dados.len() != produto(forma)` — que existia, mas sem hash não detecta
+substituição de mesmo formato.
+
+### 4.2 Erratas da proposta (3)
+
+1. **Destruição do estado anterior**: `File::create(caminho_pesos)`
+   trunca o checkpoint VÁLIDO anterior ANTES de escrever o novo. Queda
+   de energia no meio da escrita = perda dos DOIS estados. A atomicidade
+   real exige tmp+rename (a v0.9.0 JÁ fazia tmp+rename; a proposta seria
+   um REGRESSO).
+2. **Manifesto sem barreira**: `fs::write(caminho_meta, ...)` sem
+   `sync_all` — o manifesto pode não atingir o disco quando os pesos já
+   atingiram, violando a própria ordenação que a "prova de atomicidade"
+   alegada depende.
+3. **`bincode::serialize(...).unwrap()`** em caminho de I/O + dependência
+   nova para serializar `&[f32]` que o projeto já serializa em JSON;
+   crates.io inacessível no ambiente ⇒ dependência adicional
+   inaceitável. **SHA-256 implementado em Rust puro** (FIPS 180-4,
+   ~90 linhas) com os vetores oficiais como teste (cp0a).
+
+**Errata de linguagem**: "Se M existe e H(W) == M.hash, então W é
+matematicamente idêntico ao salvo" — exagero; o correto é
+**indistinguibilidade computacional** com P[colisão] ≤ 2⁻¹²⁸ (limite de
+aniversário, CP-3). Truncamento é capturado DETERMINISTICAMENTE pelo
+campo `tamanho`.
+
+### 4.3 O que foi implementado (Teos CP-1, CP-2, CP-3 em `checkpoint.rs`)
+
+Ordem de durabilidade: `write(W.tmp) → fsync(W.tmp) → rename(W) →
+write(M.tmp) → fsync(M.tmp) → rename(M) → fsync(dir)`. Manifesto
+lado-a-lado `{ck}.manifest.json` = `{versao, algoritmo, hash_sha256,
+tamanho}`. API: `salvar_atomico`, `carregar_verificado` (Err se
+manifesto ausente/divergente), `validar` (bool p/ Python),
+`sha256_hex`. Integrado em `gerador.salvar`, `tokenizador.salvar`,
+`Bpe.salvar` (python) — **os carregadores legados permanecem**
+(compatibilidade v0.9.0; nada removido); acrescentados
+`carregar_verificado` (gerador/tokenizador) e `carregar` nativo do
+tokenizador (antes só existia no helper Python).
+
+**Custo**: manifesto de 140–141 B por checkpoint (overhead 5,8e-7 do
+checkpoint de 240,9 MB); SHA-256 ≈ 1,1 s/240 MB em release single-thread
+(medido dentro do salvar; amornado pelo próprio treino).
+
+### 4.4 Testes (6 novos + drill Python)
+
+cp0a (vetores FIPS: vazio, "abc", 3-blocos), cp1a (roundtrip + tmp
+limpo), cp1b (**falha simulada** — dir somente-leitura ⇒ Err e o
+checkpoint ANTERIOR permanece válido), cp3a (adulteração 1 byte),
+cp3b (truncamento), cp4a (manifesto ausente recusado), cp5a (manifesto
+de outro arquivo recusado). **Drill Python** (política de resume do CLI):
+íntegro→"válido"; adulterado→"corrompido (apagado)"; legado→reuso com
+detecção por parse.
+
+## §5 — Validação com dataset real (Wikipédia PT-BR)
+
+Pipeline A/B/C fresco na pilha v0.10.0 (1.121 sequências ctx=256,
+`wikimedia/wikipedia 20231101.pt`, streaming controlado; o
+`telemetria_fase_c.jsonl` residual da v0.9.0 foi apagado antes — §1):
+
+| fase | antes | depois | custo | observação |
+|---|---|---|---|---|
+| A (tokenizador GSQ+RCO) | 9,8818 | **8,7258** | 449 s | acc_recon 0,123; **δ_ort 1,01e-06** (ortogonalidade exata em treino real) |
+| B (gerador NCM) | 4,1010 | **3,8219** | 266 s | abaixo do acaso ln 64 = 4,159 (aprendizado real) |
+| C (conjunto, p/ FNH) | 3,7730 | **3,7508** | cap 400 s | δ_ort 2,0e-07; π(C)=0,000 ⇒ gate corretamente FECHADO (homeostase: punição saudável) |
+
+Checkpoints verificados pós-treino: tokenizador 240.853.123 B
+(sha256 `202e9d9fbeba8551…`, válido), gerador 59.527.584 B
+(`74a7a4595b1b4b20…`, válido). Resume subsequente via CLI:
+"válido → reutilizando" (as fases A/B não retreinaram — prova
+criptográfica de que o estado em disco é o salvo).
+
+**Leitura honesta**: as magnitudes de perda são comparáveis às da v0.9.0
+(CE C ≈ 3,75–3,93 dependendo do lote; confiança absoluta segue na casa
+0,01–0,02, o débito de 10–50× compute das r-07/r-27/r-32 permanece). O
+que a v0.10.0 PROVA é a **integridade e a reprodutibilidade do estado**
+— o que a crítica 3 pedia — sem regressão de aprendizado.
+
+## §6 — Crítica 2 + Proposta 4: CLI unificado (MLOps)
+
+**Análise**: a pasta `scripts/` tem 36 arquivos numerados — factualmente
+correto. A proposta "substituir por um CLI declarativo" foi **rejeitada
+nos termos**: (a) os scripts numerados são a **trilha de rastreabilidade**
+das memórias (r-04 cita "scripts 39-43", r-22 cita "48-54", r-27 "59",
+r-32 "61-66", r-33 "68-69", r-34 "70-74"); (b) a regra da casa proíbe
+remover funcionalidade eficaz; (c) o exemplo de código da proposta
+referencia `K.Config`/`K.treinar_fase_a` (corretos por coincidência) mas
+inventa `validar_integridade` sem fonte e fixa `fase 1|2|3` — o pipeline
+real tem fases A/B/C com parâmetros distintos.
+
+**Implementação (aditiva)**: `scripts/75_cli.py` (Typer 0.23):
+`versao`, `coletar`, `treinar` (com pré-validação SHA-256 dos
+checkpoints — política §4.4), `verificar-checkpoints` (relatório),
+`suite`, `telemetria`, `publicar` (exige `--confirmar` + `HF_TOKEN` no
+ambiente), `estados` (varre/apaga estados locais). Delegação por
+subprocess aos scripts canônicos — **zero duplicação de lógica**.
+
+## §7 — Autocrítica (minha)
+
+1. **O split quase reintroduziu o problema que criticava**: a 1ª
+   tentativa criou `python/{jepa, pensamento, verificador}.rs` — nomes
+   que SOMBREIAM `crate::{jepa, pensamento, verificador}` via
+   `use super::*` + `use crate::*`. Detectado pelos erros E0425/E0433,
+   corrigido com renomes (`jepa_treinos`, `pensamento_demos`,
+   `calibracao`). Lição: divisão por domínio exige auditoria de colisão
+   de nomes com a raiz do crate.
+2. **Dois passos de edição quebrados meus** (stub vazio em
+   `carregar_de_txt`; substituição que apagou `carregar_verificado`
+   em vez de precedê-lo) — ambos capturados pelo compilador antes de
+   qualquer teste/publicação; o corpo original do `tokenizador::carregar`
+   foi recuperado do git (não existia — era helper Python; reimplementado
+   nativo como ADIÇÃO).
+3. **O drill de corrupção falhou na 1ª execução por erro MEU** no cenário
+   (manifesto com `tamanho: 15` para 16 bytes) — a função agiu
+   CORRETAMENTE (tamanho divergente ⇒ corrompido). O "fracasso" do
+   teste era o teste funcionando; documentado aqui porque um leitor
+   apressado teria "corrigido" a função errada.
+4. **fnh.rs (57,6 kB) agora é o maior arquivo** — próximo do menor
+   monólito criticado (50,9 kB). Não dividido nesta versão: suas
+   responsabilidades (rotações/cayley/suavizador/gate/camada) são
+   coesas sob o domínio FNH e a divisão adicionaria acoplamento
+   artificial; registrado como débito de observação.
+5. **A medição incremental tem ruído da máquina** (±0,15 s) — por isso o
+   grupo de controle; a conclusão (refutação de O(N/k) em granularidade
+   de arquivo) é robusta ao ruído porque o EFEITO alegado seria de
+   ordens de magnitude, não de 15%.
+6. **`versao()` estava fixada em "0.9.0"** — corrigida para derivar de
+   `CARGO_PKG_VERSION` (o build antigo mentia a própria versão; um
+   bug meu de versões anteriores que a telemetria v0.10.0 expôs).
+
+## §8 — Débitos honestos remanescentes
+
+- **Divisão em crates (workspace)** para o ganho O(N/k) real de
+  compilação: especificado em CK-0, não executado (custo de migração
+  PyO3/feature-unification alto; benefício atual pequeno — builds frios
+  de 68–86 s não justificam).
+- **fsync de diretório é Linux-only** (`#[cfg(unix)]`); em plataformas
+  sem fsync de dir aberto, a durabilidade do rename fica a cargo do SO
+  (documentado no fonte).
+- **SHA-256 single-thread** (~1,1 s/240 MB): paralelizável por blocos se
+  os checkpoints crescerem de ordem de magnitude.
+- **Telemetria jsonl da fase C** continua append sem manifesto — é log,
+  não estado; o resume tolera linha parcial (parse por linha) mas não a
+  valida por hash (extensão: rotacionar com hash por segmento).
+- **Kani** para os newtypes: mesmo débito justificado da r-34 §6.
+- **Confiança absoluta 0,01–0,02** segue exigindo 10–50× compute
+  (herdado); a v0.10.0 garante a INTEGRIDADE do estado que se tem, não
+  a magnitude do aprendizado.
+
+## §9 — Rastreabilidade (afirmação → decisão → código)
+
+| prova | sítio | teste |
+|---|---|---|
+| CK-0 (granularidade) | r-35 §2.1/§2.4 | medições §2.3 (telemetria_v010.json.compilacao) |
+| CK-1 (composição B×T) | camadas.rs (doc do trait) | ck1a |
+| CP-1 (troca atômica) | checkpoint.rs | cp1a, cp1b |
+| CP-2 (durabilidade ordenada) | checkpoint.rs | cp1a + ordem no código |
+| CP-3 (detecção) | checkpoint.rs | cp0a, cp3a, cp3b, cp5a |
+| T-V3 (γ ∈ (0,∞) por construção) | tipos.rs | tv3a/b/c |
+| T-V3 fronteira verificador | verificador.rs | tv3d, tv3e |
+| MoeComPapel bit-a-bit | camadas.rs | ck1c |
+| política de resume | scripts/75_cli.py | drill §4.4 + treino real §5 |
+
+**Gates consolidados (script 77)**: 107/107 = 97 herdados v0.9.0 + 10
+novos (s1×3, s2×1[2 checkpoints], s3s4×1, s5×4, s6×1). Cargo 123/123
+(107 herdados + 16 novos). Determinismo preservado pela construção
+aditiva (nenhum caminho existente alterado semanticamente; oráculos
+legados intactos).

pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "maturin"
 
 [project]
 name = "khtst-rust"
-version = "0.9.0"
-description = "KHTST_RUST — NCM com verificador calibrado, MoEs redirecionáveis com forward canônico (gradiente íntegro), FNH com skew O(n²) e calibração vetorial, FFI Python isolada em feature e newtypes de domínio (críticas Qwen3.8 analisadas/provadas/testadas em r-34)"
+version = "0.10.0"
+description = "KHTST_RUST — v0.10.0: SRP nos módulos, checkpoints atômicos com prova criptográfica, tipos de domínio com invariantes, polimorfismo de camadas e CLI MLOps unificada (críticas Qwen3.8 lote 3 analisadas/provadas/testadas em r-35)"
 requires-python = ">=3.10"
 license = { text = "Apache-2.0" }
 

resultados/fase_a_v010.json

@@ -0,0 +1,14 @@
+{
+ "fase": "a",
+ "resumo": {
+  "acc_recon": 0.123046875,
+  "delta_ort_max": 1.012120244413075e-06,
+  "escore_aprendizado": 0.34142467641580315,
+  "monotonia_prefixo": 0.5,
+  "passos": 400,
+  "perda_final": 8.72581958770752,
+  "perda_inicial": 9.88181209564209,
+  "perplexidade_codebook": 54.26808964591084
+ },
+ "tempo_s": 449.4470684528351
+}

resultados/fase_b_v010.json

@@ -0,0 +1,11 @@
+{
+ "fase": "b",
+ "resumo": {
+  "acc_conceitos": 0.10212053571428571,
+  "escore_aprendizado": 0.19593913663076906,
+  "passos": 400,
+  "perda_final": 3.8218880721500943,
+  "perda_inicial": 4.1010067122323175
+ },
+ "tempo_s": 265.64751839637756
+}

resultados/suite_v010_final.json

@@ -0,0 +1,159 @@
+{
+ "versao": "0.10.0",
+ "blocos": {
+  "legado_v090": "97/97",
+  "s1_divisao_srp": "3/3",
+  "s2_checkpoint_atomico": "2/2",
+  "s3s4_tipos_trait": "1/1",
+  "s5_treino_real": "4/4",
+  "s6_cli": "1/1"
+ },
+ "gates": {
+  "legado_legado_legado_legado_calibracao_soundness.v1_calibracao": true,
+  "legado_legado_legado_legado_calibracao_soundness.v2_soundness": true,
+  "legado_legado_legado_legado_calibracao_soundness.v3_tau_positivo": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.aprendeu": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.terminou": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.sem_oraculo": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.calibrado": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.ganho_nao_negativo": true,
+  "legado_legado_legado_legado_ciclo_d_sem_oraculo.verificador_sem_oraculo": true,
+  "legado_legado_legado_legado_escalonamento_n.tp2_ncm": true,
+  "legado_legado_legado_legado_fase_c.verificador_sem_oraculo": true,
+  "legado_legado_legado_legado_fase_c.calibracao_nll_otima": true,
+  "legado_legado_legado_legado_fase_c.ece_aceitavel_para_soundness": true,
+  "legado_legado_legado_legado_fase_c.correcao_ativa": true,
+  "legado_legado_legado_legado_fase_c.acoplador_sem_timeout": true,
+  "legado_legado_legado_legado_fase_c.acoplador_duplex_ativo": true,
+  "legado_legado_legado_legado_fase_c.confianca_pos_nao_inferior": true,
+  "legado_legado_legado_legado_fase_c.backbone_preservado": true,
+  "legado_legado_legado_legado_fase_c.pcgrad_sem_conflito_observado": true,
+  "legado_legado_legado_legado_provas_mr.mr1_capacidade": true,
+  "legado_legado_legado_legado_provas_mr.mr1_perda_aux": true,
+  "legado_legado_legado_legado_provas_mr.mr2_neutralidade": true,
+  "legado_legado_legado_legado_provas_mr.mr3_paralelismo": true,
+  "legado_legado_legado_legado_provas_mr.mr5_water_filling": true,
+  "legado_legado_legado_legado_jepa_moe.jepa_moe_aprende": true,
+  "legado_legado_legado_legado_jepa_moe.jepa_moe_vs_densa": true,
+  "legado_legado_legado_legado_jepa_moe.jepa_moe_vs_pequena": true,
+  "legado_legado_legado_legado_som_moe.moe_refina": true,
+  "legado_legado_legado_legado_som_moe.redirect_decodifica": true,
+  "legado_legado_legado_legado_som_moe.wf_melhor_uniforme": true,
+  "legado_legado_legado_legado_acoplador_duplo.duplex_simultaneo": true,
+  "legado_legado_legado_legado_acoplador_duplo.sem_timeout": true,
+  "legado_legado_legado_legado_acoplador_duplo.terminou": true,
+  "legado_legado_legado_legado_iter.gate_ucb1_encontrou_moe": true,
+  "legado_legado_legado_legado_iter.gate_gap_positivo_vs_baseline": true,
+  "legado_legado_legado_legado_iter.gate_arrependimento_pequeno": true,
+  "legado_legado_legado_legado_iter.gate_regulacao_ocorreu": true,
+  "legado_legado_legado_legado_iter.gate_parada_ou_teto": true,
+  "legado_legado_legado_legado_iter.gate_melhor_aprendeu": true,
+  "legado_legado_legado_legado_iter.a1_tau_quantil": true,
+  "legado_legado_legado_legado_iter.a2_b_finito": true,
+  "legado_legado_legado_legado_iter.a3_n_reduzido": true,
+  "legado_legado_legado_legado_iter.a4_ucb1_achou": true,
+  "legado_legado_legado_legado_iter.a5_gate_subiu": true,
+  "legado_legado_legado_legado_legada_suite_v": true,
+  "legado_legado_legado_legado_cargo_54": true,
+  "legado_legado_legado_fnh_f1_so_n_exato": true,
+  "legado_legado_legado_fnh_f3_gate_zona_morta": true,
+  "legado_legado_legado_fnh_f3_gate_abre": true,
+  "legado_legado_legado_fnh_f4_homeostase_theta_congelado": true,
+  "legado_legado_legado_fnh_f4_rotacao_aprende_com_punicao": true,
+  "legado_legado_legado_fnh_a2_delta_ort_treino_real": true,
+  "legado_legado_legado_fnh_a3_punicao_real_medida": true,
+  "legado_legado_legado_arvore_quebra_t1_invariantes": true,
+  "legado_legado_legado_arvore_quebra_t2_agregacao_exata": true,
+  "legado_legado_legado_arvore_quebra_t3_teto_simetrico": true,
+  "legado_legado_legado_arvore_quebra_q1_executa_real": true,
+  "legado_legado_legado_arvore_quebra_q2_soundness_aceites": true,
+  "legado_legado_legado_arvore_quebra_q3_invariantes_pos_quebra": true,
+  "legado_legado_legado_arvore_quebra_q4_punicao_registrada": true,
+  "legado_legado_legado_arvore_quebra_q5_sintetico_mistura_aceita_rejeita": true,
+  "legado_legado_legado_nlp_nlg_n_coerencia_ok": true,
+  "legado_legado_legado_nlp_nlg_n_espec_ok": true,
+  "legado_legado_legado_nlp_nlg_n_gate_medio_ok": true,
+  "legado_legado_legado_nlp_nlg_n_nlg_neutro": true,
+  "legado_legado_legado_nlp_nlg_n_nlp_neutro": true,
+  "legado_legado_legado_nlp_nlg_n_ctx_real_bigramas_unicos": true,
+  "legado_legado_legado_nlp_nlg_s_piso_ok": true,
+  "legado_legado_legado_nlp_nlg_s_qe_sobe": true,
+  "legado_legado_legado_nlp_nlg_s_stop_dispara": true,
+  "legado_legado_legado_nlp_nlg_s_tetos_ok": true,
+  "legado_legado_legado_telemetria_painel_v070": true,
+  "legado_legado_legado_treino_real_completo": true,
+  "legado_legado_q1_newton_menos_avaliacoes": true,
+  "legado_legado_q1_newton_mesmo_t": true,
+  "legado_legado_q1_newton_nll_nao_piora": true,
+  "legado_legado_q3_cayley_ambos_exatos": true,
+  "legado_legado_q3_cayley_cayley_mais_rapido": true,
+  "legado_legado_q2_arvore_iguais_bit_a_bit": true,
+  "legado_legado_q4_moe_bug_v080_1_confirmado": true,
+  "legado_legado_q4_moe_gradiente_restaurado": true,
+  "legado_legado_q4_moe_valores_iguais": true,
+  "legado_legado_q5_ablacao_moe_aprende_3x": true,
+  "legado_legado_q5_ablacao_moe_domina_pequena_3x": true,
+  "legado_legado_cargo_todos_verdes": true,
+  "legado_q1_skew_bits_identicos": true,
+  "legado_q1_skew_mais_rapido_n128": true,
+  "legado_q2_calibrar_bit_a_bit": true,
+  "legado_q2_calibrar_nao_regride": true,
+  "legado_q3_forward_valores_e_gradiente": true,
+  "legado_q4_newtypes_fronteira_validada": true,
+  "legado_real_gate_abre_com_punicao_alta": true,
+  "legado_real_gate_fecha_com_punicao_baixa": true,
+  "legado_real_rotacao_aprende": true,
+  "legado_real_so_n_exato": true,
+  "legado_real_ce_decresce": true,
+  "legado_q5_compila_sem_python": true,
+  "s1_nenhum_arquivo_acima_60kB": true,
+  "s1_monolitos_dissolvidos": true,
+  "s1_testes_herdados_preservados": true,
+  "s2_checkpoints_sha256_validos": true,
+  "s3s4_testes_novos_16": true,
+  "s5a_faseA_perda_cai": true,
+  "s5b_faseB_perda_cai": true,
+  "s5c_faseC_ce_cai": true,
+  "s5d_ortogonalidade_exata": true,
+  "s6_cli_comandos": true
+ },
+ "medicoes": {
+  "maior_arquivo": {
+   "caminho": "src/fnh.rs",
+   "kB": 57.6
+  },
+  "cargo_total": 123,
+  "checkpoints": {
+   "tokenizador_conceitos.json": {
+    "valido": true,
+    "manifesto_bytes": 141
+   },
+   "gerador_conceitos.json": {
+    "valido": true,
+    "manifesto_bytes": 140
+   }
+  },
+  "testes_novos_v010": 16,
+  "treino_real": {
+   "a": {
+    "perda_inicial": 9.88181209564209,
+    "perda_final": 8.72581958770752,
+    "delta_ort_max": 1.012120244413075e-06
+   },
+   "b": {
+    "perda_inicial": 4.1010067122323175,
+    "perda_final": 3.8218880721500943
+   },
+   "c": {
+    "ce_inicial": 3.773000853402274,
+    "ce_final": 3.750825984137399,
+    "taxa_gatilho": null
+   }
+  },
+  "cli": {
+   "versao": "khtst-rust-0.10.0",
+   "checkpoints_relacionados": 2
+  }
+ },
+ "veredito": "107/107 — APROVADO"
+}

resultados/telemetria_v010.json

@@ -0,0 +1,155 @@
+{
+ "versao": "0.10.0",
+ "estrutura": {
+  "arquivos_fonte": 61,
+  "maior_arquivo": {
+   "caminho": "src/fnh.rs",
+   "bytes": 57580
+  },
+  "monolitos_v090_bytes": {
+   "src/python.rs": 112410,
+   "src/jepa.rs": 58407,
+   "src/pensamento.rs": 53408,
+   "src/moe_redirecionavel.rs": 50941
+  },
+  "subdirs": [
+   "src/jepa",
+   "src/moe_redirecionavel",
+   "src/pensamento",
+   "src/python"
+  ],
+  "arquivos_por_diretorio": {
+   "src": 31,
+   "src/jepa": 8,
+   "src/moe_redirecionavel": 6,
+   "src/pensamento": 5,
+   "src/python": 11
+  }
+ },
+ "compilacao": {
+  "frio_dominio_s": 68,
+  "frio_completo_s": 86,
+  "frio_dominio_v090_s": 70,
+  "frio_completo_v090_s": 85,
+  "overhead_python_pct": 20.9,
+  "incremental_toque_s": {
+   "v090_jepa_rs_monolito": 1.06,
+   "v010_jepa_variantes": 1.13,
+   "v090_pensamento_rs_monolito": 1.13,
+   "v010_pensamento_motor": 1.15,
+   "v090_moe_rs_monolito": 1.05,
+   "v010_moe_nucleo": 1.2,
+   "controle_tipos_rs_v090": 1.21,
+   "controle_tipos_rs_v010": 1.19
+  },
+  "nota": "a alegação O(N/k) da crítica 1 é REFUTADA em granularidade de arquivo: o custo incremental (~1,1s) é dominado pelo overhead fixo do rustc/cargo, não pelo tamanho do arquivo tocado (controle tipos.rs varia igual). O ganho comprovado da divisão é SRP/manutenibilidade; builds frios neutros (70→68s, 85→86s). Ganhos O(N/k) exigiriam divisão em crates (workspace) — analisado teoricamente em r-35 §2.4."
+ },
+ "testes": {
+  "cargo_total": 123,
+  "herdados_v090": 107,
+  "novos_v010": 16,
+  "novos": [
+   "cp0a_sha256_vetores_fips",
+   "cp1a_salvar_carregar_roundtrip",
+   "cp1b_falha_preserva_anterior",
+   "cp3a_adulteracao_detectada",
+   "cp3b_truncamento_detectado",
+   "cp4a_manifesto_ausente_recusado",
+   "cp5a_manifesto_de_outro_recusado",
+   "tv3a_construtores_recusam_fora_do_dominio",
+   "tv3b_fechamento_inversao",
+   "tv3c_de_gamma_concorda",
+   "tv3d_nll_tipada_equivalente",
+   "tv3e_verificador_fronteira",
+   "ck1a_composicao_heterogenea_preserva_bt",
+   "ck1b_parametros_nao_vazios",
+   "ck1c_adaptador_bit_a_bit",
+   "ck2a_despacho_homeostatico"
+  ],
+  "saida": "ok"
+ },
+ "checkpoints": {
+  "tokenizador_conceitos.json": {
+   "existe": true,
+   "valido_sha256": true,
+   "bytes": 240853123,
+   "manifesto_bytes": 141,
+   "hash_prefixo": "202e9d9fbeba8551…"
+  },
+  "gerador_conceitos.json": {
+   "existe": true,
+   "valido_sha256": true,
+   "bytes": 59527584,
+   "manifesto_bytes": 140,
+   "hash_prefixo": "74a7a4595b1b4b20…"
+  }
+ },
+ "treino_real": {
+  "a": {
+   "perda_inicial": 9.88181209564209,
+   "perda_final": 8.72581958770752,
+   "tempo_s": 449.4
+  },
+  "b": {
+   "perda_inicial": 4.1010067122323175,
+   "perda_final": 3.8218880721500943,
+   "tempo_s": 265.6
+  },
+  "c": {
+   "ce_inicial": 3.773000853402274,
+   "ce_final": 3.750825984137399,
+   "taxa_gatilho_media": null,
+   "ece_final": null
+  }
+ },
+ "modulos": [
+  {
+   "caminho": "src/fnh.rs",
+   "kB": 57.6
+  },
+  {
+   "caminho": "src/treino.rs",
+   "kB": 47.0
+  },
+  {
+   "caminho": "src/som4d.rs",
+   "kB": 37.2
+  },
+  {
+   "caminho": "src/verificador.rs",
+   "kB": 28.2
+  },
+  {
+   "caminho": "src/arvore_pesos.rs",
+   "kB": 27.8
+  },
+  {
+   "caminho": "src/controlador.rs",
+   "kB": 25.3
+  },
+  {
+   "caminho": "src/pensamento/motor.rs",
+   "kB": 24.8
+  },
+  {
+   "caminho": "src/tokenizador.rs",
+   "kB": 20.9
+  },
+  {
+   "caminho": "src/python/pensamento_demos.rs",
+   "kB": 19.3
+  },
+  {
+   "caminho": "src/moe_redirecionavel/nucleo.rs",
+   "kB": 18.8
+  },
+  {
+   "caminho": "src/telemetria.rs",
+   "kB": 18.4
+  },
+  {
+   "caminho": "src/nlg.rs",
+   "kB": 18.3
+  }
+ ]
+}

resultados/treino_v090.json

@@ -1,33 +1,33 @@
 {
  "versao": "0.9.0",
- "build": "khtst-rust-0.9.0",
+ "build": "khtst-rust-0.10.0",
  "dados": {
   "sequencias": 1121,
   "fonte": "wikimedia/wikipedia 20231101.pt"
  },
  "fases": {
   "c": {
-   "acordos_medios": 0.5188963732356818,
-   "ce_final": 3.9293200288500105,
-   "ce_gatilhada_com_correcao": 4.091411646335356,
-   "ce_gatilhada_sem_correcao": 4.073794892270078,
-   "ce_inicial": 3.9499684742518832,
-   "confianca_media_final": 0.0002814010949805379,
-   "confianca_media_inicial": 0.00025644380366429687,
-   "confianca_pos_correcao": 0.0002146976511745203,
-   "decaimento_delta": 0.8004814077785324,
-   "ece_antes": 0.0153643210651353,
-   "ece_depois": 0.002648286405019462,
-   "escore_aprendizado": 0.20041952236591176,
-   "maior_sobreposicao_us": 5,
-   "passos": 169,
-   "rodadas_acoplador": 155,
-   "tau_c": 0.015690743923187256,
+   "acordos_medios": 0.5037088430928356,
+   "ce_final": 3.750825984137399,
+   "ce_gatilhada_com_correcao": 4.067766536110994,
+   "ce_gatilhada_sem_correcao": 4.0559665174328225,
+   "ce_inicial": 3.773000853402274,
+   "confianca_media_final": 0.18228887021541595,
+   "confianca_media_inicial": 0.1729295253753662,
+   "confianca_pos_correcao": 0.17216802735818676,
+   "decaimento_delta": 0.8236299321747604,
+   "ece_antes": 0.11367493326542899,
+   "ece_depois": 0.026873455557506542,
+   "escore_aprendizado": 0.20192427652934322,
+   "maior_sobreposicao_us": 10,
+   "passos": 180,
+   "rodadas_acoplador": 163,
+   "tau_c": 0.0171622633934021,
    "taxa_conflito_pcgrad": 0.0,
-   "taxa_gatilho": 0.6020710059171598,
-   "temperatura_calibrada": 8.0,
+   "taxa_gatilho": 0.5041666666666667,
+   "temperatura_calibrada": 0.2975706511869346,
    "timeouts_acoplador": 0,
-   "tempo_s": 403.8611032962799
+   "tempo_s": 255.78383922576904
   }
  },
  "arvore": {
@@ -168,17 +168,17 @@
   "punicao_normalizada_fase_c": 0.0,
   "abacao_sintetica": {
    "punicao_alta": {
-    "delta_ort": 2.064895173658083e-07,
+    "delta_ort": 1.9774252730388464e-07,
     "gate_final": 0.9413755384972873,
-    "perda_final": 0.02014596201479435,
-    "perda_inicial": 0.02049672044813633,
-    "theta_norma": 0.042591993338429654
+    "perda_final": 0.018947146832942963,
+    "perda_inicial": 0.020190276205539703,
+    "theta_norma": 0.06030914626997405
    },
    "punicao_baixa": {
     "delta_ort": 0.0,
     "gate_final": 0.0,
-    "perda_final": 0.022267581894993782,
-    "perda_inicial": 0.02211258001625538,
+    "perda_final": 0.03298451378941536,
+    "perda_inicial": 0.03268986567854881,
     "theta_norma": 0.0
    }
   },

scripts/75_cli.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""KHTST-RUST — CLI MLOps unificada (v0.10.0, crítica Qwen3.8 lote 3 nº 2).
+
+**Por que FAÇADA e não substituição:** a proposta original ("substituir
+por um CLI declarativo") violaria duas regras do projeto: (a) os scripts
+numerados são a trilha de rastreabilidade das memórias r-XX (cada prova
+cita "scripts 39-74"); (b) aprimoramentos não removem funcionalidade
+eficaz. O CLI unifica o ENTRY POINT (um só comando para todo o pipeline)
+delegando via subprocess aos scripts canônicos — zero duplicação de
+lógica, zero remoção — e acrescenta o que não existia: validação de
+integridade criptográfica dos checkpoints ANTES do resume (Teo CP-1..3,
+r-35 §4) e gestão de estados locais.
+
+Uso:
+    python scripts/75_cli.py versao
+    python scripts/75_cli.py treinar --validar-checkpoints
+    python scripts/75_cli.py verificar-checkpoints
+    python scripts/75_cli.py estados [--apagar]
+    python scripts/75_cli.py coletar|suite|telemetria|publicar [--confirmar]
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+app = typer.Typer(help="Pipeline KHTST-RUST v0.10.0 — fachada unificada (r-35 §6)")
+
+RAIZ = Path(__file__).resolve().parent.parent
+RESULTADOS = RAIZ / "resultados"
+CHECKPOINTS = [
+    RESULTADOS / "tokenizador_conceitos.json",
+    RESULTADOS / "gerador_conceitos.json",
+]
+
+# scripts canônicos por estágio (trilha r-XX preservada)
+DELEGACAO = {
+    "coletar": "70_coleta_shards_v090.py",
+    "treinar": "71_treino_v090.py",
+    "suite": "77_suite_v010.py",
+    "telemetria": "76_telemetria_v010.py",
+    "publicar": "78_publicar_v010.py",
+}
+
+# padrões de estados de treino (mesma lista da varredura pós-publicação)
+PADROES_ESTADO = [
+    "*.pt", "*.npz", "*.ckpt", "*.safetensors", "*.estado.json",
+    "**/*.pt", "**/*.npz", "**/*.ckpt", "**/*.safetensors", "**/*.estado.json",
+]
+
+
+def _delega(estagio: str, extra: list[str] | None = None) -> int:
+    script = DELEGACAO[estagio]
+    cmd = [sys.executable, str(RAIZ / "scripts" / script)] + (extra or [])
+    typer.echo(f"→ {estagio}: {' '.join(cmd)}", err=True)
+    return subprocess.run(cmd, cwd=RAIZ).returncode
+
+
+@app.command()
+def versao() -> None:
+    """Versão do núcleo Rust e informação de build."""
+    import khtst_rust as k
+    typer.echo(k.versao())
+    typer.echo(k.info_build())
+
+
+@app.command()
+def coletar() -> None:
+    """Coleta shards reais (Wikipédia PT-BR, streaming controlado)."""
+    raise typer.Exit(_delega("coletar"))
+
+
+def _valida_ou_regenera(ck: Path, k) -> str:
+    """Política de resume com prova de integridade (CP-1..CP-3):
+    - não existe              → 'ausente'   (treina)
+    - manifesto bate (SHA256) → 'válido'    (reusa — rápido)
+    - manifesto divergente    → 'corrompido' (APAGA e retreina: nunca
+      reusa estado em silêncio)
+    - sem manifesto (legado)  → 'legado'    (reusa; o carregador legado
+      falha alto em JSON truncado — detecção por parse)
+    """
+    if not ck.exists():
+        return "ausente"
+    if k.checkpoint_valido(str(ck)):
+        return "válido"
+    tem_manifesto = k.checkpoint_manifesto(str(ck)) is not None
+    if tem_manifesto:
+        ck.unlink(missing_ok=True)
+        Path(str(ck) + ".manifest.json").unlink(missing_ok=True)
+        return "corrompido (apagado — será retreinado)"
+    return "legado (sem manifesto; parse do carregador detecta truncamento)"
+
+
+@app.command()
+def treinar(
+    validar_checkpoints: bool = typer.Option(
+        True, "--validar-checkpoints/--nao-validar",
+        help="Valida SHA-256 dos checkpoints antes do resume (Teo CP-3)."),
+) -> None:
+    """Pipeline A/B/C (script 71) com pré-validação de integridade."""
+    import khtst_rust as k
+    if validar_checkpoints:
+        for ck in CHECKPOINTS:
+            estado = _valida_ou_regenera(ck, k)
+            typer.echo(f"checkpoint {ck.name}: {estado}")
+    raise typer.Exit(_delega("treinar"))
+
+
+@app.command()
+def verificar_checkpoints() -> None:
+    """Relatório de integridade (SHA-256 + tamanho) dos checkpoints."""
+    import khtst_rust as k
+    achou = False
+    for ck in RESULTADOS.rglob("*.json"):
+        if ck.name.endswith(".manifest.json"):
+            continue
+        manifesto = k.checkpoint_manifesto(str(ck))
+        if manifesto is None:
+            continue
+        achou = True
+        m = json.loads(manifesto)
+        valido = k.checkpoint_valido(str(ck))
+        typer.echo(
+            f"{'✓' if valido else '✗'} {ck.name}: sha256={m['hash_sha256'][:16]}… "
+            f"tamanho={m['tamanho']}B algoritmo={m['algoritmo']} "
+            f"versão={m['versao']}")
+    if not achou:
+        typer.echo("nenhum checkpoint com manifesto encontrado")
+
+
+@app.command()
+def suite() -> None:
+    """Suíte consolidada de gates v0.10.0 (script 77)."""
+    raise typer.Exit(_delega("suite"))
+
+
+@app.command()
+def telemetria() -> None:
+    """Coleta telemetria do projeto v0.10.0 (script 76)."""
+    raise typer.Exit(_delega("telemetria"))
+
+
+@app.command()
+def publicar(
+    confirmar: bool = typer.Option(False, "--confirmar",
+                                   help="Executa o upload único ao HF (script 74)."),
+) -> None:
+    """Publicação organizada no HF — exige --confirmar."""
+    if not confirmar:
+        typer.echo("publicação não confirmada: use --confirmar (upload único, "
+                   "HF_TOKEN apenas via variável de ambiente)")
+        raise typer.Exit(2)
+    if not os.environ.get("HF_TOKEN"):
+        typer.echo("HF_TOKEN ausente no ambiente — defina antes de publicar")
+        raise typer.Exit(2)
+    raise typer.Exit(_delega("publicar"))
+
+
+@app.command()
+def estados(
+    apagar: bool = typer.Option(False, "--apagar",
+                                help="Apaga os estados encontrados (regeneráveis)."),
+) -> None:
+    """Varre (e opcionalmente apaga) estados de treino do ambiente local."""
+    achados: list[Path] = []
+    for padrao in PADROES_ESTADO:
+        achados.extend(RAIZ.rglob(padrao))
+    achados = sorted(set(p for p in achados if "target" not in p.parts
+                         and ".git" not in p.parts))
+    if not achados:
+        typer.echo("0 estados de treino no ambiente local")
+        return
+    total = 0
+    for p in achados:
+        tam = p.stat().st_size
+        total += tam
+        typer.echo(f"{'apagando' if apagar else 'achado'}: {p.relative_to(RAIZ)} "
+                   f"({tam / 1e6:.1f} MB)")
+        if apagar:
+            p.unlink()
+    typer.echo(f"total: {len(achados)} arquivos, {total / 1e6:.1f} MB"
+               + (" — apagados" if apagar else " (use --apagar para remover)"))
+
+
+if __name__ == "__main__":
+    app()

scripts/76_telemetria_v010.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""76_telemetria_v010.py — telemetria do projeto v0.10.0 (críticas Qwen3.8
+lote 3): estrutura pós-divisão SRP, tempos de compilação (frios em target
+dir separado + incrementais por toque — experimento da alegação de
+"Amdahl da compilação"), contagens de testes, integridade dos checkpoints
+(SHA-256) e inventário de módulos.
+Saída: resultados/telemetria_v010.json
+"""
+import json, os, re, subprocess, time
+
+PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+def run(cmd, env=None, **kw):
+    return subprocess.run(cmd, capture_output=True, text=True,
+                          cwd=PASTA, env=env, **kw)
+
+def main():
+    rel = {"versao": "0.10.0"}
+
+    # ---- estrutura: monólitos dissolvidos (SRP)
+    src = os.path.join(PASTA, "src")
+    arquivos = []
+    for raiz, _, nfs in os.walk(src):
+        for n in nfs:
+            if n.endswith(".rs"):
+                p = os.path.join(raiz, n)
+                arquivos.append((os.path.relpath(p, PASTA), os.path.getsize(p)))
+    arquivos.sort(key=lambda x: -x[1])
+    monolitos_v090 = {  # tamanhos na v0.9.0 (pré-split) — r-34/medição
+        "src/python.rs": 112410, "src/jepa.rs": 58407,
+        "src/pensamento.rs": 53408, "src/moe_redirecionavel.rs": 50941,
+    }
+    rel["estrutura"] = {
+        "arquivos_fonte": len(arquivos),
+        "maior_arquivo": {"caminho": arquivos[0][0], "bytes": arquivos[0][1]},
+        "monolitos_v090_bytes": monolitos_v090,
+        "subdirs": sorted({os.path.dirname(a) for a, _ in arquivos
+                           if os.path.dirname(a) != "src"}),
+        "arquivos_por_diretorio": {
+            d: sum(1 for a, _ in arquivos if os.path.dirname(a) == d)
+            for d in sorted({os.path.dirname(a) for a, _ in arquivos})},
+    }
+
+    # ---- compilação (medições da sessão, target dirs separados p/ frios)
+    rel["compilacao"] = {
+        "frio_dominio_s": 68,   # cargo test --no-default-features --no-run (CARGO_TARGET_DIR limpo)
+        "frio_completo_s": 86,  # cargo test --all-features --no-run (CARGO_TARGET_DIR limpo)
+        "frio_dominio_v090_s": 70, "frio_completo_v090_s": 85,  # r-34 (mesmo protocolo)
+        "overhead_python_pct": round(100 * (86 - 68) / 86, 1),
+        # experimento "Amdahl da compilação" (r-35 §2.3): toque único,
+        # mediana de 3, build incremental — monólito vs submódulo
+        "incremental_toque_s": {
+            "v090_jepa_rs_monolito": 1.06, "v010_jepa_variantes": 1.13,
+            "v090_pensamento_rs_monolito": 1.13, "v010_pensamento_motor": 1.15,
+            "v090_moe_rs_monolito": 1.05, "v010_moe_nucleo": 1.20,
+            "controle_tipos_rs_v090": 1.21, "controle_tipos_rs_v010": 1.19,
+        },
+        "nota": "a alegação O(N/k) da crítica 1 é REFUTADA em granularidade "
+                "de arquivo: o custo incremental (~1,1s) é dominado pelo "
+                "overhead fixo do rustc/cargo, não pelo tamanho do arquivo "
+                "tocado (controle tipos.rs varia igual). O ganho comprovado "
+                "da divisão é SRP/manutenibilidade; builds frios neutros "
+                "(70→68s, 85→86s). Ganhos O(N/k) exigiriam divisão em crates "
+                "(workspace) — analisado teoricamente em r-35 §2.4.",
+    }
+
+    # ---- testes (execução fresca; contagem oficial)
+    r = run(["cargo", "test", "--all-features", "--quiet"])
+    m = re.findall(r"test result: ok\. (\d+) passed", r.stdout)
+    total = sum(int(x) for x in m)
+    rel["testes"] = {
+        "cargo_total": total,
+        "herdados_v090": 107,
+        "novos_v010": total - 107,
+        "novos": ["cp0a_sha256_vetores_fips", "cp1a_salvar_carregar_roundtrip",
+                  "cp1b_falha_preserva_anterior", "cp3a_adulteracao_detectada",
+                  "cp3b_truncamento_detectado", "cp4a_manifesto_ausente_recusado",
+                  "cp5a_manifesto_de_outro_recusado",
+                  "tv3a_construtores_recusam_fora_do_dominio",
+                  "tv3b_fechamento_inversao", "tv3c_de_gamma_concorda",
+                  "tv3d_nll_tipada_equivalente", "tv3e_verificador_fronteira",
+                  "ck1a_composicao_heterogenea_preserva_bt",
+                  "ck1b_parametros_nao_vazios", "ck1c_adaptador_bit_a_bit",
+                  "ck2a_despacho_homeostatico"],
+        "saida": r.stdout[-400:] if r.returncode else "ok",
+    }
+
+    # ---- integridade dos checkpoints (SHA-256 + manifesto)
+    import khtst_rust as k
+    R = os.path.join(PASTA, "resultados")
+    cks = {}
+    for nome in ("tokenizador_conceitos.json", "gerador_conceitos.json"):
+        p = os.path.join(R, nome)
+        if os.path.exists(p):
+            m_ = k.checkpoint_manifesto(p)
+            cks[nome] = {
+                "existe": True, "valido_sha256": k.checkpoint_valido(p),
+                "bytes": os.path.getsize(p),
+                "manifesto_bytes": os.path.getsize(p + ".manifest.json") if m_ else None,
+                "hash_prefixo": (json.loads(m_)["hash_sha256"][:16] + "���") if m_ else None,
+            }
+        else:
+            cks[nome] = {"existe": False}
+    rel["checkpoints"] = cks
+
+    # ---- treino real v0.10.0 (Wikipédia PT-BR — pipeline A/B/C fresco)
+    treino = {}
+    for f, chave in (("fase_a_v010.json", "a"), ("fase_b_v010.json", "b")):
+        p = os.path.join(R, f)
+        if os.path.exists(p):
+            d = json.load(open(p))
+            treino[chave] = {"perda_inicial": d["resumo"]["perda_inicial"],
+                             "perda_final": d["resumo"]["perda_final"],
+                             "tempo_s": round(d["tempo_s"], 1)}
+    p = os.path.join(R, "treino_v090.json")
+    if os.path.exists(p):
+        d = json.load(open(p))
+        c = d.get("fases", {}).get("c", {})
+        if c:
+            treino["c"] = {k2: c.get(k2) for k2 in
+                           ("ce_inicial", "ce_final", "taxa_gatilho_media", "ece_final")}
+    rel["treino_real"] = treino
+
+    # ---- inventário de módulos (top 12 por tamanho)
+    rel["modulos"] = [{"caminho": a, "kB": round(b / 1e3, 1)} for a, b in arquivos[:12]]
+
+    saida = os.path.join(R, "telemetria_v010.json")
+    json.dump(rel, open(saida, "w"), indent=1, ensure_ascii=False)
+    print(f"OK: {saida}")
+    print(json.dumps({k: rel[k] for k in ("estrutura", "compilacao", "testes")},
+                     indent=1, ensure_ascii=False)[:1200])
+
+if __name__ == "__main__":
+    main()

scripts/77_suite_v010.py

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

scripts/78_publicar_v010.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""78_publicar_v010.py — Publicação da v0.10.0 no HF (UM ÚNICO upload_folder
+organizado — o HF bloqueia envios parciais em sequência; upload atômico).
+
+Fases:
+  1. inventário da conta + APAGAMENTO de estados de treino remanescentes;
+  2. varredura local do VALOR do token (nenhum arquivo pode contê-lo);
+  3. UM ÚNICO upload_folder com ignore_patterns EXPLÍCITOS +
+     delete_patterns p/ monólitos dissolvidos (src/jepa.rs → src/jepa/…);
+  4. verificação pós-upload (0 estados, módulos-chave presentes);
+  5. varredura REMOTA do valor do token;
+  6. apagamento dos estados de treino LOCAIS (checkpoints + manifestos).
+
+v0.10.0: manifestos (*.manifest.json) NÃO são publicados — só têm sentido
+ao lado do checkpoint correspondente (que também não é publicado).
+Token: EXCLUSIVAMENTE via variável de ambiente HF_TOKEN (nunca em arquivo).
+"""
+import os, sys, tempfile
+
+ARQUIVOS_EXCLUIR_DIRS = {"target", ".cargo", "__pycache__", ".git", ".venv",
+                         "skills", "externos"}
+ARQUIVOS_EXCLUIR_NOME = {"shard_treino.jsonl", "shard_validacao.jsonl",
+                         "bpe.json", "rustup-init.sh"}
+SUFIXOS_ESTADO = (".pt", ".pth", ".ckpt", ".safetensors", ".bin", ".npz",
+                  ".msgpack")
+NOMES_ESTADO = {"gerador_conceitos.json", "tokenizador_conceitos.json",
+                "gerador_aritmetica.json", "_drill_ck.json"}
+# monólitos da v0.9.0 dissolvidos em diretórios na v0.10.0 (r-35 §2)
+MONOLITOS_VELHOS = ["src/python.rs", "src/jepa.rs", "src/pensamento.rs",
+                    "src/moe_redirecionavel.rs"]
+
+def coletar(pasta):
+    arquivos = {}
+    for raiz, dirs, fs in os.walk(pasta):
+        dirs[:] = [d for d in dirs if d not in ARQUIVOS_EXCLUIR_DIRS]
+        for f in fs:
+            if f in ARQUIVOS_EXCLUIR_NOME or f in NOMES_ESTADO:
+                continue
+            if f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json"):
+                continue
+            if f.endswith(".manifest.json") or f.endswith(".manifest.json.tmp"):
+                continue
+            if f.endswith(".so") or f in (".gitignore", "Cargo.lock.ori"):
+                continue
+            if f.startswith("hf_") or f.startswith("intros_"):
+                continue
+            caminho = os.path.join(raiz, f)
+            arquivos[os.path.relpath(caminho, pasta)] = caminho
+    return arquivos
+
+def varre_token_em_arquivos(token, pares):
+    tb = token.encode()
+    achados = []
+    for rel, p in pares.items():
+        try:
+            with open(p, "rb") as f:
+                if tb in f.read():
+                    achados.append(rel)
+        except OSError:
+            pass
+    return achados
+
+def main():
+    from huggingface_hub import HfApi
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("ERRO: HF_TOKEN ausente"); sys.exit(1)
+    api = HfApi(token=token)
+    repo = "PowerMachine/khtst-rust"
+
+    # ---------------- 1) inventário da conta + apaga estados ----------------
+    print("=== 1) inventário da conta HF (procura estados de treino) ===")
+    repos = list(api.list_models(author="PowerMachine"))
+    print(f"repos: {len(repos)}")
+    total_removidos = 0
+    for r in repos:
+        try:
+            files = api.list_repo_files(repo_id=r.id, repo_type="model")
+        except Exception as e:
+            print(f"  {r.id}: erro ao listar ({e})"); continue
+        estados = [f for f in files
+                   if f.endswith(SUFIXOS_ESTADO)
+                   or f.split("/")[-1] in NOMES_ESTADO
+                   or (".meta.json" in f and "checkpoint" in f)]
+        if estados:
+            print(f"  {r.id}: APAGANDO {len(estados)} estados")
+            for f in estados:
+                api.delete_file(path_in_repo=f, repo_id=r.id, repo_type="model")
+            total_removidos += len(estados)
+        else:
+            print(f"  {r.id}: {len(files)} arquivos, 0 estados")
+    print(f"estados removidos no total: {total_removidos}")
+
+    # ---------------- 2) varredura local do token ----------------
+    pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    arquivos = coletar(pasta)
+    print(f"\n=== 2) varredura local: {len(arquivos)} arquivos ===")
+    achados = varre_token_em_arquivos(token, arquivos)
+    if achados:
+        print(f"ERRO: valor do token encontrado em: {achados}"); sys.exit(1)
+    print("varredura de token local: limpa")
+
+    # ---------------- 3) UM ÚNICO upload_folder ----------------
+    ignores = (
+        [f"{d}/**" for d in ARQUIVOS_EXCLUIR_DIRS]
+        + [f"{d}" for d in ARQUIVOS_EXCLUIR_DIRS]
+        + [f"**/{n}" for n in ARQUIVOS_EXCLUIR_NOME]
+        + [f"**/{n}" for n in NOMES_ESTADO]
+        + list(SUFIXOS_ESTADO)
+        + ["*.so", ".gitignore", "hf_*.py", "hf_*.json", "intros_*.json",
+           "*.estado.json", "**/*.manifest.json", "**/*.manifest.json.tmp",
+           "*.tmp"]
+    )
+    print(f"\n=== 3) upload_folder ÚNICO ({len(arquivos)} arquivos) ===")
+    api.upload_folder(
+        repo_id=repo, repo_type="model", folder_path=pasta,
+        ignore_patterns=ignores,
+        delete_patterns=MONOLITOS_VELHOS,
+        commit_message="v0.10.0: análise/prova/teste das críticas de "
+        "engenharia Qwen3.8 lote 3 (r-35) — divisão SRP dos monólitos "
+        "jepa/pensamento/moe/python em 26 submódulos (API estável via "
+        "re-exports; 'Amdahl de compilação' refutada por experimento "
+        "controlado, builds frios neutros), checkpoints atômicos SHA-256 "
+        "puro FIPS 180-4 + fsync + rename + manifesto (CP-1..CP-3; "
+        "correções da proposta: sem destruir estado anterior, manifesto "
+        "com barreira, sem bincode/unwrap), TemperaturaInversa T-V3 "
+        "(fronteira tipada da convexidade N-2; alegação compile-time "
+        "corrigida), trait CamadaKhtst+CamadaHomeostatica (premissa do "
+        "controlador refutada no fonte; Vec<Var>; adaptador MoeComPapel "
+        "bit-a-bit), CLI Typer 75 (fachada aditiva com resume verificado "
+        "por hash) — 123/123 cargo, 107/107 gates, treino real Wikipédia "
+        "PT-BR com checkpoints íntegros",
+    )
+    print("upload concluído")
+
+    # ---------------- 4) verificação pós-upload ----------------
+    print("\n=== 4) verificação pós-upload ===")
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+    estados = [f for f in files if f.endswith(SUFIXOS_ESTADO)
+               or f.split("/")[-1] in NOMES_ESTADO
+               or f.endswith(".manifest.json")]
+    assert not estados, f"estados publicados: {estados}"
+    chaves = ["src/checkpoint.rs", "src/tipos.rs", "src/camadas.rs",
+              "src/jepa/mod.rs", "src/pensamento/mod.rs",
+              "src/moe_redirecionavel/mod.rs", "src/python/mod.rs",
+              "src/fnh.rs", "src/verificador.rs",
+              "scripts/75_cli.py", "scripts/76_telemetria_v010.py",
+              "scripts/77_suite_v010.py", "scripts/78_publicar_v010.py",
+              "docs/memorias/r-35-analise-provas-qwen-v010.md",
+              "resultados/suite_v010_final.json",
+              "resultados/telemetria_v010.json",
+              "resultados/fase_a_v010.json", "resultados/fase_b_v010.json",
+              "resultados/treino_v090.json"]
+    faltando = [c for c in chaves if c not in files]
+    assert not faltando, f"faltando: {faltando}"
+    velhos = [m for m in MONOLITOS_VELHOS if m in files]
+    assert not velhos, f"monólitos velhos ainda no repo: {velhos}"
+    print(f"repo: {len(files)} arquivos | 0 estados | módulos-chave OK | "
+          f"monólitos velhos removidos")
+
+    # ---------------- 5) varredura REMOTA do token ----------------
+    print("\n=== 5) varredura REMOTA do valor do token ===")
+    with tempfile.TemporaryDirectory() as tmp:
+        achados_remotos = []
+        for f in files:
+            if f.endswith((".py", ".rs", ".md", ".json", ".toml", ".sh", ".cfg",
+                           ".txt", ".jsonl")):
+                try:
+                    p = api.hf_hub_download(repo_id=repo, repo_type="model",
+                                            filename=f, local_dir=tmp)
+                    with open(p, "rb") as fh:
+                        if token.encode() in fh.read():
+                            achados_remotos.append(f)
+                except Exception:
+                    pass
+        if achados_remotos:
+            print(f"ERRO: token remoto em: {achados_remotos}"); sys.exit(1)
+    print("varredura remota: limpa")
+
+    # ---------------- 6) apaga estados de treino LOCAIS ----------------
+    print("\n=== 6) estados de treino locais (checkpoints + manifestos) ===")
+    apagados = 0
+    for nome in sorted(NOMES_ESTADO):
+        for sufixo in ("", ".manifest.json"):
+            p = os.path.join(pasta, "resultados", nome + sufixo)
+            if os.path.exists(p):
+                os.remove(p)
+                apagados += 1
+                print(f"  apagado: resultados/{nome}{sufixo}")
+    print(f"locais apagados: {apagados}")
+    print("\nPUBLICAÇÃO v0.10.0 CONCLUÍDA")
+
+if __name__ == "__main__":
+    main()

src/camadas.rs

@@ -136,3 +136,165 @@ impl Swiglu {
         [self.w1.vars(), self.w3.vars(), self.w2.vars()].concat()
     }
 }
+
+// ===========================================================================
+// v0.10.0 — Polimorfismo de camadas (crítica Qwen3.8 lote 3, proposta 1,
+// CORRIGIDA; r-35 §3). A proposta original tinha três problemas:
+//
+//   (a) a PREMISSA era falsa: `controlador.rs` NÃO referencia Fnh/Moe/Jepa
+//       (verificado por busca no fonte — o controlador regula
+//       hiperparâmetros, não despacha camadas);
+//   (b) `parametros() -> Vec<&Tensor>` QUEBRA o otimizador: a partir de
+//       `&Tensor` não se recupera a `Var` para atualização in-place — a
+//       assinatura correta devolve `Vec<Var>`;
+//   (c) `gate_ativacao` na interface-base viola a segregação de
+//       interface: nem toda camada tem gate de punição. Movida para o
+//       trait `CamadaHomeostatica` (implantável só por quem tem gate).
+//
+// A "prova" da proposta ("composição de funções lineares e ativações
+// preserva a dimensionalidade do batch") também está mal tipada: D_in →
+// D_out PODE mudar (é o que uma projeção faz). O invariante correto:
+//
+// **Teo CK-1 (invariante de composição).** Se f: R^{B×T×D1} → R^{B×T×D2}
+// e g: R^{B×T×D2} → R^{B×T×D3} operam apenas (i) mapas lineares na
+// ÚLTIMA dimensão (via reshape (B·T, D) → (B·T, D') → reshape) e (ii)
+// ativações elemento-a-elemento, então g∘f: R^{B×T×D1} → R^{B×T×D3} —
+// as dimensões de lote B e tempo T são preservadas por toda a composição.
+// Prova: o reshape é bijeção canônica R^{B×T×D} ≅ R^{(B·T)·D} que fixa
+// o produto B·T; matmul por W ∈ R^{D'×D} age à direita (índice de
+// coluna) e não permuta as linhas; ativações elemento-a-elemento agem
+// coordenada-a-coordenada. Logo cada estágio devolve exatamente B·T
+// linhas, e o reshape inverso restaura (B, T). ∎
+// ===========================================================================
+
+/// Camada com forward canônico R^{B×T×D_in} → R^{B×T×D_out} (Teo CK-1).
+pub trait CamadaKhtst {
+    /// Forward preservando as dimensões de lote/tempo (B, T).
+    fn forward(&self, x: &Tensor) -> Result<Tensor>;
+    /// Parâmetros treináveis como `Var` — o otimizador atualiza in-place
+    /// (correção (b): `Vec<&Tensor>` romperia o SGD).
+    fn parametros(&self) -> Vec<Var>;
+}
+
+/// Camada com gate de punição homeostático (segregação, correção (c)).
+/// g = max(0, 2σ((π − θ_π)/τ_g) − 1) — zona morta exata (Teo F-3).
+pub trait CamadaHomeostatica {
+    fn gate_ativacao(&self, punicao: &crate::tipos::Probabilidade)
+        -> crate::tipos::GateAtivacao;
+}
+
+impl CamadaKhtst for Linear {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        self.fwd(x)
+    }
+    fn parametros(&self) -> Vec<Var> {
+        self.vars()
+    }
+}
+
+impl CamadaKhtst for crate::jepa::MlpJepa {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        self.fwd(x)
+    }
+    fn parametros(&self) -> Vec<Var> {
+        [self.l1.vars(), self.l2.vars()].concat()
+    }
+}
+
+/// Adaptador zero-custo que CAPTURA o papel (codificador/decodificador)
+/// da MoE redirecionável, expondo o forward canônico do trait SEM perder
+/// o parâmetro: os caminhos de treino continuam usando `forward(x, papel)`
+/// completo (com perda auxiliar e carga — nada é removido); o adaptador
+/// serve a composição heterogênea de INFERÊNCIA.
+pub struct MoeComPapel<'a> {
+    pub moe: &'a crate::moe_redirecionavel::MoeRedirecionavel,
+    pub papel: crate::moe_redirecionavel::Papel,
+}
+
+impl CamadaKhtst for MoeComPapel<'_> {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        Ok(self.moe.forward(x, self.papel)?.saida)
+    }
+    fn parametros(&self) -> Vec<Var> {
+        self.moe.vars()
+    }
+}
+
+#[cfg(test)]
+mod testes_camada_khtst {
+    use super::*;
+
+    /// CK-1a — composição heterogênea `Vec<&dyn CamadaKhtst>` preserva
+    /// B×T (2, 3) através de Linear→MlpJepa (Teo CK-1) e o adaptador MoE.
+    #[test]
+    fn ck1a_composicao_heterogenea_preserva_bt() {
+        let dev = Device::Cpu;
+        let (b, t, d) = (2usize, 3usize, 8usize);
+        let lin = Linear::novo(d, 16, 0.02, &dev).unwrap();
+        let mlp = crate::jepa::MlpJepa::novo(16, 24, 32, &dev).unwrap();
+        let x0 = Tensor::randn(0f32, 1f32, (b, t, d), &dev).unwrap();
+
+        let camadas: Vec<&dyn CamadaKhtst> = vec![&lin, &mlp];
+        let mut x = x0.clone();
+        for c in &camadas {
+            x = c.forward(&x).unwrap();
+        }
+        assert_eq!(x.dims(), &[b, t, 32], "B×T preservado (Teo CK-1)");
+
+        // adaptador MoE sobre o achatado (B·T, D) — forward canônico
+        let moe = crate::moe_redirecionavel::MoeRedirecionavel::novo(32, 4, 2, 7, &dev).unwrap();
+        let adapt = MoeComPapel {
+            moe: &moe,
+            papel: crate::moe_redirecionavel::Papel::Codificador,
+        };
+        let x2d = x.reshape((b * t, 32)).unwrap();
+        let y = <MoeComPapel as CamadaKhtst>::forward(&adapt, &x2d).unwrap();
+        assert_eq!(y.dims(), &[b * t, 32]);
+    }
+
+    /// CK-1b — `parametros()` devolve `Var` NÃO-VAZIAS (otimizável).
+    #[test]
+    fn ck1b_parametros_nao_vazios() {
+        let dev = Device::Cpu;
+        let lin = Linear::novo(8, 16, 0.02, &dev).unwrap();
+        let mlp = crate::jepa::MlpJepa::novo(16, 24, 32, &dev).unwrap();
+        let moe = crate::moe_redirecionavel::MoeRedirecionavel::novo(32, 4, 2, 7, &dev).unwrap();
+        let adapt = MoeComPapel { moe: &moe, papel: crate::moe_redirecionavel::Papel::Codificador };
+        for (nome, n) in [("linear", lin.parametros().len()),
+                          ("mlp", mlp.parametros().len()),
+                          ("moe", adapt.parametros().len())] {
+            assert!(n > 0, "{nome} deveria ter parâmetros");
+        }
+    }
+
+    /// CK-1c — o adaptador delega BIT-A-BIT para moe.forward(x, papel).
+    #[test]
+    fn ck1c_adaptador_bit_a_bit() {
+        let dev = Device::Cpu;
+        let moe = crate::moe_redirecionavel::MoeRedirecionavel::novo(16, 4, 2, 11, &dev).unwrap();
+        let x = Tensor::randn(0f32, 1f32, (5, 16), &dev).unwrap();
+        let direto = moe.forward(&x, crate::moe_redirecionavel::Papel::Codificador).unwrap();
+        let adapt = MoeComPapel { moe: &moe, papel: crate::moe_redirecionavel::Papel::Codificador };
+        let via_trait = <MoeComPapel as CamadaKhtst>::forward(&adapt, &x).unwrap();
+        let a = direto.saida.flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let bvia = via_trait.flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        assert_eq!(a.len(), bvia.len());
+        for (i, (x1, x2)) in a.iter().zip(bvia.iter()).enumerate() {
+            assert_eq!(x1.to_bits(), x2.to_bits(), "elem {i} difere");
+        }
+    }
+
+    /// CK-2a — despacho homeostático heterogêneo: zona morta exata em
+    /// π < θ_π e ativação > 0 em π alto (Teo F-3 via fronteira tipada).
+    #[test]
+    fn ck2a_despacho_homeostatico() {
+        let gate = crate::fnh::GatePunicao::default();
+        let camadas: Vec<&dyn CamadaHomeostatica> = vec![&gate];
+        let baixa = crate::tipos::Probabilidade::novo(0.2).unwrap();
+        let alta = crate::tipos::Probabilidade::novo(0.95).unwrap();
+        for c in &camadas {
+            assert_eq!(c.gate_ativacao(&baixa).valor(), 0.0, "zona morta exata");
+            assert!(c.gate_ativacao(&alta).valor() > 0.0, "gate abre sob punição alta");
+        }
+    }
+}

src/checkpoint.rs

@@ -0,0 +1,353 @@
+//! Checkpoints atômicos com prova de integridade criptográfica (v0.10.0).
+//!
+//! **Crítica Qwen3.8 lote 3, nº 3 ("Checkpointing Não-Atômico") — ACEITA
+//! COM CORREÇÕES (r-35 §4).** A proposta original tinha três falhas:
+//!
+//! 1. **Destruição do estado anterior:** `File::create(caminho_pesos)`
+//!    trunca o checkpoint ANTERIOR antes de escrever o novo — uma queda
+//!    de energia no meio da escrita perde AMBOS. A atomicidade real exige
+//!    escrita em `.tmp` + `rename(2)` (o POSIX garante troca atômica).
+//! 2. **Manifesto sem barreira:** `fs::write(caminho_meta, ...)` sem
+//!    `sync_all` — o manifesto pode não atingir o disco quando os pesos
+//!    já atingiram (ou vice-versa), violando a própria ordenação alegada.
+//! 3. **Dependência nova (bincode) + `unwrap()`** em caminho de I/O.
+//!
+//! Esta implementação: SHA-256 **puro em Rust** (FIPS 180-4, sem crates
+//! externas — crates.io inacessível no ambiente), escrita tmp→fsync→
+//! rename→fsync(dir) para AMBOS os arquivos, e manifesto lado-a-lado
+//! `{caminho}.manifest.json` com hash + tamanho.
+//!
+//! **Teo CP-1 (atomicidade da troca).** `rename(2)` é atômico em relação
+//! a leitores concorrentes e crashes: em qualquer instante o caminho
+//! resolve OU para o arquivo antigo OU para o novo, nunca uma mistura.
+//! Logo um crash em qualquer ponto deixa o caminho final = checkpoint
+//! antigo (crash antes do rename) ou novo (depois). ∎ (garantia POSIX)
+//!
+//! **Teo CP-2 (durabilidade ordenada).** Com a disciplina
+//! `write(W.tmp) → fsync(W.tmp) → rename(W) → write(M.tmp) →
+//! fsync(M.tmp) → rename(M) → fsync(dir)`, após reboot: se `M` existe,
+//! então o rename de `W` foi durável (executado e journalizado antes) e
+//! os blocos de dados de `W` foram forçados por `fsync(W.tmp)` — portanto
+//! `SHA-256(W) = M.hash` (a menos de colisão, CP-3). Se `M` não existe,
+//! o estado é tratado como INVÁLIDO (não silenciosamente errado). ∎
+//!
+//! **Teo CP-3 (detecção de corrupção).** Para W' ≠ W com |W'| = |W|,
+//! `P[SHA-256(W') = SHA-256(W)] ≤ 2^-256` (ataque direto) e, para
+//! qualquer par distinto, ≤ 2^-128 (limite de aniversário). Truncamentos
+//! e gravações parciais são capturados DETERMINISTICAMENTE pelo campo
+//! `tamanho`. Nota honesta: a alegação original "matematicamente
+//! idêntico" é exagerada — o correto é indistinguibilidade computacional
+//! com probabilidade de colisão ≤ 2^-128. ∎
+//!
+//! **Compatibilidade (regra da casa: nada é removido):** checkpoints da
+//! v0.9.0 (sem manifesto) continuam carregáveis pelos `carregar` legados;
+//! `carregar_verificado` exige manifesto e recusa o contrário.
+
+use candle_core::Result;
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+
+pub const VERSAO_CHECKPOINT: &str = "0.10.0";
+
+// ---------------------------------------------------------------------------
+// SHA-256 — FIPS 180-4, implementação autocontida (sem dependências)
+// ---------------------------------------------------------------------------
+
+const K_SHA256: [u32; 64] = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+/// SHA-256 de `dados` — 32 bytes (FIPS 180-4 §6.2.2).
+pub fn sha256(dados: &[u8]) -> [u8; 32] {
+    let mut h: [u32; 8] = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ];
+    // padding: 0x80, zeros, comprimento de bit big-endian em 64 bits
+    let bitlen = (dados.len() as u64).wrapping_mul(8);
+    let mut msg = dados.to_vec();
+    msg.push(0x80);
+    while msg.len() % 64 != 56 {
+        msg.push(0);
+    }
+    msg.extend_from_slice(&bitlen.to_be_bytes());
+
+    for bloco in msg.chunks_exact(64) {
+        let mut w = [0u32; 64];
+        for (i, j) in (0..64).step_by(4).enumerate() {
+            w[i] = u32::from_be_bytes([bloco[j], bloco[j + 1], bloco[j + 2], bloco[j + 3]]);
+        }
+        for t in 16..64 {
+            let s0 = w[t - 15].rotate_right(7) ^ w[t - 15].rotate_right(18) ^ (w[t - 15] >> 3);
+            let s1 = w[t - 2].rotate_right(17) ^ w[t - 2].rotate_right(19) ^ (w[t - 2] >> 10);
+            w[t] = w[t - 16]
+                .wrapping_add(s0)
+                .wrapping_add(w[t - 7])
+                .wrapping_add(s1);
+        }
+        let (mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut hh) =
+            (h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]);
+        for t in 0..64 {
+            let s1 = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25);
+            let ch = (e & f) ^ ((!e) & g);
+            let t1 = hh
+                .wrapping_add(s1)
+                .wrapping_add(ch)
+                .wrapping_add(K_SHA256[t])
+                .wrapping_add(w[t]);
+            let s0 = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22);
+            let maj = (a & b) ^ (a & c) ^ (b & c);
+            let t2 = s0.wrapping_add(maj);
+            hh = g; g = f; f = e; e = d.wrapping_add(t1);
+            d = c; c = b; b = a; a = t1.wrapping_add(t2);
+        }
+        h[0] = h[0].wrapping_add(a); h[1] = h[1].wrapping_add(b);
+        h[2] = h[2].wrapping_add(c); h[3] = h[3].wrapping_add(d);
+        h[4] = h[4].wrapping_add(e); h[5] = h[5].wrapping_add(f);
+        h[6] = h[6].wrapping_add(g); h[7] = h[7].wrapping_add(hh);
+    }
+    let mut saida = [0u8; 32];
+    for (i, x) in h.iter().enumerate() {
+        saida[i * 4..i * 4 + 4].copy_from_slice(&x.to_be_bytes());
+    }
+    saida
+}
+
+/// SHA-256 em hexadecimal minúsculo (64 caracteres).
+pub fn sha256_hex(dados: &[u8]) -> String {
+    sha256(dados).iter().map(|b| format!("{b:02x}")).collect()
+}
+
+// ---------------------------------------------------------------------------
+// salva / carrega atômicos
+// ---------------------------------------------------------------------------
+
+/// Caminho do manifesto lado-a-lado de `caminho`.
+pub fn caminho_manifesto(caminho: &str) -> String {
+    format!("{caminho}.manifest.json")
+}
+
+fn err_io(e: std::io::Error, ctx: &str) -> candle_core::Error {
+    candle_core::Error::Msg(format!("{ctx}: {e}"))
+}
+
+/// fsync de um diretório (durabilidade do rename — POSIX). Unix apenas;
+/// em outras plataformas é no-op documentado.
+fn fsync_dir(dir: &Path) -> std::io::Result<()> {
+    #[cfg(unix)]
+    {
+        let d = File::open(dir)?;
+        d.sync_all()?;
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = dir;
+    }
+    Ok(())
+}
+
+/// Escrita atômica de `conteudo` em `caminho` com fsync + rename e
+/// manifesto `{caminho}.manifest.json` (hash SHA-256 + tamanho).
+///
+/// Ordem (Teo CP-2): write(tmp) → fsync(tmp) → rename(final) para o
+/// conteúdo e para o manifesto; fsync(dir) ao final.
+pub fn salvar_atomico(caminho: &str, conteudo: &str) -> Result<()> {
+    let dados = conteudo.as_bytes();
+    let hash = sha256_hex(dados);
+    let tmp = format!("{caminho}.tmp");
+
+    // 1) conteúdo: tmp → fsync → rename (Teo CP-1: troca atômica)
+    {
+        let mut f = File::create(&tmp).map_err(|e| err_io(e, "checkpoint: criar tmp"))?;
+        f.write_all(dados).map_err(|e| err_io(e, "checkpoint: escrever tmp"))?;
+        f.sync_all().map_err(|e| err_io(e, "checkpoint: fsync tmp"))?;
+    }
+    std::fs::rename(&tmp, caminho).map_err(|e| err_io(e, "checkpoint: rename"))?;
+
+    // 2) manifesto: mesma disciplina (a proposta original usava fs::write
+    //    simples — sem barreira, o manifesto pode perder-se sozinho)
+    let manifest = serde_json::json!({
+        "versao": VERSAO_CHECKPOINT,
+        "algoritmo": "sha256",
+        "hash_sha256": hash,
+        "tamanho": dados.len(),
+    });
+    let mtxt = serde_json::to_string(&manifest)
+        .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
+    let mtmp = format!("{}.manifest.json.tmp", caminho);
+    {
+        let mut f = File::create(&mtmp).map_err(|e| err_io(e, "manifesto: criar tmp"))?;
+        f.write_all(mtxt.as_bytes()).map_err(|e| err_io(e, "manifesto: escrever tmp"))?;
+        f.sync_all().map_err(|e| err_io(e, "manifesto: fsync tmp"))?;
+    }
+    std::fs::rename(&mtmp, caminho_manifesto(caminho))
+        .map_err(|e| err_io(e, "manifesto: rename"))?;
+
+    // 3) durabilidade dos renames (POSIX: rename journalizado no dir)
+    if let Some(pai) = Path::new(caminho).parent() {
+        fsync_dir(pai).map_err(|e| err_io(e, "checkpoint: fsync dir"))?;
+    }
+    Ok(())
+}
+
+/// Lê `caminho` verificando o manifesto (hash + tamanho). Recusa
+/// manifesto ausente ou divergente — Teo CP-3.
+pub fn carregar_verificado(caminho: &str) -> Result<String> {
+    let dados = std::fs::read(caminho).map_err(|e| err_io(e, "checkpoint: ler"))?;
+    let mtxt = std::fs::read_to_string(caminho_manifesto(caminho))
+        .map_err(|_| candle_core::Error::Msg(format!(
+            "checkpoint sem manifesto (legado v0.9.0?): {caminho}")))?;
+    let m: serde_json::Value = serde_json::from_str(&mtxt)
+        .map_err(|e| candle_core::Error::Msg(format!("manifesto ilegível: {e}")))?;
+    let hash_esp = m["hash_sha256"].as_str().unwrap_or("");
+    let tam_esp = m["tamanho"].as_u64().unwrap_or(u64::MAX);
+    let hash_rec = sha256_hex(&dados);
+    if (dados.len() as u64) != tam_esp {
+        candle_core::bail!(
+            "checkpoint corrompido: tamanho {} ��� manifesto {} ({caminho})",
+            dados.len(), tam_esp);
+    }
+    if hash_rec != hash_esp {
+        candle_core::bail!(
+            "checkpoint corrompido: SHA-256 divergente ({caminho})");
+    }
+    String::from_utf8(dados)
+        .map_err(|e| candle_core::Error::Msg(format!("utf8: {e}")))
+}
+
+/// Verificação sem exceção (para uso em Python/CLI antes de resume).
+pub fn validar(caminho: &str) -> bool {
+    carregar_verificado(caminho).is_ok()
+}
+
+#[cfg(test)]
+mod testes_checkpoint {
+    use super::*;
+
+    fn tmp_dir(nome: &str) -> std::path::PathBuf {
+        let d = std::env::temp_dir().join(format!("khtst_cp_{nome}_{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+
+    /// CP-0a — SHA-256 contra os vetores oficiais FIPS 180-4.
+    #[test]
+    fn cp0a_sha256_vetores_fips() {
+        assert_eq!(
+            sha256_hex(b""),
+            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+        assert_eq!(
+            sha256_hex(b"abc"),
+            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+        assert_eq!(
+            sha256_hex(b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
+            "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
+        // vetor de 4 blocos (256 bytes) — exercita o laço de blocos
+        let longo = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn".repeat(4);
+        assert_eq!(sha256_hex(longo.as_bytes()).len(), 64);
+    }
+
+    /// CP-1a — salvar produz final + manifesto; tmp não permanece;
+    /// carregar_verificado devolve o conteúdo bit-a-bit.
+    #[test]
+    fn cp1a_salvar_carregar_roundtrip() {
+        let d = tmp_dir("rt");
+        let p = d.join("ck.json");
+        salvar_atomico(p.to_str().unwrap(), "{\"v0\":[1.0,2.0]}").unwrap();
+        assert!(p.exists());
+        assert!(d.join("ck.json.manifest.json").exists());
+        assert!(!d.join("ck.json.tmp").exists());
+        assert!(!d.join("ck.json.manifest.json.tmp").exists());
+        assert_eq!(carregar_verificado(p.to_str().unwrap()).unwrap(),
+                   "{\"v0\":[1.0,2.0]}");
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
+    /// CP-3a — adulteração de 1 byte é detectada (hash divergente).
+    #[test]
+    fn cp3a_adulteracao_detectada() {
+        let d = tmp_dir("t");
+        let p = d.join("ck.json");
+        salvar_atomico(p.to_str().unwrap(), "conteudo original").unwrap();
+        std::fs::write(&p, "conteudo originalX").unwrap();
+        assert!(carregar_verificado(p.to_str().unwrap()).is_err());
+        assert!(!validar(p.to_str().unwrap()));
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
+    /// CP-3b — truncamento detectado pelo tamanho (determinístico).
+    #[test]
+    fn cp3b_truncamento_detectado() {
+        let d = tmp_dir("tr");
+        let p = d.join("ck.json");
+        salvar_atomico(p.to_str().unwrap(), "0123456789").unwrap();
+        std::fs::write(&p, "0123").unwrap();
+        assert!(carregar_verificado(p.to_str().unwrap()).is_err());
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
+    /// CP-4a — manifesto ausente ⇒ recusa (estado legado é do `carregar`).
+    #[test]
+    fn cp4a_manifesto_ausente_recusado() {
+        let d = tmp_dir("leg");
+        let p = d.join("ck.json");
+        salvar_atomico(p.to_str().unwrap(), "x").unwrap();
+        std::fs::remove_file(d.join("ck.json.manifest.json")).unwrap();
+        assert!(carregar_verificado(p.to_str().unwrap()).is_err());
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
+    /// CP-1b — falha de escrita PRESERVA o checkpoint anterior
+    /// (atomicidade prática: dir somente-leitura impede o create do tmp).
+    #[test]
+    fn cp1b_falha_preserva_anterior() {
+        let d = tmp_dir("fa");
+        let p = d.join("ck.json");
+        salvar_atomico(p.to_str().unwrap(), "estado_bom").unwrap();
+        // dir somente-leitura: File::create(tmp) falha
+        let mut perms = std::fs::metadata(&d).unwrap().permissions();
+        #[allow(clippy::unnecessary_cast)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            perms.set_mode(0o555);
+        }
+        std::fs::set_permissions(&d, perms).unwrap();
+        let r = salvar_atomico(p.to_str().unwrap(), "estado_novo");
+        let mut perms2 = std::fs::metadata(&d).unwrap().permissions();
+        #[allow(clippy::unnecessary_cast)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            perms2.set_mode(0o755);
+        }
+        std::fs::set_permissions(&d, perms2).unwrap();
+        assert!(r.is_err(), "escrita deveria falhar em dir somente-leitura");
+        // o anterior permanece ÍNTEGRO e válido (Teo CP-1)
+        assert_eq!(carregar_verificado(p.to_str().unwrap()).unwrap(), "estado_bom");
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
+    /// CP-5a — manifesto trocado entre arquivos (hash de outro) recusa.
+    #[test]
+    fn cp5a_manifesto_de_outro_recusado() {
+        let d = tmp_dir("sw");
+        let a = d.join("a.json");
+        let b = d.join("b.json");
+        salvar_atomico(a.to_str().unwrap(), "AAAA").unwrap();
+        salvar_atomico(b.to_str().unwrap(), "BBBB").unwrap();
+        std::fs::copy(d.join("b.json.manifest.json"), d.join("a.json.manifest.json")).unwrap();
+        assert!(carregar_verificado(a.to_str().unwrap()).is_err());
+        let _ = std::fs::remove_dir_all(&d);
+    }
+}

src/fnh.rs

@@ -570,6 +570,13 @@ impl GatePunicao {
     }
 }
 
+impl crate::camadas::CamadaHomeostatica for GatePunicao {
+    fn gate_ativacao(&self, punicao: &crate::tipos::Probabilidade)
+        -> crate::tipos::GateAtivacao {
+        self.valor_tipado(punicao)
+    }
+}
+
 /// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de
 /// canais e ativação flexível, GATADA pela punição do treino (r-28 §4.1).
 pub struct CamadaFNH {

src/gerador.rs

@@ -246,18 +246,27 @@ impl GeradorConceitos {
         }
         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::checkpoint::salvar_atomico(caminho, &txt)
+    }
+
+    /// Carrega com verificação de integridade (manifesto SHA-256 — v0.10.0).
+    /// Recusa checkpoints corrompidos/legados-sem-manifesto (Teo CP-3).
+    pub fn carregar_verificado(&mut self, caminho: &str) -> Result<()> {
+        let txt = crate::checkpoint::carregar_verificado(caminho)?;
+        self.carregar_de_txt(&txt)
     }
 
     /// Carrega um checkpoint salvo por `salvar` (mesma ordem de construção
     /// de `novo` ⇒ índices de variáveis casam 1-a-1 — ajuste fino honesto).
+    /// Caminho LEGADO: sem verificação de manifesto (compatibilidade v0.9.0).
     pub fn carregar(&mut self, caminho: &str) -> Result<()> {
         let txt = std::fs::read_to_string(caminho)
             .map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
-        let obj: serde_json::Map<String, serde_json::Value> = serde_json::from_str(&txt)
+        self.carregar_de_txt(&txt)
+    }
+
+    fn carregar_de_txt(&mut self, txt: &str) -> Result<()> {
+        let obj: serde_json::Map<String, serde_json::Value> = serde_json::from_str(txt)
             .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
         let vars = self.vars();
         for (i, v) in vars.iter().enumerate() {

src/jepa/mascaras.rs

@@ -0,0 +1,173 @@
+//! `jepa::mascaras` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Parte 2 — máscaras
+// ---------------------------------------------------------------------------
+
+/// Máscara de blocos 2D (Image-JEPA): grade (h, w) de patches; sorteia
+/// `n_blocos` retângulos aleatórios com fração alvo `frac` de patches.
+pub fn mascara_blocos_2d(h: usize, w: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    let total = h * w;
+    let alvo = (total as f64 * frac) as usize;
+    let mut masc = vec![false; total];
+    let mut coberto = 0usize;
+    for _ in 0..n_blocos.max(1) {
+        if coberto >= alvo {
+            break;
+        }
+        let bh = 1 + rng.inteiro(h.min(4));
+        let bw = 1 + rng.inteiro(w.min(4));
+        let y0 = rng.inteiro(h + 1 - bh);
+        let x0 = rng.inteiro(w + 1 - bw);
+        for y in y0..y0 + bh {
+            for x in x0..x0 + bw {
+                let i = y * w + x;
+                if !masc[i] {
+                    masc[i] = true;
+                    coberto += 1;
+                }
+            }
+        }
+    }
+    masc
+}
+
+/// Máscara de tubos 3D (V-JEPA 2): grade (t, h, w); tubos = retângulos que
+/// atravessam o tempo.
+pub fn mascara_tubos_3d(t: usize, h: usize, w: usize, n_tubos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    let total = t * h * w;
+    let alvo = (total as f64 * frac) as usize;
+    let mut masc = vec![false; total];
+    let mut coberto = 0usize;
+    for _ in 0..n_tubos.max(1) {
+        if coberto >= alvo {
+            break;
+        }
+        let bh = 1 + rng.inteiro(h.min(3));
+        let bw = 1 + rng.inteiro(w.min(3));
+        let y0 = rng.inteiro(h + 1 - bh);
+        let x0 = rng.inteiro(w + 1 - bw);
+        for tt in 0..t {
+            for y in y0..y0 + bh {
+                for x in x0..x0 + bw {
+                    let i = (tt * h + y) * w + x;
+                    if !masc[i] {
+                        masc[i] = true;
+                        coberto += 1;
+                    }
+                }
+            }
+        }
+    }
+    masc
+}
+
+/// Máscara de bandas (Audio-JEPA): grade (f, tau) — bandas de frequência
+/// horizontais com extensão temporal.
+pub fn mascara_bandas(f: usize, tau: usize, n_bandas: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    mascara_blocos_2d(f, tau, n_bandas, frac, rng) // blocos na grade (f, tau)
+}
+
+/// Máscara de blocos 3D (3D-JEPA): grade (x, y, z) de voxels.
+pub fn mascara_blocos_3d(x: usize, y: usize, z: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    mascara_tubos_3d(x, y, z, n_blocos, frac, rng)
+}
+
+/// Máscara de segmentos canal×tempo (Brain-JEPA): canais inteiros OU
+/// janelas temporais (aleatório por chamada).
+pub fn mascara_segmentos(c: usize, t: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    let total = c * t;
+    let alvo = (total as f64 * frac) as usize;
+    let mut masc = vec![false; total];
+    if rng.inteiro(2) == 0 {
+        // canais inteiros
+        let mut coberto = 0;
+        let mut canais: Vec<usize> = (0..c).collect();
+        // embaralhar
+        for i in (1..canais.len()).rev() {
+            let j = rng.inteiro(i + 1);
+            canais.swap(i, j);
+        }
+        for &ch in canais.iter() {
+            if coberto >= alvo {
+                break;
+            }
+            for tt in 0..t {
+                masc[ch * t + tt] = true;
+                coberto += 1;
+            }
+        }
+    } else {
+        // janelas temporais
+        let mut coberto = 0;
+        let mut t0 = 0;
+        while coberto < alvo && t0 < t {
+            let len = 1 + rng.inteiro((t / 4).max(1));
+            for ch in 0..c {
+                for tt in t0..(t0 + len).min(t) {
+                    masc[ch * t + tt] = true;
+                    coberto += 1;
+                }
+            }
+            t0 += len + 1;
+        }
+    }
+    masc
+}
+
+/// Máscara 1D (T-JEPA): intervalos contíguos em n posições.
+pub fn mascara_intervalos_1d(n: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
+    let alvo = (n as f64 * frac) as usize;
+    let mut masc = vec![false; n];
+    let mut coberto = 0;
+    while coberto < alvo {
+        let len = 1 + rng.inteiro((n / 8).max(1));
+        let i0 = rng.inteiro(n);
+        for i in i0..(i0 + len).min(n) {
+            if !masc[i] {
+                masc[i] = true;
+                coberto += 1;
+            }
+        }
+    }
+    masc
+}
+
+/// Amostragem dos pontos mais distantes (FPS) para Point-JEPA.
+pub fn pontos_mais_distantes(pontos: &[Vec<f64>], k: usize, rng: &mut RngDeterministico) -> Vec<usize> {
+    let n = pontos.len();
+    if n == 0 || k == 0 {
+        return vec![];
+    }
+    let k = k.min(n);
+    let mut centros = vec![rng.inteiro(n)];
+    let mut dist_min: Vec<f64> = pontos
+        .iter()
+        .map(|p| distancia_eucl(p, &pontos[centros[0]]))
+        .collect();
+    while centros.len() < k {
+        let prox = dist_min
+            .iter()
+            .enumerate()
+            .filter(|(i, _)| !centros.contains(i))
+            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
+            .map(|(i, _)| i)
+            .unwrap_or(0);
+        centros.push(prox);
+        for (i, p) in pontos.iter().enumerate() {
+            let d = distancia_eucl(p, &pontos[prox]);
+            if d < dist_min[i] {
+                dist_min[i] = d;
+            }
+        }
+    }
+    centros
+}
+
+pub(crate) fn distancia_eucl(a: &[f64], b: &[f64]) -> f64 {
+    a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum::<f64>().sqrt()
+}

src/jepa/mod.rs

@@ -0,0 +1,61 @@
+//! Suíte JEPA — módulos: núcleo, máscaras, patches, variantes,
+//! SonicMoE, ReplaySSM (divisão SRP v0.10.0 — r-35 §2).
+
+//! Suíte JEPA v0.5.0 — núcleo unificado + 12 variantes + SonicMoE + ReplaySSM.
+//!
+//! **Núcleo (todas as variantes compartilham):**
+//! - codificador `E_θ` (MLp SiLU), preditor `P_φ` (condicionado por posição/
+//!   ação/edição), codificador-alvo EMA `E_ξ` com `ξ ← m·ξ + (1−m)·θ`
+//!   (gradiente cortado — alvo nunca recebe gradiente);
+//! - regularizador variância-covariância (VICReg-lite) anti-colapso:
+//!   `V(z) = Σ_j max(0, γ − std(z_j))²` + fora-diagonal da covariância.
+//! - perda: `L = Σ_b ‖P(z_ctx, pos_b) − sg(ẑ_b)‖²/B + λ_vc·V`.
+//!
+//! **Prova J-1 (impossibilidade de colapso, em r-20):** se todas as
+//! incorporações colapsam para constante, `std(z_j) = 0 ∀j` ⇒ `V = d·γ² > 0`;
+//! logo o colapso total NÃO é minimizador com `λ_vc > 0`.
+//!
+//! **Prova J-2 (EMA = stop-grad + ponto fixo):** `∂L/∂ξ = 0` (detach); se
+//! `θ_t → θ*` então `ξ_t → θ*` (recursão linear contratante com `m < 1`).
+//!
+//! **Prova J-3 (decomposição de informação):** com `P` suficientemente
+//! rico, `min_P L = Σ_b Var(ẑ_b | z_ctx)` — a perda retém só o componentes
+//! previsíveis do alvo dado o contexto.
+//!
+//! **Variantes** (esquema de máscara + adaptador de modalidade):
+//! Image-JEPA (blocos 2D) · V-JEPA 2 (tubos 3D + cond. de ação) · MC-JEPA
+//! (cruz-modal, dois codificadores) · Audio-JEPA (bandas de espectrograma) ·
+//! Point-JEPA (grupos FPS) · 3D-JEPA (voxels) · Brain-JEPA (canal×tempo) ·
+//! T-JEPA (série temporal canal-independente) · LeJEPA (edição-condicionado) ·
+//! BJEPA (bidirecional com consistência de ciclo).
+//!
+//! **SonicMoE** — MoE com roteamento top-k, capacidade por especialista
+//! (tile-aware) e perda auxiliar de balanceamento (argumento Switch:
+//! `L_aux = E·Σ f_e·p_e ≥ 1` com igualdade sse uniforme).
+//!
+//! **ReplaySSM** — SSM de porta diagonal (`h_t = σ(a)⊙h_{t−1} +
+//! (1−σ(a))⊙(Bx_t)`, estabilidade herdada do Teo S-2') + replay de experiências
+//! para aprendizado continuado (interpolação de gradientes limita o
+//! esquecimento — Teo R-1).
+
+use candle_core::{Device, Result, Tensor, Var};
+use crate::camadas::Linear;
+use crate::rng::RngDeterministico;
+
+// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
+#[cfg(test)]
+mod testes;
+mod mascaras;
+mod nucleo;
+mod patches;
+mod replay_ssm;
+mod sonic_moe;
+mod variantes;
+
+pub use mascaras::*;
+pub use nucleo::*;
+pub use patches::*;
+pub use replay_ssm::*;
+pub use sonic_moe::*;
+pub use variantes::*;
+

src/jepa/nucleo.rs

@@ -0,0 +1,211 @@
+//! `jepa::nucleo` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Parte 1 — núcleo
+// ---------------------------------------------------------------------------
+
+/// MLP 2 camadas com SiLU (d → h → d_saida).
+pub struct MlpJepa {
+    pub l1: Linear,
+    pub l2: Linear,
+    pub d_entrada: usize,
+    pub d_saida: usize,
+}
+
+impl MlpJepa {
+    pub fn novo(d_entrada: usize, d_oculta: usize, d_saida: usize, dev: &Device) -> Result<Self> {
+        let s1 = (1.0 / (d_entrada as f64).sqrt()) * 0.9;
+        let s2 = (1.0 / (d_oculta as f64).sqrt()) * 0.9;
+        Ok(Self {
+            l1: Linear::sem_vies(d_entrada, d_oculta, s1, dev)?,
+            l2: Linear::sem_vies(d_oculta, d_saida, s2, dev)?,
+            d_entrada,
+            d_saida,
+        })
+    }
+
+    pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
+        let h = candle_nn::ops::silu(&self.l1.fwd(x)?)?;
+        self.l2.fwd(&h)
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        [self.l1.vars(), self.l2.vars()].concat()
+    }
+
+    /// EMA: `self ← m·self + (1−m)·outro` (usado no codificador-alvo).
+    pub fn ema_de(&mut self, outro: &MlpJepa, m: f64) -> Result<()> {
+        for (a, b) in self.vars().iter().zip(outro.vars().iter()) {
+            let novo = (a.as_tensor().affine(m, 0.0)? + b.as_tensor().affine(1.0 - m, 0.0)?)?;
+            a.set(&novo)?;
+        }
+        Ok(())
+    }
+}
+
+/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
+pub struct NucleoJepa {
+    pub encoder: MlpJepa,
+    pub preditor: MlpJepa,
+    pub alvo: MlpJepa,
+    /// tabela de posições (blocos) — entrada extra do preditor.
+    pub pos: Var,
+    pub d_emb: usize,
+    pub d_cond: usize,
+    pub m: f64,
+    pub lambda_vc: f64,
+    pub gamma_vc: f64,
+}
+
+impl NucleoJepa {
+    pub fn novo(
+        d_patch: usize,
+        d_emb: usize,
+        d_cond: usize,
+        n_pos: usize,
+        m: f64,
+        lambda_vc: f64,
+        gamma_vc: f64,
+        dev: &Device,
+    ) -> Result<Self> {
+        let encoder = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
+        let preditor = MlpJepa::novo(d_emb + d_cond + d_emb, 2 * d_emb, d_emb, dev)?;
+        // alvo nasce IGUAL ao encoder (ponto de partida do EMA)
+        let mut alvo = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
+        for (va, vb) in alvo.vars().iter().zip(encoder.vars().iter()) {
+            va.set(vb.as_tensor())?;
+        }
+        let pos_t = Tensor::randn(0f32, 0.02, (n_pos.max(1), d_emb), dev)?;
+        Ok(Self {
+            encoder,
+            preditor,
+            alvo,
+            pos: Var::from_tensor(&pos_t)?,
+            d_emb,
+            d_cond,
+            m,
+            lambda_vc,
+            gamma_vc,
+        })
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        let mut v = self.encoder.vars();
+        v.extend(self.preditor.vars());
+        v.push(self.pos.clone());
+        v // NOTA: alvo NÃO entra — é buffer EMA
+    }
+
+    pub fn ema_passo(&mut self) -> Result<()> {
+        self.alvo.ema_de(&self.encoder, self.m)
+    }
+
+    /// Codifica um conjunto de patches (n, d_patch) → (n, d_emb).
+    pub fn codificar(&self, patches: &Tensor) -> Result<Tensor> {
+        self.encoder.fwd(patches)
+    }
+
+    /// Codifica com o alvo EMA — SEM gradiente (detach por construção: as
+    /// vars do alvo não estão no otimizador e o tensor é desconectado).
+    pub fn alvo_codificar(&self, patches: &Tensor) -> Result<Tensor> {
+        Ok(self.alvo.fwd(patches)?.detach())
+    }
+
+    /// Prediz o embedding do bloco `i_pos` a partir do contexto `z_ctx`
+    /// (d_emb) e da condição `cond` (d_cond; zeros se None).
+    pub fn predizer(&self, z_ctx: &Tensor, i_pos: usize, cond: Option<&Tensor>) -> Result<Tensor> {
+        // z_ctx: (b, d_emb) ou (d_emb,)
+        let b = z_ctx.dim(0).unwrap_or(1);
+        let dev = z_ctx.device();
+        let pos = self.pos.as_tensor().get(i_pos.min(self.pos.dim(0)?.saturating_sub(1)))?;
+        let pos_b = pos.broadcast_as((b, self.d_emb))?;
+        let cond_b = match cond {
+            Some(c) => {
+                if c.dims().len() == 1 && b > 1 {
+                    c.broadcast_as((b, self.d_cond))?
+                } else {
+                    c.clone()
+                }
+            }
+            None => Tensor::zeros((b, self.d_cond), candle_core::DType::F32, dev)?,
+        };
+        let entrada = Tensor::cat(&[z_ctx, &pos_b, &cond_b], candle_core::D::Minus1)?;
+        self.preditor.fwd(&entrada)
+    }
+
+    /// Regularizador variância-covariância do lote de incorporações z (n, d).
+    ///
+    /// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ `V = d·γ²`.
+    pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
+        let n = z.dim(0)? as f64;
+        let d = self.d_emb;
+        let media = z.mean_keepdim(0)?; // (1, d)
+        let centr = z.broadcast_sub(&media)?;
+        let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
+        let std = var.sqrt()?;
+        // dobradiça: max(0, γ − std)²
+        let gamma_t =
+            Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
+        let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?;
+        let v = gap.sqr()?.sum_all()?;
+        // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C − diag‖²_F/(2d)
+        let cov = (centr.transpose(0, 1)?.matmul(&centr)? / n)?; // (d, d)
+        let mask_diag = {
+            let mut m = vec![0f32; d * d];
+            for i in 0..d {
+                m[i * d + i] = 1.0;
+            }
+            Tensor::from_vec(m, (d, d), z.device())?
+        };
+        let fora = ((&cov * &mask_diag)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
+        let v_norm = (v / d.max(1) as f64)?;
+        Ok((v_norm + fora)?)
+    }
+
+    /// Perda JEPA padrão para UM lote: contexto (número variável de patches),
+    /// lista de blocos-alvo (posições), condição opcional.
+    ///
+    /// `z_ctx` = incorporação agregada do contexto (b, d_emb);
+    /// `alvos`: para cada elemento do lote, Vec<(i_pos, patches_alvo)>.
+    pub fn perda_lote(
+        &self,
+        z_ctx: &Tensor,
+        alvos: &[Vec<(usize, Tensor)>],
+        cond: Option<&Tensor>,
+        z_ctx_todos: &Tensor,
+    ) -> Result<(Tensor, f64, f64)> {
+        let b = z_ctx.dim(0)?;
+        let dev = z_ctx.device();
+        let mut perdas: Vec<Tensor> = Vec::new();
+        let mut n_alvos = 0usize;
+        for (i, blocos) in alvos.iter().enumerate() {
+            for (i_pos, patches_alvo) in blocos {
+                // ẑ_b = média das incorporações-alvo dos patches do bloco
+                let zt = self.alvo_codificar(patches_alvo)?; // (m, d_emb)
+                let zt_m = zt.mean(0)?; // (d_emb,)
+                let zt_b = zt_m.broadcast_as((1, self.d_emb))?;
+                let zc = z_ctx.get(i)?.broadcast_as((1, self.d_emb))?;
+                let c_i = cond.map(|c| c.get(i)?.broadcast_as((1, self.d_cond))).transpose()?;
+                let pred = self.predizer(&zc, *i_pos, c_i.as_ref())?;
+                let dif = (&pred - &zt_b)?;
+                let l = (dif.sqr()?.sum_all()? / self.d_emb as f64)?;
+                perdas.push(l);
+                n_alvos += 1;
+            }
+        }
+        let l_pred = if perdas.is_empty() {
+            Tensor::zeros((), candle_core::DType::F32, &dev)?
+        } else {
+            (Tensor::stack(&perdas, 0)?.sum_all()? / n_alvos.max(1) as f64)?
+        };
+        let l_vc = self.perda_vc(z_ctx_todos)?;
+        let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(self.lambda_vc, 0.0)?)?;
+        let lp = l_pred.to_scalar::<f32>()? as f64;
+        let lv = l_vc.to_scalar::<f32>()? as f64;
+        Ok((total, lp, lv))
+    }
+}

src/jepa/patches.rs

@@ -0,0 +1,150 @@
+//! `jepa::patches` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Parte 3 — adaptadores de modalidade
+// ---------------------------------------------------------------------------
+
+/// (C, H, W) → patches (H/ph · W/pw, C·ph·pw) — Image-JEPA.
+pub fn em_patches_2d(img: &Tensor, ph: usize, pw: usize) -> Result<Tensor> {
+    let (c, h, w) = (img.dim(0)?, img.dim(1)?, img.dim(2)?);
+    let dev = img.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for y in (0..h).step_by(ph) {
+        for x in (0..w).step_by(pw) {
+            let hh = ph.min(h - y);
+            let ww = pw.min(w - x);
+            let patch = img.narrow(0, 0, c)?.narrow(1, y, hh)?.narrow(2, x, ww)?;
+            // padding para (C, ph, pw) se borda
+            let patch = if hh < ph || ww < pw {
+                let mut buf = patch.flatten_all()?.to_vec1::<f32>()?;
+                let falta = c * ph * pw - buf.len();
+                buf.extend(std::iter::repeat(0f32).take(falta));
+                Tensor::from_vec(buf, (c * ph * pw,), &dev)?
+            } else {
+                patch.flatten_all()?
+            };
+            linhas.push(patch);
+        }
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}
+
+/// (T, H, W) → tubos (T/pt · H/ph · W/pw, pt·ph·pw) — V-JEPA 2.
+pub fn em_tubos_3d(vid: &Tensor, pt: usize, ph: usize, pw: usize) -> Result<Tensor> {
+    let (t, h, w) = (vid.dim(0)?, vid.dim(1)?, vid.dim(2)?);
+    let dev = vid.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for tt in (0..t).step_by(pt) {
+        let tl = pt.min(t - tt);
+        for y in (0..h).step_by(ph) {
+            for x in (0..w).step_by(pw) {
+                let hh = ph.min(h - y);
+                let ww = pw.min(w - x);
+                let tubo = vid
+                    .narrow(0, tt, tl)?
+                    .narrow(1, y, hh)?
+                    .narrow(2, x, ww)?
+                    .flatten_all()?;
+                let mut buf = tubo.to_vec1::<f32>()?;
+                let falta = pt * ph * pw - buf.len();
+                buf.extend(std::iter::repeat(0f32).take(falta));
+                linhas.push(Tensor::from_vec(buf, (pt * ph * pw,), &dev)?);
+            }
+        }
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}
+
+/// (F, τ) → patches (F/pf · τ/pt, pf·pt) — Audio-JEPA.
+pub fn em_patches_espectrograma(spec: &Tensor, pf: usize, pt: usize) -> Result<Tensor> {
+    let (f, tau) = (spec.dim(0)?, spec.dim(1)?);
+    let dev = spec.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for i in (0..f).step_by(pf) {
+        for j in (0..tau).step_by(pt) {
+            let ff = pf.min(f - i);
+            let tt = pt.min(tau - j);
+            let p = spec.narrow(0, i, ff)?.narrow(1, j, tt)?.flatten_all()?;
+            let mut buf = p.to_vec1::<f32>()?;
+            let falta = pf * pt - buf.len();
+            buf.extend(std::iter::repeat(0f32).take(falta));
+            linhas.push(Tensor::from_vec(buf, (pf * pt,), &dev)?);
+        }
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}
+
+/// (C, T) → patches canal-independentes (C · T/pt, pt) — T-JEPA/Brain-JEPA.
+pub fn em_patches_serie(ts: &Tensor, pt: usize) -> Result<Tensor> {
+    let (c, t) = (ts.dim(0)?, ts.dim(1)?);
+    let dev = ts.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for ch in 0..c {
+        for j in (0..t).step_by(pt) {
+            let tt = pt.min(t - j);
+            let p = ts.narrow(0, ch, 1)?.narrow(1, j, tt)?.flatten_all()?;
+            let mut buf = p.to_vec1::<f32>()?;
+            let falta = pt - buf.len();
+            buf.extend(std::iter::repeat(0f32).take(falta));
+            linhas.push(Tensor::from_vec(buf, (pt,), &dev)?);
+        }
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}
+
+/// (X, Y, Z) → voxels (X/px · Y/py · Z/pz, px·py·pz) — 3D-JEPA.
+pub fn em_voxels(vol: &Tensor, px: usize, py: usize, pz: usize) -> Result<Tensor> {
+    let (x, y, z) = (vol.dim(0)?, vol.dim(1)?, vol.dim(2)?);
+    let dev = vol.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for i in (0..x).step_by(px) {
+        for j in (0..y).step_by(py) {
+            for k in (0..z).step_by(pz) {
+                let lx = px.min(x - i);
+                let ly = py.min(y - j);
+                let lz = pz.min(z - k);
+                let p = vol.narrow(0, i, lx)?.narrow(1, j, ly)?.narrow(2, k, lz)?.flatten_all()?;
+                let mut buf = p.to_vec1::<f32>()?;
+                let falta = px * py * pz - buf.len();
+                buf.extend(std::iter::repeat(0f32).take(falta));
+                linhas.push(Tensor::from_vec(buf, (px * py * pz,), &dev)?);
+            }
+        }
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}
+
+/// Nuvem de pontos (n, d) → grupos FPS (k, m·d): k centros por FPS, cada
+/// grupo = os m vizinhos mais próximos do centro (concatenados) — Point-JEPA.
+pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterministico) -> Result<Tensor> {
+    let n = pc.dim(0)?;
+    let d = pc.dim(1)?;
+    let coords = pc.to_vec2::<f32>()?;
+    let coords_f: Vec<Vec<f64>> = coords.iter().map(|r| r.iter().map(|&v| v as f64).collect()).collect();
+    let centros = pontos_mais_distantes(&coords_f, k, rng);
+    let dev = pc.device();
+    let mut linhas: Vec<Tensor> = Vec::new();
+    for &ci in &centros {
+        // m vizinhos mais próximos do centro ci (incluindo ele próprio)
+        let mut ord: Vec<usize> = (0..n).collect();
+        ord.sort_by(|&a, &b| {
+            let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
+            let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
+            da.partial_cmp(&db).unwrap()
+        });
+        let mut buf: Vec<f32> = Vec::with_capacity(m * d);
+        for &idx in ord.iter().take(m) {
+            for j in 0..d {
+                buf.push(coords[idx][j]);
+            }
+        }
+        let falta = m * d - buf.len();
+        buf.extend(std::iter::repeat(0f32).take(falta));
+        linhas.push(Tensor::from_vec(buf, (m * d,), &dev)?);
+    }
+    Ok(Tensor::stack(&linhas, 0)?)
+}

src/jepa/replay_ssm.rs

@@ -0,0 +1,107 @@
+//! `jepa::replay_ssm` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Parte 6 — ReplaySSM
+// ---------------------------------------------------------------------------
+
+/// SSM de porta diagonal com replay para aprendizado continuado.
+///
+/// Recorrência: `h_t = σ(a) ⊙ h_{t−1} + (1 − σ(a)) ⊙ (B x_t)`.
+///
+/// **Prova R-1 (estabilidade):** `|σ(a)| < 1` ⇒ perturbações de `h_0`
+/// decaem geometricamente (mesma estrutura do Teo S-2' do SSD-Δ).
+///
+/// **Prova R-2 (limite de esquecimento):** o passo de treino mistura
+/// gradientes `(1−α)·∇L_novo + α·∇L_replay`; para `L_antiga` μ-fortemente
+/// convexa com gradientes novos limitados por `G`, o afastamento do ótimo
+/// antigo por passo é `≤ (1−α)·η·G` (sem replay: `≤ η·G`) — o replay
+/// contrai o drift por um fator `1/(1−α)` no regime linear.
+pub struct ReplaySsm {
+    pub a: Var,   // (d,) — porta (sigmoid no uso)
+    pub b: Var,   // (d_in, d) — projeção de entrada
+    pub d: usize,
+    pub alpha_replay: f64,
+    pub buffer: Vec<Tensor>,
+    pub capacidade_buffer: usize,
+}
+
+impl ReplaySsm {
+    pub fn novo(d_in: usize, d: usize, alpha_replay: f64, capacidade_buffer: usize, dev: &Device) -> Result<Self> {
+        let a_t = Tensor::randn(0f32, 0.5, (d,), dev)?;
+        let b_t = Tensor::randn(0f32, 0.1, (d_in, d), dev)?;
+        Ok(Self {
+            a: Var::from_tensor(&a_t)?,
+            b: Var::from_tensor(&b_t)?,
+            d,
+            alpha_replay,
+            buffer: Vec::new(),
+            capacidade_buffer,
+        })
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        vec![self.a.clone(), self.b.clone()]
+    }
+
+    /// Scan: x (T, d_in) → h (T, d). Diferenciável (candle autograd).
+    pub fn scan(&self, x: &Tensor) -> Result<Tensor> {
+        let t = x.dim(0)?;
+        let dev = x.device();
+        let porta = candle_nn::ops::sigmoid(&self.a.as_tensor().broadcast_as((1, self.d))?)?; // (1, d)
+        let um_menos = porta.affine(-1.0, 1.0)?; // 1 − σ(a)
+        let entrada = x.matmul(&self.b.as_tensor())?; // (T, d)
+        let mut h = Tensor::zeros((1, self.d), candle_core::DType::F32, &dev)?;
+        let mut saidas: Vec<Tensor> = Vec::with_capacity(t);
+        for i in 0..t {
+            let xt = entrada.narrow(0, i, 1)?;
+            h = ((&porta * &h)? + (&um_menos * &xt)?)?;
+            saidas.push(h.clone());
+        }
+        Ok(Tensor::stack(&saidas, 0)?)
+    }
+
+    /// Empurra uma janela de treino no buffer (FIFO).
+    pub fn guardar(&mut self, x: &Tensor) {
+        if self.buffer.len() >= self.capacidade_buffer {
+            self.buffer.remove(0);
+        }
+        self.buffer.push(x.detach());
+    }
+
+    /// Um passo de treino no lote novo (com mistura de replay).
+    /// Devolve (perda_total, perda_novo, perda_replay).
+    pub fn passo_treino(
+        &mut self,
+        x: &Tensor,
+        alvo: &Tensor,
+        otimizador: &mut crate::treino::AdamWManual,
+    ) -> Result<(f64, f64, f64)> {
+        // perda nova
+        let h = self.scan(x)?;
+        let dif = (&h - alvo)?;
+        let perda_novo = dif.sqr()?.mean_all()?;
+        // replay
+        let mut perda_total = perda_novo.clone();
+        let mut p_r = 0.0;
+        if !self.buffer.is_empty() {
+            let idx = self.buffer.len() - 1;
+            let antigo = self.buffer[idx].clone();
+            let hr = self.scan(&antigo)?;
+            // alvo do replay: manter a dinâmica aprendida estável (magnitudes
+            // finitas) — auto-supervisão de estabilidade
+            let dr = hr.sqr()?.mean_all()?;
+            perda_total = (perda_total.affine(1.0 - self.alpha_replay, 0.0)?
+                + dr.affine(self.alpha_replay, 0.0)?)?;
+            p_r = dr.to_scalar::<f32>()? as f64;
+        }
+        let pn = perda_novo.to_scalar::<f32>()? as f64;
+        otimizador.passo(crate::treino::grads_achatados(&perda_total, &self.vars())?);
+        self.guardar(x);
+        let pt = perda_total.to_scalar::<f32>()? as f64;
+        Ok((pt, pn, p_r))
+    }
+}

src/jepa/sonic_moe.rs

@@ -0,0 +1,155 @@
+//! `jepa::sonic_moe` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Parte 5 — SonicMoE (IO/tile-aware)
+// ---------------------------------------------------------------------------
+
+/// MoE top-k com capacidade por especialista e perda de balanceamento.
+///
+/// **Prova SM-1 (limite de capacidade):** o roteamento tile-aware mantém no
+/// máximo `C` tokens por especialista por ladrilho — o drop é determinístico
+/// (ordem de chegada) e o nº de tokens descartados é `Σ_e max(0, load_e − C)`.
+///
+/// **Prova SM-2 (balanceamento):** `L_aux = E·Σ_e f_e·p_e`; com roteamento
+/// auto-consistente (`f = p`), `L_aux = E·Σ p_e² ≥ 1` com igualdade sse
+/// `p_e = 1/E` (Cauchy–Schchwarz) — o mínimo força o roteador uniforme.
+pub struct SonicMoe {
+    pub roteador: Linear,            // d → E
+    pub especialistas: Vec<MlpJepa>, // E experts d → d
+    pub n_top: usize,
+    pub capacidade: usize,
+    pub lambda_aux: f64,
+}
+
+pub struct SaidaMoe {
+    pub saida: Tensor,
+    pub perda_aux: Tensor,
+    pub carga: Vec<usize>,  // tokens efetivamente processados por especialista
+    pub descartados: usize, // tokens com especialistas cortados pela capacidade
+}
+
+impl SonicMoe {
+    pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result<Self> {
+        let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?;
+        let especialistas = (0..n_expertos)
+            .map(|_| MlpJepa::novo(d, 2 * d, d, dev))
+            .collect::<Result<Vec<_>>>()?;
+        Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        let mut v = self.roteador.vars();
+        for e in &self.especialistas {
+            v.extend(e.vars());
+        }
+        v
+    }
+
+    /// Forward tile-aware: (n, d) → (n, d).
+    pub fn fwd(&self, x: &Tensor) -> Result<SaidaMoe> {
+        let n = x.dim(0)?;
+        let d = x.dim(1)?;
+        let e = self.especialistas.len();
+        let dev = x.device();
+        let logits = self.roteador.fwd(x)?; // (n, E)
+        let probs = candle_nn::ops::softmax(&logits, candle_core::D::Minus1)?;
+
+        // top-k por token (não diferenciável — pesos do top-k são dif. via probs)
+        let probs_v = probs.to_vec2::<f32>()?;
+        let mut carga = vec![0usize; e];
+        let mut descartados = 0usize;
+        // acumulador de saída (n, d) — construído por soma de contribuições
+        let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
+        let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
+        // por especialista (tile): tokens cujo top-k contém e e com carga < C
+        for ei in 0..e {
+            // candidatos: tokens ordenados por prob do especialista ei
+            let mut cand: Vec<(usize, f32)> = (0..n)
+                .map(|i| (i, probs_v[i][ei]))
+                .collect();
+            cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+            let mut escolhidos: Vec<usize> = Vec::new();
+            for (i, _) in cand {
+                if carga[ei] >= self.capacidade {
+                    break;
+                }
+                // verifica se ei está no top-k do token i
+                let mut ordem: Vec<(f32, usize)> =
+                    (0..e).map(|k| (probs_v[i][k], k)).collect();
+                ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
+                let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
+                if top.contains(&ei) {
+                    escolhidos.push(i);
+                    carga[ei] += 1;
+                }
+            }
+            if escolhidos.is_empty() {
+                continue;
+            }
+            // tile do especialista: uma única passagem em lote
+            let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
+            let n_e = idx.len();
+            let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
+            let tile = x.index_select(&idx_t, 0)?;
+            let y = self.especialistas[ei].fwd(&tile)?; // (m, d)
+            // pesos: prob do especialista ei para cada token escolhido
+            let w: Vec<f32> = escolhidos.iter().map(|&i| probs_v[i][ei]).collect();
+            let n_w = escolhidos.len();
+            let w_t = Tensor::from_vec(w.clone(), (n_w, 1), &dev)?;
+            let contrib = y.broadcast_mul(&w_t)?;
+            // scatter-add: acumula nas posições
+            let mut buf = saida.to_vec2::<f32>()?;
+            let contrib_v = contrib.to_vec2::<f32>()?;
+            for (k, &i) in escolhidos.iter().enumerate() {
+                for j in 0..d {
+                    buf[i][j] += contrib_v[k][j];
+                }
+            }
+            saida = Tensor::from_vec(
+                buf.into_iter().flatten().collect::<Vec<f32>>(),
+                (n, d),
+                &dev,
+            )?;
+            let mut pt = peso_total.to_vec2::<f32>()?;
+            for (k, &i) in escolhidos.iter().enumerate() {
+                pt[i][0] += w[k];
+            }
+            peso_total = Tensor::from_vec(
+                pt.into_iter().flatten().collect::<Vec<f32>>(),
+                (n, 1),
+                &dev,
+            )?;
+        }
+        // tokens sem especialista (todos cortados) → descartados; saída 0
+        let pt_v = peso_total.to_vec2::<f32>()?;
+        for i in 0..n {
+            if pt_v[i][0] == 0.0 {
+                descartados += 1;
+            }
+        }
+        // renormaliza pelo peso efetivo (evita viés da capacidade)
+        let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
+        let saida = saida.broadcast_div(&denom)?;
+
+        // perda auxiliar: E·Σ f_e·p_e (f = fração de tokens cujo top-1 é e)
+        let mut f = vec![0f32; e];
+        for i in 0..n {
+            let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY);
+            for k in 0..e {
+                if probs_v[i][k] > mp {
+                    mp = probs_v[i][k];
+                    melhor = k;
+                }
+            }
+            f[melhor] += 1.0 / n as f32;
+        }
+        let f_t = Tensor::from_vec(f, (e,), &dev)?;
+        let p_media = probs.mean(0)?; // (E,)
+        let perda_aux = ((&f_t * &p_media)?.sum_all()? * (e as f64))?;
+        Ok(SaidaMoe { saida, perda_aux, carga, descartados })
+    }
+}

src/jepa/testes.rs

@@ -0,0 +1,212 @@
+//! `jepa::testes` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    fn tensor_2d(dados: &[Vec<f64>], dev: &Device) -> Tensor {
+        let flat: Vec<f32> = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect();
+        Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap()
+    }
+
+    #[test]
+    fn teste_mascaras_validas() {
+        // fração respeitada ±, particionamento contexto/alvo não-vazio
+        let mut rng = RngDeterministico::novo(1);
+        let m2 = mascara_blocos_2d(8, 8, 4, 0.3, &mut rng);
+        assert_eq!(m2.len(), 64);
+        let frac = m2.iter().filter(|&&b| b).count() as f64 / 64.0;
+        assert!(frac >= 0.15 && frac <= 0.55, "frac 2d = {frac}");
+        assert!(m2.iter().any(|&b| !b), "contexto vazio");
+
+        let m3 = mascara_tubos_3d(4, 6, 6, 3, 0.3, &mut rng);
+        assert_eq!(m3.len(), 144);
+        let f3 = m3.iter().filter(|&&b| b).count() as f64 / 144.0;
+        assert!(f3 >= 0.15 && f3 <= 0.6, "frac 3d = {f3}");
+
+        let ms = mascara_segmentos(4, 32, 0.25, &mut rng);
+        assert_eq!(ms.len(), 128);
+        assert!(ms.iter().any(|&b| b) && ms.iter().any(|&b| !b));
+
+        let m1 = mascara_intervalos_1d(64, 0.3, &mut rng);
+        let f1 = m1.iter().filter(|&&b| b).count() as f64 / 64.0;
+        assert!(f1 >= 0.25 && f1 <= 0.45, "frac 1d = {f1}");
+    }
+
+    #[test]
+    fn teste_fps_cobre() {
+        let mut rng = RngDeterministico::novo(2);
+        let pontos: Vec<Vec<f64>> = (0..40)
+            .map(|i| {
+                let a = i as f64 * 0.1;
+                vec![a.cos() * 3.0, a.sin() * 3.0, (i % 7) as f64 * 0.3]
+            })
+            .collect();
+        let centros = pontos_mais_distantes(&pontos, 6, &mut rng);
+        assert_eq!(centros.len(), 6);
+        // centros distintos
+        let mut s = centros.clone();
+        s.sort();
+        s.dedup();
+        assert_eq!(s.len(), 6);
+    }
+
+    #[test]
+    fn teste_j1_colapso_impossivel() {
+        // No colapso total (z constante), a perda VC = γ² > 0 — verificando a
+        // fórmula implementada com um lote constante.
+        let dev = Device::Cpu;
+        let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
+        let z = Tensor::from_vec(vec![0.5f32; 8 * 8], (8, 8), &dev).unwrap();
+        let lvc = nucleo.perda_vc(&z).unwrap();
+        let v = lvc.to_scalar::<f32>().unwrap() as f64;
+        // std=0 ⇒ dobradiça = γ = 1 ⇒ V/d = 1; cov = 0
+        assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
+    }
+
+    #[test]
+    fn teste_j2_ema_ponto_fixo() {
+        // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
+        let dev = Device::Cpu;
+        let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.5, 0.1, 1.0, &dev).unwrap();
+        for _ in 0..40 {
+            nucleo.ema_passo().unwrap();
+        }
+        let a = nucleo.alvo.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let b = nucleo.encoder.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let dif: f32 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).fold(0.0, f32::max);
+        assert!(dif < 1e-5, "EMA não convergiu: dif máx = {dif}");
+    }
+
+    #[test]
+    fn teste_jepa_aprende_latente_previsivel() {
+        // J-3: com alvo previsível (função determinística do contexto), a
+        // perda pred must cair substancialmente e o std das incorporações
+        // NÃO colapsa (J-1).
+        let dev = Device::Cpu;
+        let mut rng = RngDeterministico::novo(3);
+        // patches = 64 vetores 8-D em 4 grupos (estrutura previsível)
+        let mut dados: Vec<Vec<f64>> = Vec::new();
+        for g in 0..4 {
+            let c = g as f64 * 2.0;
+            for _ in 0..16 {
+                dados.push((0..8).map(|k| c + rng.normal(0.0, 0.3) + (k as f64) * 0.05).collect());
+            }
+        }
+        let patches = tensor_2d(&dados, &dev);
+        let cfg = CfgJepa { d_emb: 16, epocas: 40, lr: 5e-3, ..Default::default() };
+        let rel = treinar_variante(
+            &patches,
+            &|n, r| mascara_intervalos_1d(n, 0.3, r),
+            &cfg,
+            VarianteJepa::TJepa,
+            None,
+            &dev,
+        )
+        .unwrap();
+        assert!(
+            rel.perda_final < rel.perda_inicial * 0.8,
+            "perda deveria cair: {} → {}",
+            rel.perda_inicial,
+            rel.perda_final
+        );
+        assert!(
+            rel.std_emb_final > 0.05,
+            "sem colapso: std_final = {}",
+            rel.std_emb_final
+        );
+    }
+
+    #[test]
+    fn teste_adaptadores_formas() {
+        let dev = Device::Cpu;
+        let img = Tensor::randn(0f32, 1.0, (3, 16, 16), &dev).unwrap();
+        let p = em_patches_2d(&img, 4, 4).unwrap();
+        assert_eq!(p.dims().to_vec(), vec![16, 48]);
+
+        let vid = Tensor::randn(0f32, 1.0, (4, 8, 8), &dev).unwrap();
+        let t3 = em_tubos_3d(&vid, 2, 4, 4).unwrap();
+        assert_eq!(t3.dims().to_vec(), vec![8, 32]);
+
+        let spec = Tensor::randn(0f32, 1.0, (16, 32), &dev).unwrap();
+        let ps = em_patches_espectrograma(&spec, 4, 8).unwrap();
+        assert_eq!(ps.dims().to_vec(), vec![16, 32]);
+
+        let ts = Tensor::randn(0f32, 1.0, (4, 32), &dev).unwrap();
+        let pt_ = em_patches_serie(&ts, 8).unwrap();
+        assert_eq!(pt_.dims().to_vec(), vec![16, 8]);
+
+        let vol = Tensor::randn(0f32, 1.0, (8, 8, 8), &dev).unwrap();
+        let vx = em_voxels(&vol, 4, 4, 4).unwrap();
+        assert_eq!(vx.dims().to_vec(), vec![8, 64]);
+
+        let pc = Tensor::randn(0f32, 1.0, (50, 3), &dev).unwrap();
+        let mut rng = RngDeterministico::novo(5);
+        let gr = em_grupos_pontos(&pc, 6, 4, &mut rng).unwrap();
+        assert_eq!(gr.dims().to_vec(), vec![6, 12]);
+    }
+
+    #[test]
+    fn teste_sonic_moe_capacidade_e_balanceamento() {
+        // SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando
+        // roteador é ~uniforme (início).
+        let dev = Device::Cpu;
+        let moe = SonicMoe::novo(8, 4, 2, 6, &dev).unwrap();
+        let x = Tensor::randn(0f32, 1.0, (20, 8), &dev).unwrap();
+        let s = moe.fwd(&x).unwrap();
+        for (e, c) in s.carga.iter().enumerate() {
+            assert!(*c <= 6, "especialista {e} com carga {c} > capacidade 6");
+        }
+        assert_eq!(s.saida.dims().to_vec(), vec![20, 8]);
+        let aux = s.perda_aux.to_scalar::<f32>().unwrap() as f64;
+        // com roteador quase uniforme, aux ≈ E·Σ (1/E)·(1/E) = 1
+        assert!(aux > 0.5 && aux < 3.0, "aux = {aux}");
+        // cada token processado por ≤ n_top especialistas
+        let total_carga: usize = s.carga.iter().sum();
+        assert!(total_carga <= 20 * 2, "carga total {total_carga} > n·topk");
+    }
+
+    #[test]
+    fn teste_replay_ssm_estabilidade_e_replay() {
+        // R-1: estados finitos e limitados; R-2: com replay α>0, após treinar
+        // a tarefa nova, a dinâmica antiga (magnitude do estado) permanece
+        // estável (não diverge).
+        let dev = Device::Cpu;
+        let mut ssm = ReplaySsm::novo(4, 6, 0.5, 8, &dev).unwrap();
+        let vars = ssm.vars();
+        let mut otim = crate::treino::AdamWManual::novo(vars, 1e-2, 0.0);
+
+        // tarefa "antiga": sinal constante 1.0
+        let x_antigo = Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev).unwrap();
+        for _ in 0..30 {
+            let h = ssm.scan(&x_antigo).unwrap();
+            let alvo = h.detach();
+            ssm.passo_treino(&x_antigo, &alvo, &mut otim).unwrap();
+        }
+        // estado após treino antigo: finito
+        let h1 = ssm.scan(&x_antigo).unwrap();
+        let m1 = h1.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(m1.is_finite() && m1 < 50.0, "estado explodiu: {m1}");
+
+        // tarefa "nova": sinal −1.0 — treino com replay
+        let x_novo = Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev).unwrap();
+        for _ in 0..30 {
+            let h = ssm.scan(&x_novo).unwrap();
+            let alvo = h.detach();
+            ssm.passo_treino(&x_novo, &alvo, &mut otim).unwrap();
+        }
+        // a dinâmica antiga continua estável (sem explosão)
+        let h2 = ssm.scan(&x_antigo).unwrap();
+        let m2 = h2.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(m2.is_finite() && m2 < 50.0, "estado antigo explodiu: {m2}");
+        // portas dentro de (0,1)
+        let a = ssm.a.as_tensor().to_vec1::<f32>().unwrap();
+        for v in a {
+            assert!(v.is_finite());
+        }
+    }
+}

src/{jepa.rs → jepa/variantes.rs}

@@ -1,563 +1,8 @@
-//! Suíte JEPA v0.5.0 — núcleo unificado + 12 variantes + SonicMoE + ReplaySSM.
-//!
-//! **Núcleo (todas as variantes compartilham):**
-//! - codificador `E_θ` (MLp SiLU), preditor `P_φ` (condicionado por posição/
-//!   ação/edição), codificador-alvo EMA `E_ξ` com `ξ ← m·ξ + (1−m)·θ`
-//!   (gradiente cortado — alvo nunca recebe gradiente);
-//! - regularizador variância-covariância (VICReg-lite) anti-colapso:
-//!   `V(z) = Σ_j max(0, γ − std(z_j))²` + fora-diagonal da covariância.
-//! - perda: `L = Σ_b ‖P(z_ctx, pos_b) − sg(ẑ_b)‖²/B + λ_vc·V`.
-//!
-//! **Prova J-1 (impossibilidade de colapso, em r-20):** se todas as
-//! incorporações colapsam para constante, `std(z_j) = 0 ∀j` ⇒ `V = d·γ² > 0`;
-//! logo o colapso total NÃO é minimizador com `λ_vc > 0`.
-//!
-//! **Prova J-2 (EMA = stop-grad + ponto fixo):** `∂L/∂ξ = 0` (detach); se
-//! `θ_t → θ*` então `ξ_t → θ*` (recursão linear contratante com `m < 1`).
-//!
-//! **Prova J-3 (decomposição de informação):** com `P` suficientemente
-//! rico, `min_P L = Σ_b Var(ẑ_b | z_ctx)` — a perda retém só o componentes
-//! previsíveis do alvo dado o contexto.
-//!
-//! **Variantes** (esquema de máscara + adaptador de modalidade):
-//! Image-JEPA (blocos 2D) · V-JEPA 2 (tubos 3D + cond. de ação) · MC-JEPA
-//! (cruz-modal, dois codificadores) · Audio-JEPA (bandas de espectrograma) ·
-//! Point-JEPA (grupos FPS) · 3D-JEPA (voxels) · Brain-JEPA (canal×tempo) ·
-//! T-JEPA (série temporal canal-independente) · LeJEPA (edição-condicionado) ·
-//! BJEPA (bidirecional com consistência de ciclo).
-//!
-//! **SonicMoE** — MoE com roteamento top-k, capacidade por especialista
-//! (tile-aware) e perda auxiliar de balanceamento (argumento Switch:
-//! `L_aux = E·Σ f_e·p_e ≥ 1` com igualdade sse uniforme).
-//!
-//! **ReplaySSM** — SSM de porta diagonal (`h_t = σ(a)⊙h_{t−1} +
-//! (1−σ(a))⊙(Bx_t)`, estabilidade herdada do Teo S-2') + replay de experiências
-//! para aprendizado continuado (interpolação de gradientes limita o
-//! esquecimento — Teo R-1).
+//! `jepa::variantes` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
 
-use candle_core::{Device, Result, Tensor, Var};
-use crate::camadas::Linear;
-use crate::rng::RngDeterministico;
-use std::collections::HashMap;
+use super::*;
 
-// ---------------------------------------------------------------------------
-// Parte 1 — núcleo
-// ---------------------------------------------------------------------------
-
-/// MLP 2 camadas com SiLU (d → h → d_saida).
-pub struct MlpJepa {
-    pub l1: Linear,
-    pub l2: Linear,
-    pub d_entrada: usize,
-    pub d_saida: usize,
-}
-
-impl MlpJepa {
-    pub fn novo(d_entrada: usize, d_oculta: usize, d_saida: usize, dev: &Device) -> Result<Self> {
-        let s1 = (1.0 / (d_entrada as f64).sqrt()) * 0.9;
-        let s2 = (1.0 / (d_oculta as f64).sqrt()) * 0.9;
-        Ok(Self {
-            l1: Linear::sem_vies(d_entrada, d_oculta, s1, dev)?,
-            l2: Linear::sem_vies(d_oculta, d_saida, s2, dev)?,
-            d_entrada,
-            d_saida,
-        })
-    }
-
-    pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
-        let h = candle_nn::ops::silu(&self.l1.fwd(x)?)?;
-        self.l2.fwd(&h)
-    }
-
-    pub fn vars(&self) -> Vec<Var> {
-        [self.l1.vars(), self.l2.vars()].concat()
-    }
-
-    /// EMA: `self ← m·self + (1−m)·outro` (usado no codificador-alvo).
-    pub fn ema_de(&mut self, outro: &MlpJepa, m: f64) -> Result<()> {
-        for (a, b) in self.vars().iter().zip(outro.vars().iter()) {
-            let novo = (a.as_tensor().affine(m, 0.0)? + b.as_tensor().affine(1.0 - m, 0.0)?)?;
-            a.set(&novo)?;
-        }
-        Ok(())
-    }
-}
-
-/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
-pub struct NucleoJepa {
-    pub encoder: MlpJepa,
-    pub preditor: MlpJepa,
-    pub alvo: MlpJepa,
-    /// tabela de posições (blocos) — entrada extra do preditor.
-    pub pos: Var,
-    pub d_emb: usize,
-    pub d_cond: usize,
-    pub m: f64,
-    pub lambda_vc: f64,
-    pub gamma_vc: f64,
-}
-
-impl NucleoJepa {
-    pub fn novo(
-        d_patch: usize,
-        d_emb: usize,
-        d_cond: usize,
-        n_pos: usize,
-        m: f64,
-        lambda_vc: f64,
-        gamma_vc: f64,
-        dev: &Device,
-    ) -> Result<Self> {
-        let encoder = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
-        let preditor = MlpJepa::novo(d_emb + d_cond + d_emb, 2 * d_emb, d_emb, dev)?;
-        // alvo nasce IGUAL ao encoder (ponto de partida do EMA)
-        let mut alvo = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
-        for (va, vb) in alvo.vars().iter().zip(encoder.vars().iter()) {
-            va.set(vb.as_tensor())?;
-        }
-        let pos_t = Tensor::randn(0f32, 0.02, (n_pos.max(1), d_emb), dev)?;
-        Ok(Self {
-            encoder,
-            preditor,
-            alvo,
-            pos: Var::from_tensor(&pos_t)?,
-            d_emb,
-            d_cond,
-            m,
-            lambda_vc,
-            gamma_vc,
-        })
-    }
-
-    pub fn vars(&self) -> Vec<Var> {
-        let mut v = self.encoder.vars();
-        v.extend(self.preditor.vars());
-        v.push(self.pos.clone());
-        v // NOTA: alvo NÃO entra — é buffer EMA
-    }
-
-    pub fn ema_passo(&mut self) -> Result<()> {
-        self.alvo.ema_de(&self.encoder, self.m)
-    }
-
-    /// Codifica um conjunto de patches (n, d_patch) → (n, d_emb).
-    pub fn codificar(&self, patches: &Tensor) -> Result<Tensor> {
-        self.encoder.fwd(patches)
-    }
-
-    /// Codifica com o alvo EMA — SEM gradiente (detach por construção: as
-    /// vars do alvo não estão no otimizador e o tensor é desconectado).
-    pub fn alvo_codificar(&self, patches: &Tensor) -> Result<Tensor> {
-        Ok(self.alvo.fwd(patches)?.detach())
-    }
-
-    /// Prediz o embedding do bloco `i_pos` a partir do contexto `z_ctx`
-    /// (d_emb) e da condição `cond` (d_cond; zeros se None).
-    pub fn predizer(&self, z_ctx: &Tensor, i_pos: usize, cond: Option<&Tensor>) -> Result<Tensor> {
-        // z_ctx: (b, d_emb) ou (d_emb,)
-        let b = z_ctx.dim(0).unwrap_or(1);
-        let dev = z_ctx.device();
-        let pos = self.pos.as_tensor().get(i_pos.min(self.pos.dim(0)?.saturating_sub(1)))?;
-        let pos_b = pos.broadcast_as((b, self.d_emb))?;
-        let cond_b = match cond {
-            Some(c) => {
-                if c.dims().len() == 1 && b > 1 {
-                    c.broadcast_as((b, self.d_cond))?
-                } else {
-                    c.clone()
-                }
-            }
-            None => Tensor::zeros((b, self.d_cond), candle_core::DType::F32, dev)?,
-        };
-        let entrada = Tensor::cat(&[z_ctx, &pos_b, &cond_b], candle_core::D::Minus1)?;
-        self.preditor.fwd(&entrada)
-    }
-
-    /// Regularizador variância-covariância do lote de incorporações z (n, d).
-    ///
-    /// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ `V = d·γ²`.
-    pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
-        let n = z.dim(0)? as f64;
-        let d = self.d_emb;
-        let media = z.mean_keepdim(0)?; // (1, d)
-        let centr = z.broadcast_sub(&media)?;
-        let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
-        let std = var.sqrt()?;
-        // dobradiça: max(0, γ − std)²
-        let gamma_t =
-            Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
-        let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?;
-        let v = gap.sqr()?.sum_all()?;
-        // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C − diag‖²_F/(2d)
-        let cov = (centr.transpose(0, 1)?.matmul(&centr)? / n)?; // (d, d)
-        let mask_diag = {
-            let mut m = vec![0f32; d * d];
-            for i in 0..d {
-                m[i * d + i] = 1.0;
-            }
-            Tensor::from_vec(m, (d, d), z.device())?
-        };
-        let fora = ((&cov * &mask_diag)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
-        let v_norm = (v / d.max(1) as f64)?;
-        Ok((v_norm + fora)?)
-    }
-
-    /// Perda JEPA padrão para UM lote: contexto (número variável de patches),
-    /// lista de blocos-alvo (posições), condição opcional.
-    ///
-    /// `z_ctx` = incorporação agregada do contexto (b, d_emb);
-    /// `alvos`: para cada elemento do lote, Vec<(i_pos, patches_alvo)>.
-    pub fn perda_lote(
-        &self,
-        z_ctx: &Tensor,
-        alvos: &[Vec<(usize, Tensor)>],
-        cond: Option<&Tensor>,
-        z_ctx_todos: &Tensor,
-    ) -> Result<(Tensor, f64, f64)> {
-        let b = z_ctx.dim(0)?;
-        let dev = z_ctx.device();
-        let mut perdas: Vec<Tensor> = Vec::new();
-        let mut n_alvos = 0usize;
-        for (i, blocos) in alvos.iter().enumerate() {
-            for (i_pos, patches_alvo) in blocos {
-                // ẑ_b = média das incorporações-alvo dos patches do bloco
-                let zt = self.alvo_codificar(patches_alvo)?; // (m, d_emb)
-                let zt_m = zt.mean(0)?; // (d_emb,)
-                let zt_b = zt_m.broadcast_as((1, self.d_emb))?;
-                let zc = z_ctx.get(i)?.broadcast_as((1, self.d_emb))?;
-                let c_i = cond.map(|c| c.get(i)?.broadcast_as((1, self.d_cond))).transpose()?;
-                let pred = self.predizer(&zc, *i_pos, c_i.as_ref())?;
-                let dif = (&pred - &zt_b)?;
-                let l = (dif.sqr()?.sum_all()? / self.d_emb as f64)?;
-                perdas.push(l);
-                n_alvos += 1;
-            }
-        }
-        let l_pred = if perdas.is_empty() {
-            Tensor::zeros((), candle_core::DType::F32, &dev)?
-        } else {
-            (Tensor::stack(&perdas, 0)?.sum_all()? / n_alvos.max(1) as f64)?
-        };
-        let l_vc = self.perda_vc(z_ctx_todos)?;
-        let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(self.lambda_vc, 0.0)?)?;
-        let lp = l_pred.to_scalar::<f32>()? as f64;
-        let lv = l_vc.to_scalar::<f32>()? as f64;
-        Ok((total, lp, lv))
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Parte 2 — máscaras
-// ---------------------------------------------------------------------------
-
-/// Máscara de blocos 2D (Image-JEPA): grade (h, w) de patches; sorteia
-/// `n_blocos` retângulos aleatórios com fração alvo `frac` de patches.
-pub fn mascara_blocos_2d(h: usize, w: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    let total = h * w;
-    let alvo = (total as f64 * frac) as usize;
-    let mut masc = vec![false; total];
-    let mut coberto = 0usize;
-    for _ in 0..n_blocos.max(1) {
-        if coberto >= alvo {
-            break;
-        }
-        let bh = 1 + rng.inteiro(h.min(4));
-        let bw = 1 + rng.inteiro(w.min(4));
-        let y0 = rng.inteiro(h + 1 - bh);
-        let x0 = rng.inteiro(w + 1 - bw);
-        for y in y0..y0 + bh {
-            for x in x0..x0 + bw {
-                let i = y * w + x;
-                if !masc[i] {
-                    masc[i] = true;
-                    coberto += 1;
-                }
-            }
-        }
-    }
-    masc
-}
-
-/// Máscara de tubos 3D (V-JEPA 2): grade (t, h, w); tubos = retângulos que
-/// atravessam o tempo.
-pub fn mascara_tubos_3d(t: usize, h: usize, w: usize, n_tubos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    let total = t * h * w;
-    let alvo = (total as f64 * frac) as usize;
-    let mut masc = vec![false; total];
-    let mut coberto = 0usize;
-    for _ in 0..n_tubos.max(1) {
-        if coberto >= alvo {
-            break;
-        }
-        let bh = 1 + rng.inteiro(h.min(3));
-        let bw = 1 + rng.inteiro(w.min(3));
-        let y0 = rng.inteiro(h + 1 - bh);
-        let x0 = rng.inteiro(w + 1 - bw);
-        for tt in 0..t {
-            for y in y0..y0 + bh {
-                for x in x0..x0 + bw {
-                    let i = (tt * h + y) * w + x;
-                    if !masc[i] {
-                        masc[i] = true;
-                        coberto += 1;
-                    }
-                }
-            }
-        }
-    }
-    masc
-}
-
-/// Máscara de bandas (Audio-JEPA): grade (f, tau) — bandas de frequência
-/// horizontais com extensão temporal.
-pub fn mascara_bandas(f: usize, tau: usize, n_bandas: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    mascara_blocos_2d(f, tau, n_bandas, frac, rng) // blocos na grade (f, tau)
-}
-
-/// Máscara de blocos 3D (3D-JEPA): grade (x, y, z) de voxels.
-pub fn mascara_blocos_3d(x: usize, y: usize, z: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    mascara_tubos_3d(x, y, z, n_blocos, frac, rng)
-}
-
-/// Máscara de segmentos canal×tempo (Brain-JEPA): canais inteiros OU
-/// janelas temporais (aleatório por chamada).
-pub fn mascara_segmentos(c: usize, t: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    let total = c * t;
-    let alvo = (total as f64 * frac) as usize;
-    let mut masc = vec![false; total];
-    if rng.inteiro(2) == 0 {
-        // canais inteiros
-        let mut coberto = 0;
-        let mut canais: Vec<usize> = (0..c).collect();
-        // embaralhar
-        for i in (1..canais.len()).rev() {
-            let j = rng.inteiro(i + 1);
-            canais.swap(i, j);
-        }
-        for &ch in canais.iter() {
-            if coberto >= alvo {
-                break;
-            }
-            for tt in 0..t {
-                masc[ch * t + tt] = true;
-                coberto += 1;
-            }
-        }
-    } else {
-        // janelas temporais
-        let mut coberto = 0;
-        let mut t0 = 0;
-        while coberto < alvo && t0 < t {
-            let len = 1 + rng.inteiro((t / 4).max(1));
-            for ch in 0..c {
-                for tt in t0..(t0 + len).min(t) {
-                    masc[ch * t + tt] = true;
-                    coberto += 1;
-                }
-            }
-            t0 += len + 1;
-        }
-    }
-    masc
-}
-
-/// Máscara 1D (T-JEPA): intervalos contíguos em n posições.
-pub fn mascara_intervalos_1d(n: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
-    let alvo = (n as f64 * frac) as usize;
-    let mut masc = vec![false; n];
-    let mut coberto = 0;
-    while coberto < alvo {
-        let len = 1 + rng.inteiro((n / 8).max(1));
-        let i0 = rng.inteiro(n);
-        for i in i0..(i0 + len).min(n) {
-            if !masc[i] {
-                masc[i] = true;
-                coberto += 1;
-            }
-        }
-    }
-    masc
-}
-
-/// Amostragem dos pontos mais distantes (FPS) para Point-JEPA.
-pub fn pontos_mais_distantes(pontos: &[Vec<f64>], k: usize, rng: &mut RngDeterministico) -> Vec<usize> {
-    let n = pontos.len();
-    if n == 0 || k == 0 {
-        return vec![];
-    }
-    let k = k.min(n);
-    let mut centros = vec![rng.inteiro(n)];
-    let mut dist_min: Vec<f64> = pontos
-        .iter()
-        .map(|p| distancia_eucl(p, &pontos[centros[0]]))
-        .collect();
-    while centros.len() < k {
-        let prox = dist_min
-            .iter()
-            .enumerate()
-            .filter(|(i, _)| !centros.contains(i))
-            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
-            .map(|(i, _)| i)
-            .unwrap_or(0);
-        centros.push(prox);
-        for (i, p) in pontos.iter().enumerate() {
-            let d = distancia_eucl(p, &pontos[prox]);
-            if d < dist_min[i] {
-                dist_min[i] = d;
-            }
-        }
-    }
-    centros
-}
-
-fn distancia_eucl(a: &[f64], b: &[f64]) -> f64 {
-    a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum::<f64>().sqrt()
-}
-
-// ---------------------------------------------------------------------------
-// Parte 3 — adaptadores de modalidade
-// ---------------------------------------------------------------------------
-
-/// (C, H, W) → patches (H/ph · W/pw, C·ph·pw) — Image-JEPA.
-pub fn em_patches_2d(img: &Tensor, ph: usize, pw: usize) -> Result<Tensor> {
-    let (c, h, w) = (img.dim(0)?, img.dim(1)?, img.dim(2)?);
-    let dev = img.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for y in (0..h).step_by(ph) {
-        for x in (0..w).step_by(pw) {
-            let hh = ph.min(h - y);
-            let ww = pw.min(w - x);
-            let patch = img.narrow(0, 0, c)?.narrow(1, y, hh)?.narrow(2, x, ww)?;
-            // padding para (C, ph, pw) se borda
-            let patch = if hh < ph || ww < pw {
-                let mut buf = patch.flatten_all()?.to_vec1::<f32>()?;
-                let falta = c * ph * pw - buf.len();
-                buf.extend(std::iter::repeat(0f32).take(falta));
-                Tensor::from_vec(buf, (c * ph * pw,), &dev)?
-            } else {
-                patch.flatten_all()?
-            };
-            linhas.push(patch);
-        }
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
-
-/// (T, H, W) → tubos (T/pt · H/ph · W/pw, pt·ph·pw) — V-JEPA 2.
-pub fn em_tubos_3d(vid: &Tensor, pt: usize, ph: usize, pw: usize) -> Result<Tensor> {
-    let (t, h, w) = (vid.dim(0)?, vid.dim(1)?, vid.dim(2)?);
-    let dev = vid.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for tt in (0..t).step_by(pt) {
-        let tl = pt.min(t - tt);
-        for y in (0..h).step_by(ph) {
-            for x in (0..w).step_by(pw) {
-                let hh = ph.min(h - y);
-                let ww = pw.min(w - x);
-                let tubo = vid
-                    .narrow(0, tt, tl)?
-                    .narrow(1, y, hh)?
-                    .narrow(2, x, ww)?
-                    .flatten_all()?;
-                let mut buf = tubo.to_vec1::<f32>()?;
-                let falta = pt * ph * pw - buf.len();
-                buf.extend(std::iter::repeat(0f32).take(falta));
-                linhas.push(Tensor::from_vec(buf, (pt * ph * pw,), &dev)?);
-            }
-        }
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
-
-/// (F, τ) → patches (F/pf · τ/pt, pf·pt) — Audio-JEPA.
-pub fn em_patches_espectrograma(spec: &Tensor, pf: usize, pt: usize) -> Result<Tensor> {
-    let (f, tau) = (spec.dim(0)?, spec.dim(1)?);
-    let dev = spec.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for i in (0..f).step_by(pf) {
-        for j in (0..tau).step_by(pt) {
-            let ff = pf.min(f - i);
-            let tt = pt.min(tau - j);
-            let p = spec.narrow(0, i, ff)?.narrow(1, j, tt)?.flatten_all()?;
-            let mut buf = p.to_vec1::<f32>()?;
-            let falta = pf * pt - buf.len();
-            buf.extend(std::iter::repeat(0f32).take(falta));
-            linhas.push(Tensor::from_vec(buf, (pf * pt,), &dev)?);
-        }
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
-
-/// (C, T) → patches canal-independentes (C · T/pt, pt) — T-JEPA/Brain-JEPA.
-pub fn em_patches_serie(ts: &Tensor, pt: usize) -> Result<Tensor> {
-    let (c, t) = (ts.dim(0)?, ts.dim(1)?);
-    let dev = ts.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for ch in 0..c {
-        for j in (0..t).step_by(pt) {
-            let tt = pt.min(t - j);
-            let p = ts.narrow(0, ch, 1)?.narrow(1, j, tt)?.flatten_all()?;
-            let mut buf = p.to_vec1::<f32>()?;
-            let falta = pt - buf.len();
-            buf.extend(std::iter::repeat(0f32).take(falta));
-            linhas.push(Tensor::from_vec(buf, (pt,), &dev)?);
-        }
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
-
-/// (X, Y, Z) → voxels (X/px · Y/py · Z/pz, px·py·pz) — 3D-JEPA.
-pub fn em_voxels(vol: &Tensor, px: usize, py: usize, pz: usize) -> Result<Tensor> {
-    let (x, y, z) = (vol.dim(0)?, vol.dim(1)?, vol.dim(2)?);
-    let dev = vol.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for i in (0..x).step_by(px) {
-        for j in (0..y).step_by(py) {
-            for k in (0..z).step_by(pz) {
-                let lx = px.min(x - i);
-                let ly = py.min(y - j);
-                let lz = pz.min(z - k);
-                let p = vol.narrow(0, i, lx)?.narrow(1, j, ly)?.narrow(2, k, lz)?.flatten_all()?;
-                let mut buf = p.to_vec1::<f32>()?;
-                let falta = px * py * pz - buf.len();
-                buf.extend(std::iter::repeat(0f32).take(falta));
-                linhas.push(Tensor::from_vec(buf, (px * py * pz,), &dev)?);
-            }
-        }
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
-
-/// Nuvem de pontos (n, d) → grupos FPS (k, m·d): k centros por FPS, cada
-/// grupo = os m vizinhos mais próximos do centro (concatenados) — Point-JEPA.
-pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterministico) -> Result<Tensor> {
-    let n = pc.dim(0)?;
-    let d = pc.dim(1)?;
-    let coords = pc.to_vec2::<f32>()?;
-    let coords_f: Vec<Vec<f64>> = coords.iter().map(|r| r.iter().map(|&v| v as f64).collect()).collect();
-    let centros = pontos_mais_distantes(&coords_f, k, rng);
-    let dev = pc.device();
-    let mut linhas: Vec<Tensor> = Vec::new();
-    for &ci in &centros {
-        // m vizinhos mais próximos do centro ci (incluindo ele próprio)
-        let mut ord: Vec<usize> = (0..n).collect();
-        ord.sort_by(|&a, &b| {
-            let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
-            let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
-            da.partial_cmp(&db).unwrap()
-        });
-        let mut buf: Vec<f32> = Vec::with_capacity(m * d);
-        for &idx in ord.iter().take(m) {
-            for j in 0..d {
-                buf.push(coords[idx][j]);
-            }
-        }
-        let falta = m * d - buf.len();
-        buf.extend(std::iter::repeat(0f32).take(falta));
-        linhas.push(Tensor::from_vec(buf, (m * d,), &dev)?);
-    }
-    Ok(Tensor::stack(&linhas, 0)?)
-}
 
 // ---------------------------------------------------------------------------
 // Parte 4 — variantes e treino unificado
@@ -770,257 +215,6 @@ fn std_por_dim(z: &Tensor) -> Result<f64> {
     Ok(var.sqrt()?.mean_all()?.to_scalar::<f32>()? as f64)
 }
 
-// ---------------------------------------------------------------------------
-// Parte 5 — SonicMoE (IO/tile-aware)
-// ---------------------------------------------------------------------------
-
-/// MoE top-k com capacidade por especialista e perda de balanceamento.
-///
-/// **Prova SM-1 (limite de capacidade):** o roteamento tile-aware mantém no
-/// máximo `C` tokens por especialista por ladrilho — o drop é determinístico
-/// (ordem de chegada) e o nº de tokens descartados é `Σ_e max(0, load_e − C)`.
-///
-/// **Prova SM-2 (balanceamento):** `L_aux = E·Σ_e f_e·p_e`; com roteamento
-/// auto-consistente (`f = p`), `L_aux = E·Σ p_e² ≥ 1` com igualdade sse
-/// `p_e = 1/E` (Cauchy–Schchwarz) — o mínimo força o roteador uniforme.
-pub struct SonicMoe {
-    pub roteador: Linear,            // d → E
-    pub especialistas: Vec<MlpJepa>, // E experts d → d
-    pub n_top: usize,
-    pub capacidade: usize,
-    pub lambda_aux: f64,
-}
-
-pub struct SaidaMoe {
-    pub saida: Tensor,
-    pub perda_aux: Tensor,
-    pub carga: Vec<usize>,  // tokens efetivamente processados por especialista
-    pub descartados: usize, // tokens com especialistas cortados pela capacidade
-}
-
-impl SonicMoe {
-    pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result<Self> {
-        let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?;
-        let especialistas = (0..n_expertos)
-            .map(|_| MlpJepa::novo(d, 2 * d, d, dev))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
-    }
-
-    pub fn vars(&self) -> Vec<Var> {
-        let mut v = self.roteador.vars();
-        for e in &self.especialistas {
-            v.extend(e.vars());
-        }
-        v
-    }
-
-    /// Forward tile-aware: (n, d) → (n, d).
-    pub fn fwd(&self, x: &Tensor) -> Result<SaidaMoe> {
-        let n = x.dim(0)?;
-        let d = x.dim(1)?;
-        let e = self.especialistas.len();
-        let dev = x.device();
-        let logits = self.roteador.fwd(x)?; // (n, E)
-        let probs = candle_nn::ops::softmax(&logits, candle_core::D::Minus1)?;
-
-        // top-k por token (não diferenciável — pesos do top-k são dif. via probs)
-        let probs_v = probs.to_vec2::<f32>()?;
-        let mut carga = vec![0usize; e];
-        let mut descartados = 0usize;
-        // acumulador de saída (n, d) — construído por soma de contribuições
-        let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
-        let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
-        // por especialista (tile): tokens cujo top-k contém e e com carga < C
-        for ei in 0..e {
-            // candidatos: tokens ordenados por prob do especialista ei
-            let mut cand: Vec<(usize, f32)> = (0..n)
-                .map(|i| (i, probs_v[i][ei]))
-                .collect();
-            cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
-            let mut escolhidos: Vec<usize> = Vec::new();
-            for (i, _) in cand {
-                if carga[ei] >= self.capacidade {
-                    break;
-                }
-                // verifica se ei está no top-k do token i
-                let mut ordem: Vec<(f32, usize)> =
-                    (0..e).map(|k| (probs_v[i][k], k)).collect();
-                ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
-                let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
-                if top.contains(&ei) {
-                    escolhidos.push(i);
-                    carga[ei] += 1;
-                }
-            }
-            if escolhidos.is_empty() {
-                continue;
-            }
-            // tile do especialista: uma única passagem em lote
-            let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
-            let n_e = idx.len();
-            let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
-            let tile = x.index_select(&idx_t, 0)?;
-            let y = self.especialistas[ei].fwd(&tile)?; // (m, d)
-            // pesos: prob do especialista ei para cada token escolhido
-            let w: Vec<f32> = escolhidos.iter().map(|&i| probs_v[i][ei]).collect();
-            let n_w = escolhidos.len();
-            let w_t = Tensor::from_vec(w.clone(), (n_w, 1), &dev)?;
-            let contrib = y.broadcast_mul(&w_t)?;
-            // scatter-add: acumula nas posições
-            let mut buf = saida.to_vec2::<f32>()?;
-            let contrib_v = contrib.to_vec2::<f32>()?;
-            for (k, &i) in escolhidos.iter().enumerate() {
-                for j in 0..d {
-                    buf[i][j] += contrib_v[k][j];
-                }
-            }
-            saida = Tensor::from_vec(
-                buf.into_iter().flatten().collect::<Vec<f32>>(),
-                (n, d),
-                &dev,
-            )?;
-            let mut pt = peso_total.to_vec2::<f32>()?;
-            for (k, &i) in escolhidos.iter().enumerate() {
-                pt[i][0] += w[k];
-            }
-            peso_total = Tensor::from_vec(
-                pt.into_iter().flatten().collect::<Vec<f32>>(),
-                (n, 1),
-                &dev,
-            )?;
-        }
-        // tokens sem especialista (todos cortados) → descartados; saída 0
-        let pt_v = peso_total.to_vec2::<f32>()?;
-        for i in 0..n {
-            if pt_v[i][0] == 0.0 {
-                descartados += 1;
-            }
-        }
-        // renormaliza pelo peso efetivo (evita viés da capacidade)
-        let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
-        let saida = saida.broadcast_div(&denom)?;
-
-        // perda auxiliar: E·Σ f_e·p_e (f = fração de tokens cujo top-1 é e)
-        let mut f = vec![0f32; e];
-        for i in 0..n {
-            let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY);
-            for k in 0..e {
-                if probs_v[i][k] > mp {
-                    mp = probs_v[i][k];
-                    melhor = k;
-                }
-            }
-            f[melhor] += 1.0 / n as f32;
-        }
-        let f_t = Tensor::from_vec(f, (e,), &dev)?;
-        let p_media = probs.mean(0)?; // (E,)
-        let perda_aux = ((&f_t * &p_media)?.sum_all()? * (e as f64))?;
-        Ok(SaidaMoe { saida, perda_aux, carga, descartados })
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Parte 6 — ReplaySSM
-// ---------------------------------------------------------------------------
-
-/// SSM de porta diagonal com replay para aprendizado continuado.
-///
-/// Recorrência: `h_t = σ(a) ⊙ h_{t−1} + (1 − σ(a)) ⊙ (B x_t)`.
-///
-/// **Prova R-1 (estabilidade):** `|σ(a)| < 1` ⇒ perturbações de `h_0`
-/// decaem geometricamente (mesma estrutura do Teo S-2' do SSD-Δ).
-///
-/// **Prova R-2 (limite de esquecimento):** o passo de treino mistura
-/// gradientes `(1−α)·∇L_novo + α·∇L_replay`; para `L_antiga` μ-fortemente
-/// convexa com gradientes novos limitados por `G`, o afastamento do ótimo
-/// antigo por passo é `≤ (1−α)·η·G` (sem replay: `≤ η·G`) — o replay
-/// contrai o drift por um fator `1/(1−α)` no regime linear.
-pub struct ReplaySsm {
-    pub a: Var,   // (d,) — porta (sigmoid no uso)
-    pub b: Var,   // (d_in, d) — projeção de entrada
-    pub d: usize,
-    pub alpha_replay: f64,
-    pub buffer: Vec<Tensor>,
-    pub capacidade_buffer: usize,
-}
-
-impl ReplaySsm {
-    pub fn novo(d_in: usize, d: usize, alpha_replay: f64, capacidade_buffer: usize, dev: &Device) -> Result<Self> {
-        let a_t = Tensor::randn(0f32, 0.5, (d,), dev)?;
-        let b_t = Tensor::randn(0f32, 0.1, (d_in, d), dev)?;
-        Ok(Self {
-            a: Var::from_tensor(&a_t)?,
-            b: Var::from_tensor(&b_t)?,
-            d,
-            alpha_replay,
-            buffer: Vec::new(),
-            capacidade_buffer,
-        })
-    }
-
-    pub fn vars(&self) -> Vec<Var> {
-        vec![self.a.clone(), self.b.clone()]
-    }
-
-    /// Scan: x (T, d_in) → h (T, d). Diferenciável (candle autograd).
-    pub fn scan(&self, x: &Tensor) -> Result<Tensor> {
-        let t = x.dim(0)?;
-        let dev = x.device();
-        let porta = candle_nn::ops::sigmoid(&self.a.as_tensor().broadcast_as((1, self.d))?)?; // (1, d)
-        let um_menos = porta.affine(-1.0, 1.0)?; // 1 − σ(a)
-        let entrada = x.matmul(&self.b.as_tensor())?; // (T, d)
-        let mut h = Tensor::zeros((1, self.d), candle_core::DType::F32, &dev)?;
-        let mut saidas: Vec<Tensor> = Vec::with_capacity(t);
-        for i in 0..t {
-            let xt = entrada.narrow(0, i, 1)?;
-            h = ((&porta * &h)? + (&um_menos * &xt)?)?;
-            saidas.push(h.clone());
-        }
-        Ok(Tensor::stack(&saidas, 0)?)
-    }
-
-    /// Empurra uma janela de treino no buffer (FIFO).
-    pub fn guardar(&mut self, x: &Tensor) {
-        if self.buffer.len() >= self.capacidade_buffer {
-            self.buffer.remove(0);
-        }
-        self.buffer.push(x.detach());
-    }
-
-    /// Um passo de treino no lote novo (com mistura de replay).
-    /// Devolve (perda_total, perda_novo, perda_replay).
-    pub fn passo_treino(
-        &mut self,
-        x: &Tensor,
-        alvo: &Tensor,
-        otimizador: &mut crate::treino::AdamWManual,
-    ) -> Result<(f64, f64, f64)> {
-        // perda nova
-        let h = self.scan(x)?;
-        let dif = (&h - alvo)?;
-        let perda_novo = dif.sqr()?.mean_all()?;
-        // replay
-        let mut perda_total = perda_novo.clone();
-        let mut p_r = 0.0;
-        if !self.buffer.is_empty() {
-            let idx = self.buffer.len() - 1;
-            let antigo = self.buffer[idx].clone();
-            let hr = self.scan(&antigo)?;
-            // alvo do replay: manter a dinâmica aprendida estável (magnitudes
-            // finitas) — auto-supervisão de estabilidade
-            let dr = hr.sqr()?.mean_all()?;
-            perda_total = (perda_total.affine(1.0 - self.alpha_replay, 0.0)?
-                + dr.affine(self.alpha_replay, 0.0)?)?;
-            p_r = dr.to_scalar::<f32>()? as f64;
-        }
-        let pn = perda_novo.to_scalar::<f32>()? as f64;
-        otimizador.passo(crate::treino::grads_achatados(&perda_total, &self.vars())?);
-        self.guardar(x);
-        let pt = perda_total.to_scalar::<f32>()? as f64;
-        Ok((pt, pn, p_r))
-    }
-}
 
 // ---------------------------------------------------------------------------
 // Variantes especiais: LeJEPA (edição-condicionado), MC-JEPA (cruz-modal),
@@ -1280,210 +474,3 @@ pub fn mascara_por_variante(
 pub fn versao() -> &'static str {
     "jepa-0.5.0"
 }
-
-#[cfg(test)]
-mod testes {
-    use super::*;
-
-    fn tensor_2d(dados: &[Vec<f64>], dev: &Device) -> Tensor {
-        let flat: Vec<f32> = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect();
-        Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap()
-    }
-
-    #[test]
-    fn teste_mascaras_validas() {
-        // fração respeitada ±, particionamento contexto/alvo não-vazio
-        let mut rng = RngDeterministico::novo(1);
-        let m2 = mascara_blocos_2d(8, 8, 4, 0.3, &mut rng);
-        assert_eq!(m2.len(), 64);
-        let frac = m2.iter().filter(|&&b| b).count() as f64 / 64.0;
-        assert!(frac >= 0.15 && frac <= 0.55, "frac 2d = {frac}");
-        assert!(m2.iter().any(|&b| !b), "contexto vazio");
-
-        let m3 = mascara_tubos_3d(4, 6, 6, 3, 0.3, &mut rng);
-        assert_eq!(m3.len(), 144);
-        let f3 = m3.iter().filter(|&&b| b).count() as f64 / 144.0;
-        assert!(f3 >= 0.15 && f3 <= 0.6, "frac 3d = {f3}");
-
-        let ms = mascara_segmentos(4, 32, 0.25, &mut rng);
-        assert_eq!(ms.len(), 128);
-        assert!(ms.iter().any(|&b| b) && ms.iter().any(|&b| !b));
-
-        let m1 = mascara_intervalos_1d(64, 0.3, &mut rng);
-        let f1 = m1.iter().filter(|&&b| b).count() as f64 / 64.0;
-        assert!(f1 >= 0.25 && f1 <= 0.45, "frac 1d = {f1}");
-    }
-
-    #[test]
-    fn teste_fps_cobre() {
-        let mut rng = RngDeterministico::novo(2);
-        let pontos: Vec<Vec<f64>> = (0..40)
-            .map(|i| {
-                let a = i as f64 * 0.1;
-                vec![a.cos() * 3.0, a.sin() * 3.0, (i % 7) as f64 * 0.3]
-            })
-            .collect();
-        let centros = pontos_mais_distantes(&pontos, 6, &mut rng);
-        assert_eq!(centros.len(), 6);
-        // centros distintos
-        let mut s = centros.clone();
-        s.sort();
-        s.dedup();
-        assert_eq!(s.len(), 6);
-    }
-
-    #[test]
-    fn teste_j1_colapso_impossivel() {
-        // No colapso total (z constante), a perda VC = γ² > 0 — verificando a
-        // fórmula implementada com um lote constante.
-        let dev = Device::Cpu;
-        let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
-        let z = Tensor::from_vec(vec![0.5f32; 8 * 8], (8, 8), &dev).unwrap();
-        let lvc = nucleo.perda_vc(&z).unwrap();
-        let v = lvc.to_scalar::<f32>().unwrap() as f64;
-        // std=0 ⇒ dobradiça = γ = 1 ⇒ V/d = 1; cov = 0
-        assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
-    }
-
-    #[test]
-    fn teste_j2_ema_ponto_fixo() {
-        // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
-        let dev = Device::Cpu;
-        let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.5, 0.1, 1.0, &dev).unwrap();
-        for _ in 0..40 {
-            nucleo.ema_passo().unwrap();
-        }
-        let a = nucleo.alvo.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
-        let b = nucleo.encoder.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
-        let dif: f32 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).fold(0.0, f32::max);
-        assert!(dif < 1e-5, "EMA não convergiu: dif máx = {dif}");
-    }
-
-    #[test]
-    fn teste_jepa_aprende_latente_previsivel() {
-        // J-3: com alvo previsível (função determinística do contexto), a
-        // perda pred must cair substancialmente e o std das incorporações
-        // NÃO colapsa (J-1).
-        let dev = Device::Cpu;
-        let mut rng = RngDeterministico::novo(3);
-        // patches = 64 vetores 8-D em 4 grupos (estrutura previsível)
-        let mut dados: Vec<Vec<f64>> = Vec::new();
-        for g in 0..4 {
-            let c = g as f64 * 2.0;
-            for _ in 0..16 {
-                dados.push((0..8).map(|k| c + rng.normal(0.0, 0.3) + (k as f64) * 0.05).collect());
-            }
-        }
-        let patches = tensor_2d(&dados, &dev);
-        let cfg = CfgJepa { d_emb: 16, epocas: 40, lr: 5e-3, ..Default::default() };
-        let rel = treinar_variante(
-            &patches,
-            &|n, r| mascara_intervalos_1d(n, 0.3, r),
-            &cfg,
-            VarianteJepa::TJepa,
-            None,
-            &dev,
-        )
-        .unwrap();
-        assert!(
-            rel.perda_final < rel.perda_inicial * 0.8,
-            "perda deveria cair: {} → {}",
-            rel.perda_inicial,
-            rel.perda_final
-        );
-        assert!(
-            rel.std_emb_final > 0.05,
-            "sem colapso: std_final = {}",
-            rel.std_emb_final
-        );
-    }
-
-    #[test]
-    fn teste_adaptadores_formas() {
-        let dev = Device::Cpu;
-        let img = Tensor::randn(0f32, 1.0, (3, 16, 16), &dev).unwrap();
-        let p = em_patches_2d(&img, 4, 4).unwrap();
-        assert_eq!(p.dims().to_vec(), vec![16, 48]);
-
-        let vid = Tensor::randn(0f32, 1.0, (4, 8, 8), &dev).unwrap();
-        let t3 = em_tubos_3d(&vid, 2, 4, 4).unwrap();
-        assert_eq!(t3.dims().to_vec(), vec![8, 32]);
-
-        let spec = Tensor::randn(0f32, 1.0, (16, 32), &dev).unwrap();
-        let ps = em_patches_espectrograma(&spec, 4, 8).unwrap();
-        assert_eq!(ps.dims().to_vec(), vec![16, 32]);
-
-        let ts = Tensor::randn(0f32, 1.0, (4, 32), &dev).unwrap();
-        let pt_ = em_patches_serie(&ts, 8).unwrap();
-        assert_eq!(pt_.dims().to_vec(), vec![16, 8]);
-
-        let vol = Tensor::randn(0f32, 1.0, (8, 8, 8), &dev).unwrap();
-        let vx = em_voxels(&vol, 4, 4, 4).unwrap();
-        assert_eq!(vx.dims().to_vec(), vec![8, 64]);
-
-        let pc = Tensor::randn(0f32, 1.0, (50, 3), &dev).unwrap();
-        let mut rng = RngDeterministico::novo(5);
-        let gr = em_grupos_pontos(&pc, 6, 4, &mut rng).unwrap();
-        assert_eq!(gr.dims().to_vec(), vec![6, 12]);
-    }
-
-    #[test]
-    fn teste_sonic_moe_capacidade_e_balanceamento() {
-        // SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando
-        // roteador é ~uniforme (início).
-        let dev = Device::Cpu;
-        let moe = SonicMoe::novo(8, 4, 2, 6, &dev).unwrap();
-        let x = Tensor::randn(0f32, 1.0, (20, 8), &dev).unwrap();
-        let s = moe.fwd(&x).unwrap();
-        for (e, c) in s.carga.iter().enumerate() {
-            assert!(*c <= 6, "especialista {e} com carga {c} > capacidade 6");
-        }
-        assert_eq!(s.saida.dims().to_vec(), vec![20, 8]);
-        let aux = s.perda_aux.to_scalar::<f32>().unwrap() as f64;
-        // com roteador quase uniforme, aux ≈ E·Σ (1/E)·(1/E) = 1
-        assert!(aux > 0.5 && aux < 3.0, "aux = {aux}");
-        // cada token processado por ≤ n_top especialistas
-        let total_carga: usize = s.carga.iter().sum();
-        assert!(total_carga <= 20 * 2, "carga total {total_carga} > n·topk");
-    }
-
-    #[test]
-    fn teste_replay_ssm_estabilidade_e_replay() {
-        // R-1: estados finitos e limitados; R-2: com replay α>0, após treinar
-        // a tarefa nova, a dinâmica antiga (magnitude do estado) permanece
-        // estável (não diverge).
-        let dev = Device::Cpu;
-        let mut ssm = ReplaySsm::novo(4, 6, 0.5, 8, &dev).unwrap();
-        let vars = ssm.vars();
-        let mut otim = crate::treino::AdamWManual::novo(vars, 1e-2, 0.0);
-
-        // tarefa "antiga": sinal constante 1.0
-        let x_antigo = Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev).unwrap();
-        for _ in 0..30 {
-            let h = ssm.scan(&x_antigo).unwrap();
-            let alvo = h.detach();
-            ssm.passo_treino(&x_antigo, &alvo, &mut otim).unwrap();
-        }
-        // estado após treino antigo: finito
-        let h1 = ssm.scan(&x_antigo).unwrap();
-        let m1 = h1.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
-        assert!(m1.is_finite() && m1 < 50.0, "estado explodiu: {m1}");
-
-        // tarefa "nova": sinal −1.0 — treino com replay
-        let x_novo = Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev).unwrap();
-        for _ in 0..30 {
-            let h = ssm.scan(&x_novo).unwrap();
-            let alvo = h.detach();
-            ssm.passo_treino(&x_novo, &alvo, &mut otim).unwrap();
-        }
-        // a dinâmica antiga continua estável (sem explosão)
-        let h2 = ssm.scan(&x_antigo).unwrap();
-        let m2 = h2.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
-        assert!(m2.is_finite() && m2 < 50.0, "estado antigo explodiu: {m2}");
-        // portas dentro de (0,1)
-        let a = ssm.a.as_tensor().to_vec1::<f32>().unwrap();
-        for v in a {
-            assert!(v.is_finite());
-        }
-    }
-}

src/lib.rs

@@ -11,6 +11,7 @@ pub mod arvore_pesos;
 pub mod atencao;
 pub mod acoplador;
 pub mod camadas;
+pub mod checkpoint;
 pub mod config;
 pub mod controlador;
 pub mod diagnostico;

src/moe_redirecionavel/atencao.rs

@@ -0,0 +1,63 @@
+//! `moe_redirecionavel::atencao` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Atenção própria (independente e paralela à ADBA do tronco)
+// ---------------------------------------------------------------------------
+
+pub struct AtencaoPropria {
+    pub q: Linear,
+    pub k: Linear,
+    pub v: Linear,
+    pub o: Linear,
+    /// gate escalar — nasce ZERO (M-R2: neutralidade no nascimento).
+    pub gate: Var,
+    pub n_cabecas: usize,
+}
+
+impl AtencaoPropria {
+    pub fn novo(d: usize, n_cabecas: usize, dev: &Device) -> Result<Self> {
+        let desvio = 1.0 / ((d * 2) as f64).sqrt();
+        let mk = || Linear::sem_vies(d, d, desvio, dev);
+        let gate = Tensor::zeros((), candle_core::DType::F32, dev)?;
+        Ok(AtencaoPropria {
+            q: mk()?, k: mk()?, v: mk()?, o: mk()?,
+            gate: Var::from_tensor(&gate)?,
+            n_cabecas,
+        })
+    }
+
+    /// x (n, d) → y = x + g·attn(x) — multi-cabeça compacta (sem máscara:
+    /// atenção plena entre os tokens da entrada do MoE).
+    pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
+        let d = x.dim(candle_core::D::Minus1)?;
+        let d_cab = d / self.n_cabecas;
+        let n = x.dim(0)?;
+        let forma = (self.n_cabecas, n, d_cab);
+        let q = self.q.fwd(x)?.reshape(forma)?;
+        let k = self.k.fwd(x)?.reshape(forma)?;
+        let v = self.v.fwd(x)?.reshape(forma)?;
+        let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d_cab as f64).sqrt(), 0.0)?;
+        let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?;
+        let ctx = attn.matmul(&v)?; // (h, n, d_cab)
+        let ctx = ctx.reshape((n, d))?;
+        let saida = self.o.fwd(&ctx)?;
+        // y = x + g·saida (g=0 no nascimento ⇒ y = x — M-R2)
+        let g = self.gate.as_tensor();
+        let forma: Vec<usize> = saida.dims().to_vec();
+        let delta = saida.broadcast_mul(&g.broadcast_as(forma)?)?;
+        Ok((x + &delta)?)
+    }
+
+    pub fn vars(&self) -> Vec<Var> {
+        let mut v = self.q.vars();
+        v.extend(self.k.vars());
+        v.extend(self.v.vars());
+        v.extend(self.o.vars());
+        v.push(self.gate.clone());
+        v
+    }
+}

src/moe_redirecionavel/mod.rs

@@ -0,0 +1,57 @@
+//! MoE redirecionável — módulos: atenção própria, núcleo,
+//! treinos JEPA/SOM (divisão SRP v0.10.0 — r-35 §2).
+
+//! **MoEs de codificação/decodificação REDIRECIONÁVEIS com Mecanismo de
+//! Atenção próprio e independente (paralelo)** (v0.6.0 — pedido do usuário).
+//!
+//! Cada `MoeRedirecionavel` possui:
+//! - um roteador aprendido `d → E`;
+//! - E especialistas `MlpJepa`, cada um com um PAPEL (Codificador ou
+//!   Decodificador) — o conjunto de papéis é REDIRECIONÁVEL em tempo de
+//!   execução (permutação), sem reconstrução do modelo;
+//! - uma ATENÇÃO PRÓPRIA independente da atenção ADBA do tronco, com gate
+//!   escalar nascido em ZERO (neutralidade no nascimento);
+//! - capacidade por especialista e perda auxiliar de balanceamento.
+//!
+//! **Provas completas em `docs/memorias/r-25-*`; síntese:**
+//! - **M-R1 (invariância sob redirecionamento):** o redirecionamento é uma
+//!   permutação π dos papéis; o multiconjunto de atribuições
+//!   (especialista, token) numa passada por papel é levado ao multiconjunto
+//!   da passada π(papel) — a capacidade total e a perda auxiliar de
+//!   balanceamento E·Σ f_e·p_e são invariantes (soma sobre todos os e).
+//! - **M-R2 (neutralidade da atenção própria no nascimento):** com
+//!   `g = 0`, `y = x` bit-a-bit; a perturbação é limitada por
+//!   `‖Δy‖ ≤ L_soft·|g|·‖W_o·V‖` (Lipschitz do softmax com constante
+//!   L_soft = 1 em probabilidade; estrutura idêntica ao T-P5).
+//! - **M-R3 (paralelismo dos dois caminhos):** numa mesma entrada, as
+//!   passadas Codificador e Decodificador tocam conjuntos DISJUNTOS de
+//!   especialistas e compartilham apenas leitura — o DAG de computação tem
+//!   duas sub-DAGs independentes ⇒ tempo paralelo (2 processadores) =
+//!   max(T_enc, T_dec) + sobrecarga < T_enc + T_dec = tempo sequencial
+//!   (modelo PRAM; medido empiricamente com threads).
+//! - **M-R4 (fechamento da classe de funções):** redirecionar equivale a
+//!   permutar colunas do roteador e re-rotular papéis; a classe de funções
+//!   implementáveis é fechada sob π ⇒ expressividade inalterada.
+//! - **M-R5 (water-filling por QE — Cauchy–Schwarz):** dadas capacidades
+//!   totais C e erros por célula q_i, a alocação `c_i ∝ q_i` minimiza
+//!   `Σ q_i²/c_i ≥ (Σq_i)²/C`, cota superior do erro refinado ponderado.
+
+use candle_core::{Device, Result, Tensor, Var};
+use crate::camadas::Linear;
+use crate::jepa::MlpJepa;
+use crate::rng::RngDeterministico;
+use crate::treino::AdamWManual;
+
+// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
+#[cfg(test)]
+mod testes;
+#[cfg(test)]
+mod teste_integrado;
+mod atencao;
+mod nucleo;
+mod treino;
+
+pub use atencao::*;
+pub use nucleo::*;
+pub use treino::*;
+

src/{moe_redirecionavel.rs → moe_redirecionavel/nucleo.rs}

@@ -1,101 +1,8 @@
-//! **MoEs de codificação/decodificação REDIRECIONÁVEIS com Mecanismo de
-//! Atenção próprio e independente (paralelo)** (v0.6.0 — pedido do usuário).
-//!
-//! Cada `MoeRedirecionavel` possui:
-//! - um roteador aprendido `d → E`;
-//! - E especialistas `MlpJepa`, cada um com um PAPEL (Codificador ou
-//!   Decodificador) — o conjunto de papéis é REDIRECIONÁVEL em tempo de
-//!   execução (permutação), sem reconstrução do modelo;
-//! - uma ATENÇÃO PRÓPRIA independente da atenção ADBA do tronco, com gate
-//!   escalar nascido em ZERO (neutralidade no nascimento);
-//! - capacidade por especialista e perda auxiliar de balanceamento.
-//!
-//! **Provas completas em `docs/memorias/r-25-*`; síntese:**
-//! - **M-R1 (invariância sob redirecionamento):** o redirecionamento é uma
-//!   permutação π dos papéis; o multiconjunto de atribuições
-//!   (especialista, token) numa passada por papel é levado ao multiconjunto
-//!   da passada π(papel) — a capacidade total e a perda auxiliar de
-//!   balanceamento E·Σ f_e·p_e são invariantes (soma sobre todos os e).
-//! - **M-R2 (neutralidade da atenção própria no nascimento):** com
-//!   `g = 0`, `y = x` bit-a-bit; a perturbação é limitada por
-//!   `‖Δy‖ ≤ L_soft·|g|·‖W_o·V‖` (Lipschitz do softmax com constante
-//!   L_soft = 1 em probabilidade; estrutura idêntica ao T-P5).
-//! - **M-R3 (paralelismo dos dois caminhos):** numa mesma entrada, as
-//!   passadas Codificador e Decodificador tocam conjuntos DISJUNTOS de
-//!   especialistas e compartilham apenas leitura — o DAG de computação tem
-//!   duas sub-DAGs independentes ⇒ tempo paralelo (2 processadores) =
-//!   max(T_enc, T_dec) + sobrecarga < T_enc + T_dec = tempo sequencial
-//!   (modelo PRAM; medido empiricamente com threads).
-//! - **M-R4 (fechamento da classe de funções):** redirecionar equivale a
-//!   permutar colunas do roteador e re-rotular papéis; a classe de funções
-//!   implementáveis é fechada sob π ⇒ expressividade inalterada.
-//! - **M-R5 (water-filling por QE — Cauchy–Schwarz):** dadas capacidades
-//!   totais C e erros por célula q_i, a alocação `c_i ∝ q_i` minimiza
-//!   `Σ q_i²/c_i ≥ (Σq_i)²/C`, cota superior do erro refinado ponderado.
+//! `moe_redirecionavel::nucleo` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
 
-use candle_core::{Device, Result, Tensor, Var};
-use crate::camadas::Linear;
-use crate::jepa::MlpJepa;
-use crate::rng::RngDeterministico;
-use crate::treino::AdamWManual;
+use super::*;
 
-// ---------------------------------------------------------------------------
-// Atenção própria (independente e paralela à ADBA do tronco)
-// ---------------------------------------------------------------------------
-
-pub struct AtencaoPropria {
-    pub q: Linear,
-    pub k: Linear,
-    pub v: Linear,
-    pub o: Linear,
-    /// gate escalar — nasce ZERO (M-R2: neutralidade no nascimento).
-    pub gate: Var,
-    pub n_cabecas: usize,
-}
-
-impl AtencaoPropria {
-    pub fn novo(d: usize, n_cabecas: usize, dev: &Device) -> Result<Self> {
-        let desvio = 1.0 / ((d * 2) as f64).sqrt();
-        let mk = || Linear::sem_vies(d, d, desvio, dev);
-        let gate = Tensor::zeros((), candle_core::DType::F32, dev)?;
-        Ok(AtencaoPropria {
-            q: mk()?, k: mk()?, v: mk()?, o: mk()?,
-            gate: Var::from_tensor(&gate)?,
-            n_cabecas,
-        })
-    }
-
-    /// x (n, d) → y = x + g·attn(x) — multi-cabeça compacta (sem máscara:
-    /// atenção plena entre os tokens da entrada do MoE).
-    pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
-        let d = x.dim(candle_core::D::Minus1)?;
-        let d_cab = d / self.n_cabecas;
-        let n = x.dim(0)?;
-        let forma = (self.n_cabecas, n, d_cab);
-        let q = self.q.fwd(x)?.reshape(forma)?;
-        let k = self.k.fwd(x)?.reshape(forma)?;
-        let v = self.v.fwd(x)?.reshape(forma)?;
-        let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d_cab as f64).sqrt(), 0.0)?;
-        let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?;
-        let ctx = attn.matmul(&v)?; // (h, n, d_cab)
-        let ctx = ctx.reshape((n, d))?;
-        let saida = self.o.fwd(&ctx)?;
-        // y = x + g·saida (g=0 no nascimento ⇒ y = x — M-R2)
-        let g = self.gate.as_tensor();
-        let forma: Vec<usize> = saida.dims().to_vec();
-        let delta = saida.broadcast_mul(&g.broadcast_as(forma)?)?;
-        Ok((x + &delta)?)
-    }
-
-    pub fn vars(&self) -> Vec<Var> {
-        let mut v = self.q.vars();
-        v.extend(self.k.vars());
-        v.extend(self.v.vars());
-        v.extend(self.o.vars());
-        v.push(self.gate.clone());
-        v
-    }
-}
 
 // ---------------------------------------------------------------------------
 // MoE redirecionável
@@ -522,686 +429,3 @@ pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
     }
     c
 }
-
-// ---------------------------------------------------------------------------
-// Aplicação JEPA — codificador/preditor redirecionáveis com MoE
-// ---------------------------------------------------------------------------
-
-pub struct RelatorioJepaMoe {
-    pub modo: &'static str,
-    pub perda_pred_inicial: f64,
-    pub perda_pred_final: f64,
-    pub perda_vc_final: f64,
-    pub std_emb: f64,
-    pub carga_max: usize,
-    pub descartados: usize,
-}
-
-/// Treino JEPA compacto com três braços (ablação honesta):
-/// - `"pequena"`: codificador/preditor MLP simples (baseline);
-/// - `"densa"`: MLP com o TOTAL de parâmetros dos especialistas (capacidade
-///   equiparada, SEM roteamento — isola o ganho do roteamento);
-/// - `"moe"`: `MoeRedirecionavel` nos dois caminhos (Codificador no
-///   codificador, Decodificador no preditor) com atenção própria.
-pub fn treinar_jepa_com_moe(
-    patches: &Tensor,
-    modo: &'static str,
-    passos: usize,
-    frac_mascara: f64,
-    semente: u64,
-) -> Result<RelatorioJepaMoe> {
-    let dev = patches.device();
-    let n = patches.dim(0)?;
-    let d = patches.dim(1)?;
-    let mut rng = RngDeterministico::novo(semente);
-    // alvo = patches originais (detach); contexto = patches mascarados
-    let alvo = patches.detach();
-    let contexto = {
-        let mut v = patches.flatten_all()?.to_vec1::<f32>()?;
-        for x in v.iter_mut() {
-            if rng.uniforme() < frac_mascara {
-                *x = 0.0;
-            }
-        }
-        Tensor::from_vec(v, (n, d), &dev)?
-    };
-    let e = 4usize; // especialistas por papel no braço moe
-    let n_top = 2;
-    let capacidade = n;
-
-    // braços
-    enum Braco {
-        Pequena(MlpJepa, MlpJepa),
-        Densa(MlpJepa, MlpJepa),
-        Moe(MoeRedirecionavel),
-    }
-    let braco = match modo {
-        "pequena" => Braco::Pequena(
-            MlpJepa::novo(d, 2 * d, d, &dev)?,
-            MlpJepa::novo(d, 2 * d, d, &dev)?,
-        ),
-        "densa" => {
-            // capacidade equiparada: oculta = soma das ocultas dos especialistas
-            let d_oculta = 2 * d * e;
-            Braco::Densa(
-                MlpJepa::novo(d, d_oculta, d, &dev)?,
-                MlpJepa::novo(d, d_oculta, d, &dev)?,
-            )
-        }
-        _ => Braco::Moe(MoeRedirecionavel::novo(d, 2 * e, n_top, capacidade, &dev)?),
-    };
-
-    let perda_de = |b: &Braco, x: &Tensor| -> Result<(Tensor, Tensor, usize)> {
-        match b {
-            Braco::Pequena(e1, p1) => {
-                let z = e1.fwd(x)?;
-                let yh = p1.fwd(&z)?;
-                let dif = (&yh - &alvo)?;
-                Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
-                    z.sqr()?.mean_all()?, 0))
-            }
-            Braco::Densa(e1, p1) => {
-                let z = e1.fwd(x)?;
-                let yh = p1.fwd(&z)?;
-                let dif = (&yh - &alvo)?;
-                Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
-                    z.sqr()?.mean_all()?, 0))
-            }
-            Braco::Moe(m) => {
-                // v0.9.0: forward (ex-fwd_vetorizado) — gradiente flui aos
-                // especialistas e ao roteador (a fwd seccionava o grafo)
-                let s_enc = m.forward(x, Papel::Codificador)?;
-                let s_dec = m.forward(&s_enc.saida, Papel::Decodificador)?;
-                let dif = (&s_dec.saida - &alvo)?;
-                let lp = (dif.sqr()?.sum_all()? / (n as f64 * d as f64))?;
-                // perda total = preditiva + aux balanceamento (ambos papéis)
-                let lt = (lp.affine(1.0, 0.0)? + s_enc.perda_aux.affine(m.lambda_aux, 0.0)?
-                    + s_dec.perda_aux.affine(m.lambda_aux, 0.0)?)?;
-                let carga_max = s_enc.carga.iter().copied().fold(0, usize::max)
-                    .max(s_dec.carga.iter().copied().fold(0, usize::max));
-                Ok((lt, lp, carga_max))
-            }
-        }
-    };
-
-    let (mut opt, vars): (AdamWManual, Vec<Var>) = match &braco {
-        Braco::Pequena(a, b) => {
-            let v = [a.vars(), b.vars()].concat();
-            (AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
-        }
-        Braco::Densa(a, b) => {
-            let v = [a.vars(), b.vars()].concat();
-            (AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
-        }
-        Braco::Moe(m) => (AdamWManual::novo(m.vars(), 3e-3, 0.0), m.vars()),
-    };
-    // atenção própria: gate nasce 0; sobe 1 passo em 8 (aquecimento honesto
-    // do mecanismo — T-P5 análogo: neutralidade no nascimento, gradiente flui)
-    if let Braco::Moe(m) = &braco {
-        let g0 = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
-        let _ = g0;
-    }
-
-    let (l0, _, _) = perda_de(&braco, &contexto)?;
-    let perda_inicial = l0.to_scalar::<f32>()? as f64;
-    let mut perda_final = perda_inicial;
-    let mut vc_final = 0.0;
-    let mut carga_max = 0usize;
-    let mut descartados = 0usize;
-    let mut std_emb = 0.0;
-    for passo in 0..passos {
-        let (lt, lp, cm) = perda_de(&braco, &contexto)?;
-        if let Braco::Moe(m) = &braco {
-            // abre o gate gradualmente (0 → 1 em 25% dos passos)
-            let alvo_g = ((passo as f64 / (passos as f64 / 4.0).max(1.0)).min(1.0)) as f32;
-            let g_atual = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
-            if (alvo_g as f64 - g_atual).abs() > 1e-9 {
-                m.atencao.gate.set(&Tensor::new(alvo_g, &dev)?)?;
-            }
-        }
-        let grads = crate::treino::grads_achatados(&lt, &vars)?;
-        AdamWManual::clipar(&mut grads.clone(), 1.0);
-        let mut g2 = grads;
-        AdamWManual::clipar(&mut g2, 5.0);
-        opt.passo(g2);
-        perda_final = lp.to_scalar::<f32>()? as f64;
-        carga_max = cm;
-        // VC / std do embedding (para o relatório)
-        let (_, vc, _) = perda_de(&braco, &contexto)?;
-        vc_final = vc.to_scalar::<f32>()? as f64;
-        std_emb = {
-            let z = match &braco {
-                Braco::Pequena(a, _) => a.fwd(&contexto)?,
-                Braco::Densa(a, _) => a.fwd(&contexto)?,
-                Braco::Moe(m) => m.forward(&contexto, Papel::Codificador)?.saida,
-            };
-            z.flatten_all()?.to_vec1::<f32>()?.iter().map(|x| *x as f64).collect::<Vec<f64>>()
-                .chunks(n).map(|c| {
-                    let m = c.iter().sum::<f64>() / c.len() as f64;
-                    (c.iter().map(|x| (x - m).powi(2)).sum::<f64>() / c.len() as f64).sqrt()
-                }).sum::<f64>() / n as f64
-        };
-    }
-    if let Braco::Moe(m) = &braco {
-        let s = m.forward(&contexto, Papel::Codificador)?;
-        descartados = s.descartados;
-    }
-    Ok(RelatorioJepaMoe {
-        modo,
-        perda_pred_inicial: perda_inicial,
-        perda_pred_final: perda_final,
-        perda_vc_final: vc_final,
-        std_emb,
-        carga_max,
-        descartados,
-    })
-}
-
-// ---------------------------------------------------------------------------
-// Aplicação SOM — refinamento residual com alocação por QE (M-R5)
-// ---------------------------------------------------------------------------
-
-pub struct RelatorioSomMoe {
-    pub qe_antes: f64,
-    pub qe_depois: f64,
-    pub qe_alocacao_uniforme: f64,
-    pub carga_por_celula: Vec<usize>,
-    pub tempo_treino_s: f64,
-    /// qualidade da DECODIFICAÇÃO após redirecionamento (mse w_bmu → x).
-    pub mse_decodificador: f64,
-}
-
-/// Refina um SOM 4D treinado com um MoE redirecionável:
-/// 1. aloca especialistas por célula ∝ QE (water-filling — M-R5);
-/// 2. treina o papel Codificador como corretor residual
-///    `x̂ = w_bmu(x) + E(x)`;
-/// 3. mede QE′; repete com alocação uniforme (ablação do water-filling);
-/// 4. REDIRECIONA os especialistas para Decodificador e treina
-///    `x̂ = E(w_bmu)` (reconstrução a partir do código) — mede o MSE.
-pub fn refinar_som_com_moe(
-    dados: &Tensor,
-    centroides: &[Vec<f64>],
-    passos: usize,
-    semente: u64,
-) -> Result<RelatorioSomMoe> {
-    use std::time::Instant;
-    let t0 = Instant::now();
-    let dev = dados.device();
-    let n = dados.dim(0)?;
-    let d = dados.dim(1)?;
-    let m = centroides.len();
-    // BMU + QE por célula (tolera F32/F64)
-    let dados_v: Vec<Vec<f64>> = match dados.to_vec2::<f64>() {
-        Ok(v) => v,
-        Err(_) => dados
-            .to_vec2::<f32>()?
-            .iter()
-            .map(|l| l.iter().map(|x| *x as f64).collect())
-            .collect(),
-    };
-    let bmu: Vec<usize> = dados_v
-        .iter()
-        .map(|x| {
-            centroides
-                .iter()
-                .enumerate()
-                .min_by(|(i, a), (j, b)| {
-                    let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
-                    let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
-                    da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j))
-                })
-                .map(|(i, _)| i)
-                .unwrap_or(0)
-        })
-        .collect();
-    let mut qe_cel = vec![0f64; m];
-    let mut cont_cel = vec![0usize; m];
-    for (i, b) in bmu.iter().enumerate() {
-        let dist: f64 = centroides[*b].iter().zip(&dados_v[i]).map(|(w, v)| (w - v).powi(2)).sum();
-        qe_cel[*b] += dist.sqrt();
-        cont_cel[*b] += 1;
-    }
-    for i in 0..m {
-        if cont_cel[i] > 0 {
-            qe_cel[i] /= cont_cel[i] as f64;
-        }
-    }
-    let qe_antes: f64 = dados_v
-        .iter()
-        .enumerate()
-        .map(|(i, b)| {
-            let w = &centroides[bmu[i]];
-            (w.iter().zip(b).map(|(a, v)| (a - v).powi(2)).sum::<f64>()).sqrt()
-        })
-        .sum::<f64>()
-        / n as f64;
-
-    // ---------- braço water-filling ----------
-    // capacidade = m células + 8 especialistas EXTRA distribuídos ∝ QE
-    // (com C < m o water-filling degenera em uniforme — mínimo 1 por célula)
-    let capacidade_total = m + 8;
-    let aloca_wf = alocar_por_qe(&qe_cel, capacidade_total);
-    let qe_wf = treinar_corretor(dados, centroides, &bmu, &aloca_wf, passos, semente, &dev)?;
-    // ---------- braço uniforme (ablação: MESMO total e MESMA semente —
-    // única diferença é a alocação; round-robin soma exatamente C) ----------
-    let aloca_un = {
-        let mut a = vec![1usize; m];
-        let mut i = 0usize;
-        while a.iter().sum::<usize>() < capacidade_total {
-            a[i % m] += 1;
-            i += 1;
-        }
-        a
-    };
-    let qe_un = treinar_corretor(dados, centroides, &bmu, &aloca_un, passos, semente, &dev)?;
-
-    // ---------- redirecionamento → decodificador ----------
-    // mesma pool de especialistas, agora aprendendo w_bmu → x
-    let mse_dec = treinar_decodificador(dados, centroides, &bmu, &aloca_wf, passos, semente + 2, &dev)?;
-
-    Ok(RelatorioSomMoe {
-        qe_antes,
-        qe_depois: qe_wf,
-        qe_alocacao_uniforme: qe_un,
-        carga_por_celula: aloca_wf,
-        tempo_treino_s: t0.elapsed().as_secs_f64(),
-        mse_decodificador: mse_dec,
-    })
-}
-
-/// Corretor residual: x̂ = w_bmu + E_{célula}(x). Treina com AdamW.
-fn treinar_corretor(
-    dados: &Tensor,
-    centroides: &[Vec<f64>],
-    bmu: &[usize],
-    alocacao: &[usize],
-    passos: usize,
-    semente: u64,
-    dev: &Device,
-) -> Result<f64> {
-    let n = dados.dim(0)?;
-    let d = dados.dim(1)?;
-    // um "especialista" = MlpJepa por CÉLULA (capacidade alocada = nº de
-    // especialistas extra treinados nessa célula, somados em ensemble)
-    let n_esp_tot: usize = alocacao.iter().sum();
-    let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
-    for c in alocacao {
-        let mut v = Vec::new();
-        for _ in 0..(*c).max(1) {
-            v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
-        }
-        ensembles.push(v);
-    }
-    let mut vars: Vec<Var> = Vec::new();
-    for ens in &ensembles {
-        for e in ens {
-            vars.extend(e.vars());
-        }
-    }
-    let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
-    // tensores de apoio
-    let w_bmu = {
-        let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
-        Tensor::from_vec(v, (n, d), dev)?
-    };
-    let alvo_res = (dados - &w_bmu)?;
-    for _ in 0..passos {
-        let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
-        for (i, ens) in ensembles.iter().enumerate() {
-            // tokens da célula i
-            let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
-            if idx.is_empty() {
-                continue;
-            }
-            let m_idx = idx.len();
-            let it = Tensor::from_vec(idx, (m_idx,), dev)?;
-            let x_c = dados.index_select(&it, 0)?;
-            let r_c = alvo_res.index_select(&it, 0)?;
-            // ensemble: média das saídas
-            let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
-            for e in ens {
-                y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
-            }
-            let k = ens.len() as f64;
-            let yh = y.affine(1.0 / k, 0.0)?;
-            let dif = (&yh - &r_c)?;
-            soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
-        }
-        let _ = n_esp_tot;
-        let grads = crate::treino::grads_achatados(&soma, &vars)?;
-        let mut g = grads;
-        AdamWManual::clipar(&mut g, 5.0);
-        opt.passo(g);
-    }
-    // QE refinado
-    let mut qe = 0f64;
-    for (i, ens) in ensembles.iter().enumerate() {
-        let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
-        if idx.is_empty() {
-            continue;
-        }
-        let m_idx = idx.len();
-        let it = Tensor::from_vec(idx, (m_idx,), dev)?;
-        let x_c = dados.index_select(&it, 0)?;
-        let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
-        for e in ens {
-            y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
-        }
-        let k = ens.len() as f64;
-        let yh = y.affine(1.0 / k, 0.0)?;
-        let xhat = (w_bmu.index_select(&it, 0)? + &yh)?;
-        let dif = (&x_c - &xhat)?;
-        qe += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
-    }
-    Ok((qe / (n as f64 * d as f64)).sqrt() * (d as f64).sqrt()) // QE médio por ponto (norma L2)
-}
-
-/// Decodificador (pós-redirecionamento): x̂ = E(w_bmu) — reconstrução
-/// a partir apenas do código (centróide). Mede o MSE final.
-fn treinar_decodificador(
-    dados: &Tensor,
-    centroides: &[Vec<f64>],
-    bmu: &[usize],
-    alocacao: &[usize],
-    passos: usize,
-    semente: u64,
-    dev: &Device,
-) -> Result<f64> {
-    let _ = semente;
-    let n = dados.dim(0)?;
-    let d = dados.dim(1)?;
-    let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
-    for c in alocacao {
-        let mut v = Vec::new();
-        for _ in 0..(*c).max(1) {
-            v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
-        }
-        ensembles.push(v);
-    }
-    let mut vars: Vec<Var> = Vec::new();
-    for ens in &ensembles {
-        for e in ens {
-            vars.extend(e.vars());
-        }
-    }
-    let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
-    let w_bmu = {
-        let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
-        Tensor::from_vec(v, (n, d), dev)?
-    };
-    for _ in 0..passos {
-        let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
-        for (i, ens) in ensembles.iter().enumerate() {
-            let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
-            if idx.is_empty() {
-                continue;
-            }
-            let m_idx = idx.len();
-            let it = Tensor::from_vec(idx, (m_idx,), dev)?;
-            let w_c = w_bmu.index_select(&it, 0)?;
-            let x_c = dados.index_select(&it, 0)?;
-            let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
-            for e in ens {
-                y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
-            }
-            let k = ens.len() as f64;
-            let yh = y.affine(1.0 / k, 0.0)?;
-            let dif = (&yh - &x_c)?;
-            soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
-        }
-        let grads = crate::treino::grads_achatados(&soma, &vars)?;
-        let mut g = grads;
-        AdamWManual::clipar(&mut g, 5.0);
-        opt.passo(g);
-    }
-    // MSE final do decodificador
-    let mut mse = 0f64;
-    for (i, ens) in ensembles.iter().enumerate() {
-        let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
-        if idx.is_empty() {
-            continue;
-        }
-        let m_idx = idx.len();
-        let it = Tensor::from_vec(idx, (m_idx,), dev)?;
-        let w_c = w_bmu.index_select(&it, 0)?;
-        let x_c = dados.index_select(&it, 0)?;
-        let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
-        for e in ens {
-            y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
-        }
-        let k = ens.len() as f64;
-        let yh = y.affine(1.0 / k, 0.0)?;
-        let dif = (&yh - &x_c)?;
-        mse += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
-    }
-    Ok(mse / (n as f64 * d as f64))
-}
-
-pub fn versao() -> &'static str {
-    "moe-redirecionavel-0.6.0"
-}
-
-#[cfg(test)]
-#[allow(deprecated)] // testes usam o oráculo fwd (bug v080-1) de propósito
-mod testes {
-    use super::*;
-
-    fn dados_sinteticos(n: usize, d: usize, semente: u64) -> Tensor {
-        let mut rng = crate::rng::RngDeterministico::novo(semente);
-        let v: Vec<f32> = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect();
-        Tensor::from_vec(v, (n, d), &Device::Cpu).unwrap()
-    }
-
-    #[test]
-    fn mr1_invariancia_sob_redirecionamento() {
-        let dev = Device::Cpu;
-        let x = dados_sinteticos(64, 16, 3);
-        let mut moe = MoeRedirecionavel::novo(16, 6, 2, 64, &dev).unwrap();
-        let s1 = moe.fwd(&x, Papel::Codificador).unwrap();
-        let perda_antes = s1.perda_aux.to_scalar::<f32>().unwrap() as f64;
-        let carga_antes: usize = s1.carga.iter().sum();
-        moe.redirecionar_todos();
-        // após trocar TODOS os papéis, a passada Decodificador usa os
-        // especialistas que eram do codificador — a perda auxiliar do
-        // SUBCONJUNTO é comparável (mesma distribuição de roteamento)
-        let s2 = moe.fwd(&x, Papel::Decodificador).unwrap();
-        let perda_depois = s2.perda_aux.to_scalar::<f32>().unwrap() as f64;
-        let carga_depois: usize = s2.carga.iter().sum();
-        assert_eq!(carga_antes, carga_depois, "capacidade total conservada (M-R1)");
-        assert!(
-            (perda_antes - perda_depois).abs() < 2.0 + 1e-6,
-            "perda auxiliar da família conservada: {perda_antes:.4} vs {perda_depois:.4}"
-        );
-    }
-
-    #[test]
-    fn mr2_neutralidade_no_nascimento() {
-        let dev = Device::Cpu;
-        let x = dados_sinteticos(32, 8, 5);
-        let moe = MoeRedirecionavel::novo(8, 4, 2, 32, &dev).unwrap();
-        let g = moe.atencao.gate.as_tensor().to_scalar::<f32>().unwrap();
-        assert!(g == 0.0, "gate nasce zero");
-        let y = moe.atencao.fwd(&x).unwrap();
-        let dif = (&y - &x).unwrap().sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap();
-        assert!(dif == 0.0, "y = x bit-a-bit no nascimento (dif={dif})");
-    }
-
-    #[test]
-    fn mr3_paralelismo_e_determinismo() {
-        let dev = Device::Cpu;
-        let x = dados_sinteticos(96, 24, 7);
-        let moe = MoeRedirecionavel::novo(24, 8, 2, 96, &dev).unwrap();
-        let (_enc, _dec, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap();
-        // determinismo já garantido por assert interno; speedup registrado
-        assert!(t_par > 0.0 && t_seq > 0.0);
-        let _ = speedup;
-    }
-
-    #[test]
-    fn mr5_water_filling_minimiza_cota() {
-        // cota Σ q_i²/c_i: water-filling ≤ uniforme (Cauchy–Schwarz)
-        let qes = vec![0.2, 0.5, 1.0, 0.3];
-        let c_wf = alocar_por_qe(&qes, 8);
-        let c_un = vec![2usize; 4];
-        let f = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::<f64>();
-        assert!(
-            f(&c_wf) <= f(&c_un) + 1e-9,
-            "water-filling {c_wf:?} (cota {:.4}) deve ≤ uniforme (cota {:.4})",
-            f(&c_wf), f(&c_un)
-        );
-        assert_eq!(c_wf.iter().sum::<usize>(), 8);
-    }
-
-    #[test]
-    fn jepa_moe_aprende() {
-        let x = dados_sinteticos(64, 12, 11);
-        let r = treinar_jepa_com_moe(&x, "moe", 60, 0.5, 42).unwrap();
-        assert!(r.perda_pred_final < r.perda_pred_inicial, "perda preditiva cai");
-    }
-
-    /// **M-R6 (v0.8.0):** equivalência de VALORES entre `fwd` e
-    /// `forward` — mesma seleção (auxiliar compartilhado), mesma
-    /// saída, mesma perda auxiliar, mesma carga/descartados.
-    #[test]
-    fn mr6_equivalencia_de_valores() {
-        let dev = Device::Cpu;
-        for (n, d, e, k, cap, seed) in [
-            (64usize, 16usize, 6usize, 2usize, 64usize, 3u64),
-            (96, 24, 8, 2, 96, 5),
-            (48, 12, 4, 1, 24, 9), // capacidade apertada: força descartados
-        ] {
-            let x = dados_sinteticos(n, d, seed);
-            let moe = MoeRedirecionavel::novo(d, e, k, cap, &dev).unwrap();
-            let s_ref = moe.fwd(&x, Papel::Codificador).unwrap();
-            let s_vet = moe.forward(&x, Papel::Codificador).unwrap();
-            assert_eq!(s_ref.carga, s_vet.carga, "M-R6: mesma carga (n={n})");
-            assert_eq!(s_ref.usados, s_vet.usados, "M-R6: mesmos usados");
-            assert_eq!(s_ref.descartados, s_vet.descartados, "M-R6: mesmos descartados");
-            let dif = (&s_ref.saida - &s_vet.saida).unwrap()
-                .abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
-            assert!(dif < 1e-4, "M-R6: max|Δsaída| = {dif} (n={n}, cap={cap})");
-            let pa = s_ref.perda_aux.to_scalar::<f32>().unwrap();
-            let pb = s_vet.perda_aux.to_scalar::<f32>().unwrap();
-            assert!(
-                (pa - pb).abs() < 1e-4,
-                "M-R6: perda auxiliar {pa:.6} vs {pb:.6} (n={n})"
-            );
-        }
-    }
-
-    /// **M-R7 (v0.8.0):** restauração do fluxo de gradiente — bug v080-1.
-    /// Com a `fwd` (referência de valores) os especialistas e o roteador
-    /// NÃO recebem gradiente (grafo seccionado por to_vec2/from_vec); com
-    /// a `forward` TODOS recebem (index_add/index_select vivos).
-    #[test]
-    fn mr7_restauracao_do_gradiente() {
-        let dev = Device::Cpu;
-        let x = dados_sinteticos(48, 12, 13);
-        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
-        let norma_grads = |vetorizada: bool| -> (f64, f64) {
-            let s = if vetorizada {
-                moe.forward(&x, Papel::Codificador).unwrap()
-            } else {
-                moe.fwd(&x, Papel::Codificador).unwrap()
-            };
-            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
-            let grads = perda.backward().unwrap();
-            let mut n_roteador = 0.0f64;
-            for v in moe.roteador.vars() {
-                if let Some(g) = grads.get(&v) {
-                    n_roteador += g.sqr().unwrap().sum_all().unwrap()
-                        .to_scalar::<f32>().unwrap() as f64;
-                }
-            }
-            let mut n_experts = 0.0f64;
-            for e in &moe.especialistas {
-                for v in e.vars() {
-                    if let Some(g) = grads.get(&v) {
-                        n_experts += g.sqr().unwrap().sum_all().unwrap()
-                            .to_scalar::<f32>().unwrap() as f64;
-                    }
-                }
-            }
-            (n_roteador, n_experts)
-        };
-        // (a) o bug v080-1 é REAL: na fwd, roteador e especialistas têm
-        // gradiente ZERO (grafo seccionado) — documentado, não corrigido na
-        // fwd (referência de valores preservada por decisão de projeto)
-        let (r_ref, e_ref) = norma_grads(false);
-        assert!(
-            r_ref == 0.0 && e_ref == 0.0,
-            "M-R7: bug v080-1 documentado — fwd secciona o grafo (roteador {r_ref}, experts {e_ref})"
-        );
-        // (b) a correção: na vetorizada, TODOS recebem gradiente
-        let (r_vet, e_vet) = norma_grads(true);
-        assert!(
-            r_vet > 0.0,
-            "M-R7: roteador recebe gradiente na vetorizada ({r_vet})"
-        );
-        assert!(
-            e_vet > 0.0,
-            "M-R7: especialistas recebem gradiente na vetorizada ({e_vet})"
-        );
-    }
-
-    /// **M-R8 (v0.8.0):** fim-a-fim — com a vetorizada, o treino REALMENTE
-    /// atualiza os pesos dos especialistas (regressão do bug v080-1: antes
-    /// só a atenção própria treinava no braço MoE).
-    #[test]
-    fn mr8_treino_atualiza_especialistas() {
-        let dev = Device::Cpu;
-        let x = dados_sinteticos(48, 12, 17);
-        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
-        // snapshot com dados PRÓPRIOS (to_vec1) — detach() compartilha o
-        // storage e o set() do otimizador sobrescreveria a "cópia"
-        let snapshot: Vec<Vec<f32>> = moe
-            .especialistas
-            .iter()
-            .map(|e| {
-                e.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap()
-            })
-            .collect();
-        // treino curto com gradiente fluindo
-        let vars = moe.vars();
-        let mut opt = crate::treino::AdamWManual::novo(vars.clone(), 3e-3, 0.0);
-        for _ in 0..5 {
-            let s = moe.forward(&x, Papel::Codificador).unwrap();
-            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
-            let grads = crate::treino::grads_achatados(&perda, &vars).unwrap();
-            opt.passo(grads);
-        }
-        let mut delta_max = 0.0f64;
-        for (e, antes) in moe.especialistas.iter().zip(snapshot.iter()) {
-            let agora = e.vars()[0].as_tensor().flatten_all().unwrap()
-                .to_vec1::<f32>().unwrap();
-            let dif = agora.iter().zip(antes.iter()).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
-            delta_max = delta_max.max(dif as f64);
-        }
-        let _ = &vars;
-        assert!(
-            delta_max > 0.0,
-            "M-R8: especialistas devem mudar no treino (delta_max={delta_max})"
-        );
-    }
-}
-
-#[cfg(test)]
-mod teste_som_moe_integrado {
-    use super::*;
-
-    #[test]
-    fn debug_som_com_moe_caminho() {
-        let dev = Device::Cpu;
-        let dados_v: Vec<Vec<f64>> = (0..32).map(|i| (0..16).map(|j| (i * 7 + j * 3) as f64 / 100.0).collect()).collect();
-        let (n, d) = (dados_v.len(), 16);
-        let t = Tensor::from_vec(dados_v.into_iter().flatten().collect::<Vec<f64>>(), (n, d), &dev).unwrap()
-            .to_dtype(candle_core::DType::F32).unwrap();
-        let cfg = crate::som4d::CfgSom4D { nx: 2, ny: 2, nz: 2, nt: 2, ..Default::default() };
-        let som = crate::som4d::treinar_som4d(&t, &cfg, &dev).unwrap();
-        let centroides = som.prototipos.clone();
-        let r = refinar_som_com_moe(&t, &centroides, 30, 1).unwrap();
-        println!("qe {} -> {} (wf) | uniforme {}", r.qe_antes, r.qe_depois, r.qe_alocacao_uniforme);
-        assert!(r.qe_depois < r.qe_antes, "corretor MoE reduz o QE");
-        assert!(r.mse_decodificador < r.qe_antes.powi(2), "redirect decodifica");
-    }
-}

src/moe_redirecionavel/teste_integrado.rs

@@ -0,0 +1,26 @@
+//! `moe_redirecionavel::teste_integrado` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+#[cfg(test)]
+mod teste_som_moe_integrado {
+    use super::*;
+
+    #[test]
+    fn debug_som_com_moe_caminho() {
+        let dev = Device::Cpu;
+        let dados_v: Vec<Vec<f64>> = (0..32).map(|i| (0..16).map(|j| (i * 7 + j * 3) as f64 / 100.0).collect()).collect();
+        let (n, d) = (dados_v.len(), 16);
+        let t = Tensor::from_vec(dados_v.into_iter().flatten().collect::<Vec<f64>>(), (n, d), &dev).unwrap()
+            .to_dtype(candle_core::DType::F32).unwrap();
+        let cfg = crate::som4d::CfgSom4D { nx: 2, ny: 2, nz: 2, nt: 2, ..Default::default() };
+        let som = crate::som4d::treinar_som4d(&t, &cfg, &dev).unwrap();
+        let centroides = som.prototipos.clone();
+        let r = refinar_som_com_moe(&t, &centroides, 30, 1).unwrap();
+        println!("qe {} -> {} (wf) | uniforme {}", r.qe_antes, r.qe_depois, r.qe_alocacao_uniforme);
+        assert!(r.qe_depois < r.qe_antes, "corretor MoE reduz o QE");
+        assert!(r.mse_decodificador < r.qe_antes.powi(2), "redirect decodifica");
+    }
+}

src/moe_redirecionavel/testes.rs

@@ -0,0 +1,209 @@
+//! `moe_redirecionavel::testes` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+#[cfg(test)]
+#[allow(deprecated)] // testes usam o oráculo fwd (bug v080-1) de propósito
+mod testes {
+    use super::*;
+
+    fn dados_sinteticos(n: usize, d: usize, semente: u64) -> Tensor {
+        let mut rng = crate::rng::RngDeterministico::novo(semente);
+        let v: Vec<f32> = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+        Tensor::from_vec(v, (n, d), &Device::Cpu).unwrap()
+    }
+
+    #[test]
+    fn mr1_invariancia_sob_redirecionamento() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(64, 16, 3);
+        let mut moe = MoeRedirecionavel::novo(16, 6, 2, 64, &dev).unwrap();
+        let s1 = moe.fwd(&x, Papel::Codificador).unwrap();
+        let perda_antes = s1.perda_aux.to_scalar::<f32>().unwrap() as f64;
+        let carga_antes: usize = s1.carga.iter().sum();
+        moe.redirecionar_todos();
+        // após trocar TODOS os papéis, a passada Decodificador usa os
+        // especialistas que eram do codificador — a perda auxiliar do
+        // SUBCONJUNTO é comparável (mesma distribuição de roteamento)
+        let s2 = moe.fwd(&x, Papel::Decodificador).unwrap();
+        let perda_depois = s2.perda_aux.to_scalar::<f32>().unwrap() as f64;
+        let carga_depois: usize = s2.carga.iter().sum();
+        assert_eq!(carga_antes, carga_depois, "capacidade total conservada (M-R1)");
+        assert!(
+            (perda_antes - perda_depois).abs() < 2.0 + 1e-6,
+            "perda auxiliar da família conservada: {perda_antes:.4} vs {perda_depois:.4}"
+        );
+    }
+
+    #[test]
+    fn mr2_neutralidade_no_nascimento() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(32, 8, 5);
+        let moe = MoeRedirecionavel::novo(8, 4, 2, 32, &dev).unwrap();
+        let g = moe.atencao.gate.as_tensor().to_scalar::<f32>().unwrap();
+        assert!(g == 0.0, "gate nasce zero");
+        let y = moe.atencao.fwd(&x).unwrap();
+        let dif = (&y - &x).unwrap().sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(dif == 0.0, "y = x bit-a-bit no nascimento (dif={dif})");
+    }
+
+    #[test]
+    fn mr3_paralelismo_e_determinismo() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(96, 24, 7);
+        let moe = MoeRedirecionavel::novo(24, 8, 2, 96, &dev).unwrap();
+        let (_enc, _dec, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap();
+        // determinismo já garantido por assert interno; speedup registrado
+        assert!(t_par > 0.0 && t_seq > 0.0);
+        let _ = speedup;
+    }
+
+    #[test]
+    fn mr5_water_filling_minimiza_cota() {
+        // cota Σ q_i²/c_i: water-filling ≤ uniforme (Cauchy–Schwarz)
+        let qes = vec![0.2, 0.5, 1.0, 0.3];
+        let c_wf = alocar_por_qe(&qes, 8);
+        let c_un = vec![2usize; 4];
+        let f = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::<f64>();
+        assert!(
+            f(&c_wf) <= f(&c_un) + 1e-9,
+            "water-filling {c_wf:?} (cota {:.4}) deve ≤ uniforme (cota {:.4})",
+            f(&c_wf), f(&c_un)
+        );
+        assert_eq!(c_wf.iter().sum::<usize>(), 8);
+    }
+
+    #[test]
+    fn jepa_moe_aprende() {
+        let x = dados_sinteticos(64, 12, 11);
+        let r = treinar_jepa_com_moe(&x, "moe", 60, 0.5, 42).unwrap();
+        assert!(r.perda_pred_final < r.perda_pred_inicial, "perda preditiva cai");
+    }
+
+    /// **M-R6 (v0.8.0):** equivalência de VALORES entre `fwd` e
+    /// `forward` — mesma seleção (auxiliar compartilhado), mesma
+    /// saída, mesma perda auxiliar, mesma carga/descartados.
+    #[test]
+    fn mr6_equivalencia_de_valores() {
+        let dev = Device::Cpu;
+        for (n, d, e, k, cap, seed) in [
+            (64usize, 16usize, 6usize, 2usize, 64usize, 3u64),
+            (96, 24, 8, 2, 96, 5),
+            (48, 12, 4, 1, 24, 9), // capacidade apertada: força descartados
+        ] {
+            let x = dados_sinteticos(n, d, seed);
+            let moe = MoeRedirecionavel::novo(d, e, k, cap, &dev).unwrap();
+            let s_ref = moe.fwd(&x, Papel::Codificador).unwrap();
+            let s_vet = moe.forward(&x, Papel::Codificador).unwrap();
+            assert_eq!(s_ref.carga, s_vet.carga, "M-R6: mesma carga (n={n})");
+            assert_eq!(s_ref.usados, s_vet.usados, "M-R6: mesmos usados");
+            assert_eq!(s_ref.descartados, s_vet.descartados, "M-R6: mesmos descartados");
+            let dif = (&s_ref.saida - &s_vet.saida).unwrap()
+                .abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
+            assert!(dif < 1e-4, "M-R6: max|Δsaída| = {dif} (n={n}, cap={cap})");
+            let pa = s_ref.perda_aux.to_scalar::<f32>().unwrap();
+            let pb = s_vet.perda_aux.to_scalar::<f32>().unwrap();
+            assert!(
+                (pa - pb).abs() < 1e-4,
+                "M-R6: perda auxiliar {pa:.6} vs {pb:.6} (n={n})"
+            );
+        }
+    }
+
+    /// **M-R7 (v0.8.0):** restauração do fluxo de gradiente — bug v080-1.
+    /// Com a `fwd` (referência de valores) os especialistas e o roteador
+    /// NÃO recebem gradiente (grafo seccionado por to_vec2/from_vec); com
+    /// a `forward` TODOS recebem (index_add/index_select vivos).
+    #[test]
+    fn mr7_restauracao_do_gradiente() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(48, 12, 13);
+        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
+        let norma_grads = |vetorizada: bool| -> (f64, f64) {
+            let s = if vetorizada {
+                moe.forward(&x, Papel::Codificador).unwrap()
+            } else {
+                moe.fwd(&x, Papel::Codificador).unwrap()
+            };
+            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+            let grads = perda.backward().unwrap();
+            let mut n_roteador = 0.0f64;
+            for v in moe.roteador.vars() {
+                if let Some(g) = grads.get(&v) {
+                    n_roteador += g.sqr().unwrap().sum_all().unwrap()
+                        .to_scalar::<f32>().unwrap() as f64;
+                }
+            }
+            let mut n_experts = 0.0f64;
+            for e in &moe.especialistas {
+                for v in e.vars() {
+                    if let Some(g) = grads.get(&v) {
+                        n_experts += g.sqr().unwrap().sum_all().unwrap()
+                            .to_scalar::<f32>().unwrap() as f64;
+                    }
+                }
+            }
+            (n_roteador, n_experts)
+        };
+        // (a) o bug v080-1 é REAL: na fwd, roteador e especialistas têm
+        // gradiente ZERO (grafo seccionado) — documentado, não corrigido na
+        // fwd (referência de valores preservada por decisão de projeto)
+        let (r_ref, e_ref) = norma_grads(false);
+        assert!(
+            r_ref == 0.0 && e_ref == 0.0,
+            "M-R7: bug v080-1 documentado — fwd secciona o grafo (roteador {r_ref}, experts {e_ref})"
+        );
+        // (b) a correção: na vetorizada, TODOS recebem gradiente
+        let (r_vet, e_vet) = norma_grads(true);
+        assert!(
+            r_vet > 0.0,
+            "M-R7: roteador recebe gradiente na vetorizada ({r_vet})"
+        );
+        assert!(
+            e_vet > 0.0,
+            "M-R7: especialistas recebem gradiente na vetorizada ({e_vet})"
+        );
+    }
+
+    /// **M-R8 (v0.8.0):** fim-a-fim — com a vetorizada, o treino REALMENTE
+    /// atualiza os pesos dos especialistas (regressão do bug v080-1: antes
+    /// só a atenção própria treinava no braço MoE).
+    #[test]
+    fn mr8_treino_atualiza_especialistas() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(48, 12, 17);
+        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
+        // snapshot com dados PRÓPRIOS (to_vec1) — detach() compartilha o
+        // storage e o set() do otimizador sobrescreveria a "cópia"
+        let snapshot: Vec<Vec<f32>> = moe
+            .especialistas
+            .iter()
+            .map(|e| {
+                e.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap()
+            })
+            .collect();
+        // treino curto com gradiente fluindo
+        let vars = moe.vars();
+        let mut opt = crate::treino::AdamWManual::novo(vars.clone(), 3e-3, 0.0);
+        for _ in 0..5 {
+            let s = moe.forward(&x, Papel::Codificador).unwrap();
+            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+            let grads = crate::treino::grads_achatados(&perda, &vars).unwrap();
+            opt.passo(grads);
+        }
+        let mut delta_max = 0.0f64;
+        for (e, antes) in moe.especialistas.iter().zip(snapshot.iter()) {
+            let agora = e.vars()[0].as_tensor().flatten_all().unwrap()
+                .to_vec1::<f32>().unwrap();
+            let dif = agora.iter().zip(antes.iter()).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
+            delta_max = delta_max.max(dif as f64);
+        }
+        let _ = &vars;
+        assert!(
+            delta_max > 0.0,
+            "M-R8: especialistas devem mudar no treino (delta_max={delta_max})"
+        );
+    }
+}

src/moe_redirecionavel/treino.rs

@@ -0,0 +1,463 @@
+//! `moe_redirecionavel::treino` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Aplicação JEPA — codificador/preditor redirecionáveis com MoE
+// ---------------------------------------------------------------------------
+
+pub struct RelatorioJepaMoe {
+    pub modo: &'static str,
+    pub perda_pred_inicial: f64,
+    pub perda_pred_final: f64,
+    pub perda_vc_final: f64,
+    pub std_emb: f64,
+    pub carga_max: usize,
+    pub descartados: usize,
+}
+
+/// Treino JEPA compacto com três braços (ablação honesta):
+/// - `"pequena"`: codificador/preditor MLP simples (baseline);
+/// - `"densa"`: MLP com o TOTAL de parâmetros dos especialistas (capacidade
+///   equiparada, SEM roteamento — isola o ganho do roteamento);
+/// - `"moe"`: `MoeRedirecionavel` nos dois caminhos (Codificador no
+///   codificador, Decodificador no preditor) com atenção própria.
+pub fn treinar_jepa_com_moe(
+    patches: &Tensor,
+    modo: &'static str,
+    passos: usize,
+    frac_mascara: f64,
+    semente: u64,
+) -> Result<RelatorioJepaMoe> {
+    let dev = patches.device();
+    let n = patches.dim(0)?;
+    let d = patches.dim(1)?;
+    let mut rng = RngDeterministico::novo(semente);
+    // alvo = patches originais (detach); contexto = patches mascarados
+    let alvo = patches.detach();
+    let contexto = {
+        let mut v = patches.flatten_all()?.to_vec1::<f32>()?;
+        for x in v.iter_mut() {
+            if rng.uniforme() < frac_mascara {
+                *x = 0.0;
+            }
+        }
+        Tensor::from_vec(v, (n, d), &dev)?
+    };
+    let e = 4usize; // especialistas por papel no braço moe
+    let n_top = 2;
+    let capacidade = n;
+
+    // braços
+    enum Braco {
+        Pequena(MlpJepa, MlpJepa),
+        Densa(MlpJepa, MlpJepa),
+        Moe(MoeRedirecionavel),
+    }
+    let braco = match modo {
+        "pequena" => Braco::Pequena(
+            MlpJepa::novo(d, 2 * d, d, &dev)?,
+            MlpJepa::novo(d, 2 * d, d, &dev)?,
+        ),
+        "densa" => {
+            // capacidade equiparada: oculta = soma das ocultas dos especialistas
+            let d_oculta = 2 * d * e;
+            Braco::Densa(
+                MlpJepa::novo(d, d_oculta, d, &dev)?,
+                MlpJepa::novo(d, d_oculta, d, &dev)?,
+            )
+        }
+        _ => Braco::Moe(MoeRedirecionavel::novo(d, 2 * e, n_top, capacidade, &dev)?),
+    };
+
+    let perda_de = |b: &Braco, x: &Tensor| -> Result<(Tensor, Tensor, usize)> {
+        match b {
+            Braco::Pequena(e1, p1) => {
+                let z = e1.fwd(x)?;
+                let yh = p1.fwd(&z)?;
+                let dif = (&yh - &alvo)?;
+                Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
+                    z.sqr()?.mean_all()?, 0))
+            }
+            Braco::Densa(e1, p1) => {
+                let z = e1.fwd(x)?;
+                let yh = p1.fwd(&z)?;
+                let dif = (&yh - &alvo)?;
+                Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
+                    z.sqr()?.mean_all()?, 0))
+            }
+            Braco::Moe(m) => {
+                // v0.9.0: forward (ex-fwd_vetorizado) — gradiente flui aos
+                // especialistas e ao roteador (a fwd seccionava o grafo)
+                let s_enc = m.forward(x, Papel::Codificador)?;
+                let s_dec = m.forward(&s_enc.saida, Papel::Decodificador)?;
+                let dif = (&s_dec.saida - &alvo)?;
+                let lp = (dif.sqr()?.sum_all()? / (n as f64 * d as f64))?;
+                // perda total = preditiva + aux balanceamento (ambos papéis)
+                let lt = (lp.affine(1.0, 0.0)? + s_enc.perda_aux.affine(m.lambda_aux, 0.0)?
+                    + s_dec.perda_aux.affine(m.lambda_aux, 0.0)?)?;
+                let carga_max = s_enc.carga.iter().copied().fold(0, usize::max)
+                    .max(s_dec.carga.iter().copied().fold(0, usize::max));
+                Ok((lt, lp, carga_max))
+            }
+        }
+    };
+
+    let (mut opt, vars): (AdamWManual, Vec<Var>) = match &braco {
+        Braco::Pequena(a, b) => {
+            let v = [a.vars(), b.vars()].concat();
+            (AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
+        }
+        Braco::Densa(a, b) => {
+            let v = [a.vars(), b.vars()].concat();
+            (AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
+        }
+        Braco::Moe(m) => (AdamWManual::novo(m.vars(), 3e-3, 0.0), m.vars()),
+    };
+    // atenção própria: gate nasce 0; sobe 1 passo em 8 (aquecimento honesto
+    // do mecanismo — T-P5 análogo: neutralidade no nascimento, gradiente flui)
+    if let Braco::Moe(m) = &braco {
+        let g0 = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
+        let _ = g0;
+    }
+
+    let (l0, _, _) = perda_de(&braco, &contexto)?;
+    let perda_inicial = l0.to_scalar::<f32>()? as f64;
+    let mut perda_final = perda_inicial;
+    let mut vc_final = 0.0;
+    let mut carga_max = 0usize;
+    let mut descartados = 0usize;
+    let mut std_emb = 0.0;
+    for passo in 0..passos {
+        let (lt, lp, cm) = perda_de(&braco, &contexto)?;
+        if let Braco::Moe(m) = &braco {
+            // abre o gate gradualmente (0 → 1 em 25% dos passos)
+            let alvo_g = ((passo as f64 / (passos as f64 / 4.0).max(1.0)).min(1.0)) as f32;
+            let g_atual = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
+            if (alvo_g as f64 - g_atual).abs() > 1e-9 {
+                m.atencao.gate.set(&Tensor::new(alvo_g, &dev)?)?;
+            }
+        }
+        let grads = crate::treino::grads_achatados(&lt, &vars)?;
+        AdamWManual::clipar(&mut grads.clone(), 1.0);
+        let mut g2 = grads;
+        AdamWManual::clipar(&mut g2, 5.0);
+        opt.passo(g2);
+        perda_final = lp.to_scalar::<f32>()? as f64;
+        carga_max = cm;
+        // VC / std do embedding (para o relatório)
+        let (_, vc, _) = perda_de(&braco, &contexto)?;
+        vc_final = vc.to_scalar::<f32>()? as f64;
+        std_emb = {
+            let z = match &braco {
+                Braco::Pequena(a, _) => a.fwd(&contexto)?,
+                Braco::Densa(a, _) => a.fwd(&contexto)?,
+                Braco::Moe(m) => m.forward(&contexto, Papel::Codificador)?.saida,
+            };
+            z.flatten_all()?.to_vec1::<f32>()?.iter().map(|x| *x as f64).collect::<Vec<f64>>()
+                .chunks(n).map(|c| {
+                    let m = c.iter().sum::<f64>() / c.len() as f64;
+                    (c.iter().map(|x| (x - m).powi(2)).sum::<f64>() / c.len() as f64).sqrt()
+                }).sum::<f64>() / n as f64
+        };
+    }
+    if let Braco::Moe(m) = &braco {
+        let s = m.forward(&contexto, Papel::Codificador)?;
+        descartados = s.descartados;
+    }
+    Ok(RelatorioJepaMoe {
+        modo,
+        perda_pred_inicial: perda_inicial,
+        perda_pred_final: perda_final,
+        perda_vc_final: vc_final,
+        std_emb,
+        carga_max,
+        descartados,
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Aplicação SOM — refinamento residual com alocação por QE (M-R5)
+// ---------------------------------------------------------------------------
+
+pub struct RelatorioSomMoe {
+    pub qe_antes: f64,
+    pub qe_depois: f64,
+    pub qe_alocacao_uniforme: f64,
+    pub carga_por_celula: Vec<usize>,
+    pub tempo_treino_s: f64,
+    /// qualidade da DECODIFICAÇÃO após redirecionamento (mse w_bmu → x).
+    pub mse_decodificador: f64,
+}
+
+/// Refina um SOM 4D treinado com um MoE redirecionável:
+/// 1. aloca especialistas por célula ∝ QE (water-filling — M-R5);
+/// 2. treina o papel Codificador como corretor residual
+///    `x̂ = w_bmu(x) + E(x)`;
+/// 3. mede QE′; repete com alocação uniforme (ablação do water-filling);
+/// 4. REDIRECIONA os especialistas para Decodificador e treina
+///    `x̂ = E(w_bmu)` (reconstrução a partir do código) — mede o MSE.
+pub fn refinar_som_com_moe(
+    dados: &Tensor,
+    centroides: &[Vec<f64>],
+    passos: usize,
+    semente: u64,
+) -> Result<RelatorioSomMoe> {
+    use std::time::Instant;
+    let t0 = Instant::now();
+    let dev = dados.device();
+    let n = dados.dim(0)?;
+    let d = dados.dim(1)?;
+    let m = centroides.len();
+    // BMU + QE por célula (tolera F32/F64)
+    let dados_v: Vec<Vec<f64>> = match dados.to_vec2::<f64>() {
+        Ok(v) => v,
+        Err(_) => dados
+            .to_vec2::<f32>()?
+            .iter()
+            .map(|l| l.iter().map(|x| *x as f64).collect())
+            .collect(),
+    };
+    let bmu: Vec<usize> = dados_v
+        .iter()
+        .map(|x| {
+            centroides
+                .iter()
+                .enumerate()
+                .min_by(|(i, a), (j, b)| {
+                    let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
+                    let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
+                    da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j))
+                })
+                .map(|(i, _)| i)
+                .unwrap_or(0)
+        })
+        .collect();
+    let mut qe_cel = vec![0f64; m];
+    let mut cont_cel = vec![0usize; m];
+    for (i, b) in bmu.iter().enumerate() {
+        let dist: f64 = centroides[*b].iter().zip(&dados_v[i]).map(|(w, v)| (w - v).powi(2)).sum();
+        qe_cel[*b] += dist.sqrt();
+        cont_cel[*b] += 1;
+    }
+    for i in 0..m {
+        if cont_cel[i] > 0 {
+            qe_cel[i] /= cont_cel[i] as f64;
+        }
+    }
+    let qe_antes: f64 = dados_v
+        .iter()
+        .enumerate()
+        .map(|(i, b)| {
+            let w = &centroides[bmu[i]];
+            (w.iter().zip(b).map(|(a, v)| (a - v).powi(2)).sum::<f64>()).sqrt()
+        })
+        .sum::<f64>()
+        / n as f64;
+
+    // ---------- braço water-filling ----------
+    // capacidade = m células + 8 especialistas EXTRA distribuídos ∝ QE
+    // (com C < m o water-filling degenera em uniforme — mínimo 1 por célula)
+    let capacidade_total = m + 8;
+    let aloca_wf = alocar_por_qe(&qe_cel, capacidade_total);
+    let qe_wf = treinar_corretor(dados, centroides, &bmu, &aloca_wf, passos, semente, &dev)?;
+    // ---------- braço uniforme (ablação: MESMO total e MESMA semente —
+    // única diferença é a alocação; round-robin soma exatamente C) ----------
+    let aloca_un = {
+        let mut a = vec![1usize; m];
+        let mut i = 0usize;
+        while a.iter().sum::<usize>() < capacidade_total {
+            a[i % m] += 1;
+            i += 1;
+        }
+        a
+    };
+    let qe_un = treinar_corretor(dados, centroides, &bmu, &aloca_un, passos, semente, &dev)?;
+
+    // ---------- redirecionamento → decodificador ----------
+    // mesma pool de especialistas, agora aprendendo w_bmu → x
+    let mse_dec = treinar_decodificador(dados, centroides, &bmu, &aloca_wf, passos, semente + 2, &dev)?;
+
+    Ok(RelatorioSomMoe {
+        qe_antes,
+        qe_depois: qe_wf,
+        qe_alocacao_uniforme: qe_un,
+        carga_por_celula: aloca_wf,
+        tempo_treino_s: t0.elapsed().as_secs_f64(),
+        mse_decodificador: mse_dec,
+    })
+}
+
+/// Corretor residual: x̂ = w_bmu + E_{célula}(x). Treina com AdamW.
+fn treinar_corretor(
+    dados: &Tensor,
+    centroides: &[Vec<f64>],
+    bmu: &[usize],
+    alocacao: &[usize],
+    passos: usize,
+    semente: u64,
+    dev: &Device,
+) -> Result<f64> {
+    let n = dados.dim(0)?;
+    let d = dados.dim(1)?;
+    // um "especialista" = MlpJepa por CÉLULA (capacidade alocada = nº de
+    // especialistas extra treinados nessa célula, somados em ensemble)
+    let n_esp_tot: usize = alocacao.iter().sum();
+    let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
+    for c in alocacao {
+        let mut v = Vec::new();
+        for _ in 0..(*c).max(1) {
+            v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
+        }
+        ensembles.push(v);
+    }
+    let mut vars: Vec<Var> = Vec::new();
+    for ens in &ensembles {
+        for e in ens {
+            vars.extend(e.vars());
+        }
+    }
+    let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
+    // tensores de apoio
+    let w_bmu = {
+        let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
+        Tensor::from_vec(v, (n, d), dev)?
+    };
+    let alvo_res = (dados - &w_bmu)?;
+    for _ in 0..passos {
+        let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
+        for (i, ens) in ensembles.iter().enumerate() {
+            // tokens da célula i
+            let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
+            if idx.is_empty() {
+                continue;
+            }
+            let m_idx = idx.len();
+            let it = Tensor::from_vec(idx, (m_idx,), dev)?;
+            let x_c = dados.index_select(&it, 0)?;
+            let r_c = alvo_res.index_select(&it, 0)?;
+            // ensemble: média das saídas
+            let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
+            for e in ens {
+                y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
+            }
+            let k = ens.len() as f64;
+            let yh = y.affine(1.0 / k, 0.0)?;
+            let dif = (&yh - &r_c)?;
+            soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
+        }
+        let _ = n_esp_tot;
+        let grads = crate::treino::grads_achatados(&soma, &vars)?;
+        let mut g = grads;
+        AdamWManual::clipar(&mut g, 5.0);
+        opt.passo(g);
+    }
+    // QE refinado
+    let mut qe = 0f64;
+    for (i, ens) in ensembles.iter().enumerate() {
+        let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
+        if idx.is_empty() {
+            continue;
+        }
+        let m_idx = idx.len();
+        let it = Tensor::from_vec(idx, (m_idx,), dev)?;
+        let x_c = dados.index_select(&it, 0)?;
+        let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
+        for e in ens {
+            y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
+        }
+        let k = ens.len() as f64;
+        let yh = y.affine(1.0 / k, 0.0)?;
+        let xhat = (w_bmu.index_select(&it, 0)? + &yh)?;
+        let dif = (&x_c - &xhat)?;
+        qe += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+    }
+    Ok((qe / (n as f64 * d as f64)).sqrt() * (d as f64).sqrt()) // QE médio por ponto (norma L2)
+}
+
+/// Decodificador (pós-redirecionamento): x̂ = E(w_bmu) — reconstrução
+/// a partir apenas do código (centróide). Mede o MSE final.
+fn treinar_decodificador(
+    dados: &Tensor,
+    centroides: &[Vec<f64>],
+    bmu: &[usize],
+    alocacao: &[usize],
+    passos: usize,
+    semente: u64,
+    dev: &Device,
+) -> Result<f64> {
+    let _ = semente;
+    let n = dados.dim(0)?;
+    let d = dados.dim(1)?;
+    let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
+    for c in alocacao {
+        let mut v = Vec::new();
+        for _ in 0..(*c).max(1) {
+            v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
+        }
+        ensembles.push(v);
+    }
+    let mut vars: Vec<Var> = Vec::new();
+    for ens in &ensembles {
+        for e in ens {
+            vars.extend(e.vars());
+        }
+    }
+    let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
+    let w_bmu = {
+        let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
+        Tensor::from_vec(v, (n, d), dev)?
+    };
+    for _ in 0..passos {
+        let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
+        for (i, ens) in ensembles.iter().enumerate() {
+            let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
+            if idx.is_empty() {
+                continue;
+            }
+            let m_idx = idx.len();
+            let it = Tensor::from_vec(idx, (m_idx,), dev)?;
+            let w_c = w_bmu.index_select(&it, 0)?;
+            let x_c = dados.index_select(&it, 0)?;
+            let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
+            for e in ens {
+                y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
+            }
+            let k = ens.len() as f64;
+            let yh = y.affine(1.0 / k, 0.0)?;
+            let dif = (&yh - &x_c)?;
+            soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
+        }
+        let grads = crate::treino::grads_achatados(&soma, &vars)?;
+        let mut g = grads;
+        AdamWManual::clipar(&mut g, 5.0);
+        opt.passo(g);
+    }
+    // MSE final do decodificador
+    let mut mse = 0f64;
+    for (i, ens) in ensembles.iter().enumerate() {
+        let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
+        if idx.is_empty() {
+            continue;
+        }
+        let m_idx = idx.len();
+        let it = Tensor::from_vec(idx, (m_idx,), dev)?;
+        let w_c = w_bmu.index_select(&it, 0)?;
+        let x_c = dados.index_select(&it, 0)?;
+        let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
+        for e in ens {
+            y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
+        }
+        let k = ens.len() as f64;
+        let yh = y.affine(1.0 / k, 0.0)?;
+        let dif = (&yh - &x_c)?;
+        mse += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+    }
+    Ok(mse / (n as f64 * d as f64))
+}
+
+pub fn versao() -> &'static str {
+    "moe-redirecionavel-0.6.0"
+}

src/pensamento/combinador.rs

@@ -0,0 +1,73 @@
+//! `pensamento::combinador` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// Combinador algébrico (T-P3 — projeção ridge, Teo V-1' portado)
+// ---------------------------------------------------------------------------
+
+/// Projeção ridge: `r* = (WᵀW + εI)^{−1} Wᵀ r_alvo` — minimizador de
+/// `‖W r − r_alvo‖² + ε‖r‖²` (o montador algébrico do "re-encaixe de peças").
+///
+/// **Prova (T-P3):** a função é quadrática estritamente convexa (ε > 0);
+/// o gradiente anula-se exatamente em `r*` acima; o resíduo mínimo é
+/// `‖(I − W(WᵀW+εI)^{−1}Wᵀ) r_alvo‖` — análogo direto do Teo V-1'.
+pub fn projetar_ridge(w: &Tensor, r_alvo: &Tensor, eps: f64) -> Result<Tensor> {
+    // w: (m, n), r_alvo: (m, d) ⇒ r*: (n, d)
+    let n = w.dim(1)?;
+    let dev = w.device();
+    let wt = w.transpose(0, 1)?;
+    let wtw = wt.matmul(w)?;
+    let ident = Tensor::eye(n, candle_core::DType::F32, &dev)?.affine(eps, 0.0)?;
+    let m = (&wtw + &ident)?;
+    let rhs = wt.matmul(r_alvo)?;
+    resolver_simetrica(&m, &rhs)
+}
+
+/// Resolve `M x = B` para M simétrica (n, n) por eliminação de Gauss com
+/// pivoteamento parcial (Cholesky não assumido — M pode ser só PSD+εI).
+pub fn resolver_simetrica(m: &Tensor, b: &Tensor) -> Result<Tensor> {
+    let n = m.dim(0)?;
+    let d = b.dim(1)?;
+    let dev = m.device();
+    let mut a = m.to_vec2::<f32>()?;
+    let mut rhs = b.to_vec2::<f32>()?;
+    for col in 0..n {
+        // pivoteamento parcial
+        let (mut pivo, mut linha_p) = (a[col][col].abs(), col);
+        for r in col + 1..n {
+            if a[r][col].abs() > pivo {
+                pivo = a[r][col].abs();
+                linha_p = r;
+            }
+        }
+        if pivo < 1e-12 {
+            candle_core::bail!("matriz singular (pivo ~ 0 na coluna {col})");
+        }
+        a.swap(col, linha_p);
+        rhs.swap(col, linha_p);
+        for r in col + 1..n {
+            let f = a[r][col] / a[col][col];
+            for c in col..n {
+                a[r][c] -= f * a[col][c];
+            }
+            for c in 0..d {
+                rhs[r][c] -= f * rhs[col][c];
+            }
+        }
+    }
+    let mut x = vec![vec![0f32; d]; n];
+    for r in (0..n).rev() {
+        for c in 0..d {
+            let mut s = rhs[r][c];
+            for k in r + 1..n {
+                s -= a[r][k] * x[k][c];
+            }
+            x[r][c] = s / a[r][r];
+        }
+    }
+    let flat: Vec<f32> = x.into_iter().flatten().collect();
+    Ok(Tensor::from_vec(flat, (n, d), &dev)?)
+}

src/pensamento/mod.rs

@@ -0,0 +1,71 @@
+//! Tecnologia Pensamento — módulos: motor, combinador ridge,
+//! quebra-cabeça pós-treino (divisão SRP v0.10.0 — r-35 §2).
+
+//! Tecnologia **Pensamento** v0.5.0 — N-redes neurais flexíveis paralelizadas
+//! integradas ao NCM, conectadas ao Mecanismo de Atenção, com raciocínio
+//! temporal-estratégico (item d = a + b + c).
+//!
+//! **O que é (motivação do usuário):** Pensamento é semelhante ao
+//! pós-treinamento — N-redes paralelas de tentativas cooperativas para
+//! resolver o problema do item c (requisição do usuário) quando a
+//! informação tem POUCA CONFIANÇA para gerar novo conhecimento (fora dos
+//! padrões comuns), a partir de:
+//! - **a)** conhecimento aprendido durante o treinamento;
+//! - **b)** estado de inferência corrente;
+//! - **c)** a requisição (prompt) do usuário;
+//! e da ativação de **difusores** (exploração estocástica) e
+//! **combinadores/montadores** (re-encaixe de peças por projeção algébrica).
+//!
+//! **Ciclo d (raciocínio temporal-estratégico):**
+//! `planejamento → construção de etapas e distribuição/desmembramento de
+//! competências → volta ao planejamento OU envio da resposta ao usuário`.
+//!
+//! **Provas (completas em `docs/memorias/r-21-provas-pensamento-v050.md`):**
+//! - **T-P1 (gatilho mensurável e causal):** o gatilho
+//!   `1{conf(p) < τ_c}` com `conf = 1 − H(p)/log K` é função apenas da
+//!   distribuição preditiva CORRENTE — não transporta informação do futuro,
+//!   preservando a causalidade (mesma estrutura do gate G1 do NCM).
+//! - **T-P2 (tentativas paralelas — auto-consistência):** com N tentativas
+//!   independentes, cada uma correta com prob. `p > 1/2`, a votação por
+//!   maioria tem `P(erro) ≤ exp(−2N(p−1/2)²)` (Hoeffding); com seleção
+//!   best-of-N por verificador exato, `P(sucesso) ≥ 1−(1−p)^N`.
+//! - **T-P3 (combinador ótimo):** o montador por mínimos quadrados com
+//!   regularização ridge resolve `r* = (WᵀW+εI)^{−1}Wᵀr_alvo` — o resíduo é
+//!   o MÍNIMO possível na norma (pseudo-inversa, Teo V-1' do outro agente).
+//! - **T-P4 (terminação e soundness do planejador):** o potencial
+//!   `Φ(k) = B − k` decresce estritamente a cada iteração do ciclo d ⇒ o
+//!   loop termina em ≤ B iterações (indução bem-fundada); a resposta só é
+//!   emitida com confiança ≥ τ_c OU com orçamento esgotado (declaração
+//!   honesta de queda de confiança na telemetria).
+//! - **T-P5 (neutralidade no nascimento na atenção):** com o gate de
+//!   atenção das tentativas inicializado em ZERO, a saída da atenção é
+//!   bit-a-bit a da atenção base; a perturbação é limitada por
+//!   `‖Δy‖ ≤ L·|g|·‖W_k z‖` (Lipschitz com constante L do softmax).
+//! - **T-P6 (composição d = a + b + c):** o condicionamento de cada
+//!   tentativa é `cond = [a; b; c]` — a estrutura de independência
+//!   condicional `p(resposta | a, b, c)` fatoriza pelo estado conjunto; as
+//!   tentativas só veem o PASSADO (causalidade preservada).
+
+use candle_core::{Device, Result, Tensor, Var};
+use crate::camadas::Linear;
+use crate::jepa::MlpJepa;
+use crate::rng::RngDeterministico;
+use std::collections::HashMap;
+
+// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
+#[cfg(test)]
+mod testes;
+mod combinador;
+mod motor;
+mod quebra_cabeca;
+
+pub use combinador::*;
+pub use motor::*;
+pub use quebra_cabeca::*;
+
+// ---- itens mantidos no próprio mod.rs ----
+
+
+pub fn versao() -> &'static str {
+    "pensamento-0.7.0"
+}

src/{pensamento.rs → pensamento/motor.rs}

@@ -1,53 +1,8 @@
-//! Tecnologia **Pensamento** v0.5.0 — N-redes neurais flexíveis paralelizadas
-//! integradas ao NCM, conectadas ao Mecanismo de Atenção, com raciocínio
-//! temporal-estratégico (item d = a + b + c).
-//!
-//! **O que é (motivação do usuário):** Pensamento é semelhante ao
-//! pós-treinamento — N-redes paralelas de tentativas cooperativas para
-//! resolver o problema do item c (requisição do usuário) quando a
-//! informação tem POUCA CONFIANÇA para gerar novo conhecimento (fora dos
-//! padrões comuns), a partir de:
-//! - **a)** conhecimento aprendido durante o treinamento;
-//! - **b)** estado de inferência corrente;
-//! - **c)** a requisição (prompt) do usuário;
-//! e da ativação de **difusores** (exploração estocástica) e
-//! **combinadores/montadores** (re-encaixe de peças por projeção algébrica).
-//!
-//! **Ciclo d (raciocínio temporal-estratégico):**
-//! `planejamento → construção de etapas e distribuição/desmembramento de
-//! competências → volta ao planejamento OU envio da resposta ao usuário`.
-//!
-//! **Provas (completas em `docs/memorias/r-21-provas-pensamento-v050.md`):**
-//! - **T-P1 (gatilho mensurável e causal):** o gatilho
-//!   `1{conf(p) < τ_c}` com `conf = 1 − H(p)/log K` é função apenas da
-//!   distribuição preditiva CORRENTE — não transporta informação do futuro,
-//!   preservando a causalidade (mesma estrutura do gate G1 do NCM).
-//! - **T-P2 (tentativas paralelas — auto-consistência):** com N tentativas
-//!   independentes, cada uma correta com prob. `p > 1/2`, a votação por
-//!   maioria tem `P(erro) ≤ exp(−2N(p−1/2)²)` (Hoeffding); com seleção
-//!   best-of-N por verificador exato, `P(sucesso) ≥ 1−(1−p)^N`.
-//! - **T-P3 (combinador ótimo):** o montador por mínimos quadrados com
-//!   regularização ridge resolve `r* = (WᵀW+εI)^{−1}Wᵀr_alvo` — o resíduo é
-//!   o MÍNIMO possível na norma (pseudo-inversa, Teo V-1' do outro agente).
-//! - **T-P4 (terminação e soundness do planejador):** o potencial
-//!   `Φ(k) = B − k` decresce estritamente a cada iteração do ciclo d ⇒ o
-//!   loop termina em ≤ B iterações (indução bem-fundada); a resposta só é
-//!   emitida com confiança ≥ τ_c OU com orçamento esgotado (declaração
-//!   honesta de queda de confiança na telemetria).
-//! - **T-P5 (neutralidade no nascimento na atenção):** com o gate de
-//!   atenção das tentativas inicializado em ZERO, a saída da atenção é
-//!   bit-a-bit a da atenção base; a perturbação é limitada por
-//!   `‖Δy‖ ≤ L·|g|·‖W_k z‖` (Lipschitz com constante L do softmax).
-//! - **T-P6 (composição d = a + b + c):** o condicionamento de cada
-//!   tentativa é `cond = [a; b; c]` — a estrutura de independência
-//!   condicional `p(resposta | a, b, c)` fatoriza pelo estado conjunto; as
-//!   tentativas só veem o PASSADO (causalidade preservada).
+//! `pensamento::motor` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
 
-use candle_core::{Device, Result, Tensor, Var};
-use crate::camadas::Linear;
-use crate::jepa::MlpJepa;
-use crate::rng::RngDeterministico;
-use std::collections::HashMap;
 
 // ---------------------------------------------------------------------------
 // Confiança e gatilho (T-P1)
@@ -592,601 +547,3 @@ impl MotorPensamento {
         }
     }
 }
-
-// ---------------------------------------------------------------------------
-// Combinador algébrico (T-P3 — projeção ridge, Teo V-1' portado)
-// ---------------------------------------------------------------------------
-
-/// Projeção ridge: `r* = (WᵀW + εI)^{−1} Wᵀ r_alvo` — minimizador de
-/// `‖W r − r_alvo‖² + ε‖r‖²` (o montador algébrico do "re-encaixe de peças").
-///
-/// **Prova (T-P3):** a função é quadrática estritamente convexa (ε > 0);
-/// o gradiente anula-se exatamente em `r*` acima; o resíduo mínimo é
-/// `‖(I − W(WᵀW+εI)^{−1}Wᵀ) r_alvo‖` — análogo direto do Teo V-1'.
-pub fn projetar_ridge(w: &Tensor, r_alvo: &Tensor, eps: f64) -> Result<Tensor> {
-    // w: (m, n), r_alvo: (m, d) ⇒ r*: (n, d)
-    let n = w.dim(1)?;
-    let dev = w.device();
-    let wt = w.transpose(0, 1)?;
-    let wtw = wt.matmul(w)?;
-    let ident = Tensor::eye(n, candle_core::DType::F32, &dev)?.affine(eps, 0.0)?;
-    let m = (&wtw + &ident)?;
-    let rhs = wt.matmul(r_alvo)?;
-    resolver_simetrica(&m, &rhs)
-}
-
-/// Resolve `M x = B` para M simétrica (n, n) por eliminação de Gauss com
-/// pivoteamento parcial (Cholesky não assumido — M pode ser só PSD+εI).
-pub fn resolver_simetrica(m: &Tensor, b: &Tensor) -> Result<Tensor> {
-    let n = m.dim(0)?;
-    let d = b.dim(1)?;
-    let dev = m.device();
-    let mut a = m.to_vec2::<f32>()?;
-    let mut rhs = b.to_vec2::<f32>()?;
-    for col in 0..n {
-        // pivoteamento parcial
-        let (mut pivo, mut linha_p) = (a[col][col].abs(), col);
-        for r in col + 1..n {
-            if a[r][col].abs() > pivo {
-                pivo = a[r][col].abs();
-                linha_p = r;
-            }
-        }
-        if pivo < 1e-12 {
-            candle_core::bail!("matriz singular (pivo ~ 0 na coluna {col})");
-        }
-        a.swap(col, linha_p);
-        rhs.swap(col, linha_p);
-        for r in col + 1..n {
-            let f = a[r][col] / a[col][col];
-            for c in col..n {
-                a[r][c] -= f * a[col][c];
-            }
-            for c in 0..d {
-                rhs[r][c] -= f * rhs[col][c];
-            }
-        }
-    }
-    let mut x = vec![vec![0f32; d]; n];
-    for r in (0..n).rev() {
-        for c in 0..d {
-            let mut s = rhs[r][c];
-            for k in r + 1..n {
-                s -= a[r][k] * x[k][c];
-            }
-            x[r][c] = s / a[r][r];
-        }
-    }
-    let flat: Vec<f32> = x.into_iter().flatten().collect();
-    Ok(Tensor::from_vec(flat, (n, d), &dev)?)
-}
-
-pub fn versao() -> &'static str {
-    "pensamento-0.7.0"
-}
-
-// ---------------------------------------------------------------------------
-// QUEBRA-CABEÇA pós-treinamento (v0.7.0 — inovação com o conhecimento
-// treinado; requisito do usuário; provas Q-1..Q-6 em r-31)
-// ---------------------------------------------------------------------------
-
-/// Configuração do quebra-cabeça (r-28 §4.3).
-#[derive(Clone, Copy, Debug)]
-pub struct ConfigQuebraCabeca {
-    /// K peças em que o conhecimento é quebrado.
-    pub n_pecas: usize,
-    /// orçamento B de rodadas (terminação Q-4).
-    pub n_rodadas_max: usize,
-    /// limiar de validade (mesmo τ_c calibrado do verificador — Q-2).
-    pub tau_c: f64,
-    /// teto do ajuste por componente na árvore (regulação).
-    pub delta_max: f64,
-    /// remonta as peças com mistura ORTOGONAL por peça (rotação/ortogonalidade).
-    pub rotacao_ortogonal: bool,
-    /// para a execução após este nº de rodadas consecutivas sem aceite.
-    pub paciencia: usize,
-}
-
-impl Default for ConfigQuebraCabeca {
-    fn default() -> Self {
-        ConfigQuebraCabeca {
-            n_pecas: 4,
-            n_rodadas_max: 12,
-            tau_c: 0.55,
-            delta_max: 0.05,
-            rotacao_ortogonal: true,
-            paciencia: 5,
-        }
-    }
-}
-
-impl ConfigQuebraCabeca {
-    pub fn novo(n_pecas: usize, n_rodadas: usize, tau_c: f64) -> Self {
-        ConfigQuebraCabeca {
-            n_pecas,
-            n_rodadas_max: n_rodadas,
-            tau_c,
-            delta_max: 0.05,
-            rotacao_ortogonal: true,
-            paciencia: (n_rodadas / 2).max(2),
-        }
-    }
-}
-
-/// Uma rodada do quebra-cabeça.
-#[derive(Debug, Clone)]
-pub struct RodadaQuebraCabeca {
-    pub rodada: usize,
-    /// permutação das peças aplicada na remontagem (reordenação).
-    pub permutacao_pecas: Vec<usize>,
-    /// confiança NCM do candidato remontado (reavaliação).
-    pub confianca: f64,
-    /// conf ≥ τ_c ⇒ VÁLIDO (ajusta a árvore); senão PUNIDO (descarta).
-    pub aceito: bool,
-    /// delta aplicado na árvore (0 quando descartado).
-    pub delta_aplicado: f64,
-    /// rotações ortogonais usadas (quando ativas) — por peça.
-    pub usou_rotacao: bool,
-}
-
-/// Resultado consolidado do quebra-cabeça.
-#[derive(Debug, Clone)]
-pub struct ResultadoQuebraCabeca {
-    pub rodadas: Vec<RodadaQuebraCabeca>,
-    pub aceitos: usize,
-    pub rejeitados: usize,
-    pub confianca_base: f64,
-    pub confianca_melhor: f64,
-    pub telemetria: HashMap<String, f64>,
-}
-
-/// **Quebra-cabeça de inovação pós-treinamento** (r-28 §4.3):
-/// 1. quebra o conhecimento treinado `conceitos` (m, d) em K peças por
-///    permutação aleatória das linhas (Fisher–Yates com RNG determinístico);
-/// 2. remonta as peças em nova ordem (e com mistura ortogonal por peça
-///    quando `rotacao_ortogonal`) — "descobrir novas possibilidades";
-/// 3. reavalia cada remontagem pelo verificador NCM (calibrado — V-2);
-///    VÁLIDO (conf ≥ τ_c) ⇒ ajuste regulado na árvore de pesos indexada
-///    (nó "pensamento", crédito fundo-topo); PUNIDO ⇒ descarta e o incremento
-///    de punição sobe no nó (alimenta o gate do FNH — integração v0.7.0);
-/// 4. repete até o orçamento B ou a paciência esgotar (Q-4).
-///
-/// **Provas (r-31):** Q-1 cobertura (permutações uniformes ⇒ S_K no suporte;
-/// rotações varrem O(d)); Q-2 soundness herdada (mesmo limiar calibrado do
-/// verificador — P(aceite inválido) ≤ 1−τ_c+ECE); Q-3 potencial monotônico
-/// (Φ_r = Σ conf dos aceitos é não-decrescente; rejeições não tocam Φ);
-/// Q-4 terminação (B finito, rodadas O(m·d)); Q-5 invariantes da árvore
-/// preservadas (ajustes só tocam métricas, nunca a estrutura — T-A1 intacto;
-/// agregação pós-ajuste mantém T-A2); Q-6 causalidade (permutação e confiança
-/// medidas antes do ajuste — filtração F_r).
-pub fn quebra_cabeca_inovar(
-    conceitos: &Tensor,
-    verificador: &crate::verificador::VerificadorNcm,
-    logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
-    arvore: &mut crate::arvore_pesos::ArvorePesos,
-    cfg: &ConfigQuebraCabeca,
-    rng: &mut RngDeterministico,
-) -> Result<ResultadoQuebraCabeca> {
-    let dev = conceitos.device().clone();
-    let (m, d) = (conceitos.dims()[0], conceitos.dims()[1]);
-    let k = cfg.n_pecas.clamp(1, m);
-    let no_pens = arvore.no("pensamento").unwrap_or(0);
-
-    // linha de base: confiança do conhecimento original (agregado médio)
-    let base_agg = conceitos.mean(0)?;
-    let conf_base = {
-        let lg = logits_fn(&base_agg)?;
-        verificador.confianca_1d(&lg)?
-    };
-
-    let mut rodadas = Vec::new();
-    let mut aceitos = 0usize;
-    let mut rejeitados = 0usize;
-    let mut conf_melhor = conf_base;
-    let mut sem_aceite = 0usize;
-
-    for r in 1..=cfg.n_rodadas_max {
-        if sem_aceite >= cfg.paciencia {
-            break;
-        }
-        // (1) QUEBRA: permutação de linhas Fisher–Yates (Q-6: amostrada ANTES)
-        let mut perm: Vec<usize> = (0..m).collect();
-        for i in (1..m).rev() {
-            let j = rng.inteiro(i + 1);
-            perm.swap(i, j);
-        }
-        // fatia em K peças contíguas (tamanhos quase iguais)
-        let tamanho = (m + k - 1) / k;
-        let mut pecas = Vec::with_capacity(k);
-        let mut ini = 0usize;
-        while ini < m {
-            let fim = (ini + tamanho).min(m);
-            let idx: Vec<u32> = perm[ini..fim].iter().map(|&x| x as u32).collect();
-            let pedaco = conceitos.index_select(&Tensor::from_vec(idx, (fim - ini,), &dev)?, 0)?;
-            pecas.push(pedaco);
-            ini = fim;
-        }
-        // (2) REMONTA: nova ordem aleatória das peças (permutação de peças)
-        let mut perm_pecas: Vec<usize> = (0..pecas.len()).collect();
-        for i in (1..pecas.len()).rev() {
-            let j = rng.inteiro(i + 1);
-            perm_pecas.swap(i, j);
-        }
-        let mut remontada = Vec::with_capacity(pecas.len());
-        for &pi in &perm_pecas {
-            let mut pedaco = pecas[pi].clone();
-            if cfg.rotacao_ortogonal && d >= 2 {
-                // mistura ortogonal da peça: Q ∈ O(d) via polar de gaussiana
-                // do RNG determinístico (preserva normas — ‖xQ‖_F = ‖x‖_F)
-                let q = q_ortogonal_deterministica(d, rng, &dev)?;
-                pedaco = pedaco.matmul(&q)?;
-            }
-            remontada.push(pedaco);
-        }
-        let candidata = Tensor::cat(&remontada, 0)?; // (m, d) remontado
-        // (3) REAVALIAÇÃO pelo verificador NCM (Q-2: mesmo limiar calibrado)
-        let agg = candidata.mean(0)?;
-        let lg = logits_fn(&agg)?;
-        let conf = verificador.confianca_1d(&lg)?;
-        let aceito = conf >= cfg.tau_c;
-        let delta = if aceito {
-            // VÁLIDO: ajusta a árvore bidirecional (indexada, com teto)
-            let escalado = (conf - cfg.tau_c).min(cfg.delta_max);
-            arvore.aplicar_ajuste_indexado(no_pens, "confianca", escalado, cfg.delta_max)
-        } else {
-            // PUNIDO: descarta; a punição sobe no nó (sinal para o gate FNH)
-            rejeitados += 1;
-            sem_aceite += 1;
-            arvore.aplicar_ajuste_indexado(no_pens, "punicao", cfg.delta_max * 0.5, cfg.delta_max);
-            0.0
-        };
-        if aceito {
-            aceitos += 1;
-            sem_aceite = 0;
-            conf_melhor = conf_melhor.max(conf);
-        }
-        rodadas.push(RodadaQuebraCabeca {
-            rodada: r,
-            permutacao_pecas: perm_pecas,
-            confianca: conf,
-            aceito,
-            delta_aplicado: delta,
-            usou_rotacao: cfg.rotacao_ortogonal,
-        });
-    }
-    // crédito fundo-topo após todas as rodadas (T-A2)
-    arvore.agregar_fundo_topo("confianca");
-    arvore.agregar_fundo_topo("punicao");
-
-    let n_rod = rodadas.len();
-    let mut telemetria = HashMap::new();
-    telemetria.insert("rodadas".into(), n_rod as f64);
-    telemetria.insert("aceitos".into(), aceitos as f64);
-    telemetria.insert("rejeitados".into(), rejeitados as f64);
-    telemetria.insert("confianca_base".into(), conf_base);
-    telemetria.insert("confianca_melhor".into(), conf_melhor);
-    telemetria.insert(
-        "taxa_aceitacao".into(),
-        if n_rod > 0 { aceitos as f64 / n_rod as f64 } else { 0.0 },
-    );
-    telemetria.insert("rotacao_ativa".into(), if cfg.rotacao_ortogonal { 1.0 } else { 0.0 });
-    Ok(ResultadoQuebraCabeca {
-        rodadas,
-        aceitos,
-        rejeitados,
-        confianca_base: conf_base,
-        confianca_melhor: conf_melhor,
-        telemetria,
-    })
-}
-
-/// Q ∈ O(d) determinística: gaussiana do RNG próprio → retração polar.
-/// Ortogonal EXATA (δ_ort ≤ 1e-6) e reprodutível (mesma semente ⇒ mesmo Q).
-pub fn q_ortogonal_deterministica(
-    d: usize,
-    rng: &mut RngDeterministico,
-    dev: &Device,
-) -> Result<Tensor> {
-    let n = d * d;
-    let v: Vec<f32> = (0..n).map(|_| rng.normal_padrao() as f32).collect();
-    let g = Tensor::from_vec(v, (d, d), dev)?;
-    crate::stiefel::retrair_polar_frobenius(&g, 90)
-}
-
-
-#[cfg(test)]
-mod testes {
-    use super::*;
-
-    #[test]
-    fn teste_confianca_extremos() {
-        // T-P1: Dirac ⇒ conf = 1; uniforme ⇒ conf = 0
-        let dev = Device::Cpu;
-        let dirac = Tensor::from_vec(vec![100.0f32, 0.0, 0.0, 0.0], (1, 4), &dev).unwrap();
-        let uniforme = Tensor::from_vec(vec![0.0f32; 4], (1, 4), &dev).unwrap();
-        let c1 = confianca_de_logits(&dirac).unwrap();
-        let c0 = confianca_de_logits(&uniforme).unwrap();
-        assert!(c1 > 0.999, "conf dirac = {c1}");
-        assert!(c0 < 0.001, "conf uniforme = {c0}");
-    }
-
-    #[test]
-    fn teste_tp3_projetar_ridge_minimiza() {
-        // T-P3: r* da projeção ridge tem resíduo ≤ qualquer perturbação
-        let dev = Device::Cpu;
-        let w = Tensor::randn(0f32, 1.0, (8, 3), &dev).unwrap();
-        let r_alvo = Tensor::randn(0f32, 1.0, (8, 5), &dev).unwrap();
-        let r = projetar_ridge(&w, &r_alvo, 1e-6).unwrap();
-        let residuo = |rr: &Tensor| {
-            let d = (w.matmul(rr).unwrap() - &r_alvo).unwrap();
-            d.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64
-        };
-        let f0 = residuo(&r);
-        let mut rng = RngDeterministico::novo(1);
-        for _ in 0..30 {
-            let pert: Vec<f32> = (0..15).map(|_| rng.normal(0.0, 0.1) as f32).collect();
-            let rp = (Tensor::from_vec(pert, (3, 5), &dev).unwrap() + &r).unwrap();
-            let fp = residuo(&rp);
-            assert!(f0 <= fp + 1e-6, "residuo r* = {f0} > perturbado {fp}");
-        }
-    }
-
-    #[test]
-    fn teste_tp4_terminacao_e_orcamento() {
-        // o ciclo d SEMPRE termina em ≤ orçamento iterações (potencial
-        // Φ = B − k); com verificador impossível, termina com
-        // orcamento_esgotado = 1.
-        let dev = Device::Cpu;
-        let mut motor = MotorPensamento::novo(6, 4, 3, 0.99, 5, &dev).unwrap();
-        let cond = Tensor::randn(0f32, 1.0, (6,), &dev).unwrap();
-        let mut rng = RngDeterministico::novo(2);
-        let res = motor
-            .raciocinar(&cond, &|_| 0.0, &mut rng) // verificador sempre 0
-            .unwrap();
-        assert!(res.iteracoes <= 5, "iterações = {} > orçamento", res.iteracoes);
-        assert_eq!(res.telemetria.get("orcamento_esgotado"), Some(&1.0));
-        assert!(res.resposta.is_some(), "melhor candidato ainda é retornado");
-    }
-
-    #[test]
-    fn teste_tp5_neutralidade_no_nascimento() {
-        // gate = 0 ⇒ saída da atenção integrada é BIT-A-BIT a da base
-        let dev = Device::Cpu;
-        let motor = MotorPensamento::novo(8, 8, 3, 0.5, 3, &dev).unwrap();
-        let q = Tensor::randn(0f32, 1.0, (1, 4, 8), &dev).unwrap();
-        let k = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
-        let v = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
-        let cand = Tensor::randn(0f32, 1.0, (3, 8), &dev).unwrap();
-        let y_int = motor.atencao_integrada(&q, &k, &v, &cand).unwrap();
-        // atenção base pura
-        let scores = (q.matmul(&k.transpose(1, 2).unwrap()).unwrap() / (8f64).sqrt()).unwrap();
-        let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1).unwrap();
-        let y_base = attn.matmul(&v).unwrap();
-        let dif = (&y_int - &y_base).unwrap().abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
-        assert!(dif == 0.0, "gate=0 deveria dar bit-a-bit, dif = {dif}");
-    }
-
-    #[test]
-    fn teste_treino_cooperativo_e_agregacao() {
-        // item a: as tentativas + combinador APRENDEM a função alvo; a
-        // agregação converge para o alvo melhor que uma tentativa isolada
-        // no pior caso (verificação numérica honesta em escala pequena).
-        let dev = Device::Cpu;
-        let mut motor = MotorPensamento::novo(6, 4, 3, 0.5, 3, &dev).unwrap();
-        let vars = motor.vars();
-        let mut otim = crate::treino::AdamWManual::novo(vars, 5e-3, 0.0);
-        let mut rng = RngDeterministico::novo(4);
-        // alvo: função não-linear determinística de cond
-        let dados: Vec<(Vec<f32>, Vec<f32>)> = (0..256)
-            .map(|_| {
-                let c: Vec<f32> = (0..6).map(|_| rng.normal(0.0, 1.0) as f32).collect();
-                let a: Vec<f32> = (0..4)
-                    .map(|j| {
-                        (c[j % 6] * 0.5 + (c[(j + 1) % 6] * c[(j + 2) % 6]) * 0.3 + 0.1) as f32
-                    })
-                    .collect();
-                (c, a)
-            })
-            .collect();
-        let cs: Vec<f32> = dados.iter().flat_map(|(c, _)| c.clone()).collect();
-        let as_: Vec<f32> = dados.iter().flat_map(|(_, a)| a.clone()).collect();
-        let cond = Tensor::from_vec(cs, (256, 6), &dev).unwrap();
-        let alvo = Tensor::from_vec(as_, (256, 4), &dev).unwrap();
-        let mut perda0 = f64::NAN;
-        let mut perda1 = f64::NAN;
-        for passo in 0..200 {
-            let perda = motor.perda_treino(&cond, &alvo).unwrap();
-            if passo == 0 {
-                perda0 = perda.to_scalar::<f32>().unwrap() as f64;
-            }
-            perda1 = perda.to_scalar::<f32>().unwrap() as f64;
-            otim.passo(crate::treino::grads_achatados(&perda, &motor.vars()).unwrap());
-        }
-        assert!(perda1 < perda0 * 0.5, "treino cooperativo: {perda0} → {perda1}");
-        // agregação: verificador = negativo do erro quadrático médio
-        let mut rng2 = RngDeterministico::novo(9);
-        let cand = motor.candidatos(&cond.get(0).unwrap(), 0.0, &mut rng2).unwrap();
-        let (resp, pesos) = motor.agregar(&cand).unwrap();
-        assert_eq!(resp.dims().to_vec(), vec![1, 4]);
-        let soma: f64 = pesos.iter().sum();
-        assert!((soma - 1.0).abs() < 1e-9, "pesos somam {soma}");
-        assert!(pesos.iter().all(|&p| p >= 0.0));
-    }
-
-    #[test]
-    fn teste_tp2_auto_consistencia_numérica() {
-        // T-P2 numérico: N tentativas com viés comum pequeno; a média
-        // agregada tem erro menor que a tentativa mediana (redução de
-        // variância) na maioria das repetições.
-        let dev = Device::Cpu;
-        let mut rng = RngDeterministico::novo(6);
-        let alvo = [1.0f64, 2.0, -1.0, 0.5];
-        let mut venceu = 0;
-        let reps = 200;
-        for _ in 0..reps {
-            let n = 7;
-            let erros: Vec<f64> = (0..n)
-                .map(|_| {
-                    alvo
-                        .iter()
-                        .map(|&a| {
-                            let ruido = rng.normal(0.0, 1.0);
-                            (a + ruido - a).abs()
-                        })
-                        .sum::<f64>()
-                })
-                .collect();
-            let media: Vec<f64> = (0..4)
-                .map(|j| {
-                    (0..n).map(|i| alvo[j] + rng.normal(0.0, 1.0)).sum::<f64>() / n as f64
-                })
-                .collect();
-            let erro_media: f64 = media.iter().zip(alvo.iter()).map(|(m, a)| (m - a).abs()).sum();
-            let mut ordenado = erros.clone();
-            ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap());
-            let mediana = ordenado[n / 2];
-            if erro_media <= mediana {
-                venceu += 1;
-            }
-        }
-        // a média vence a mediana na grande maioria dos casos (E[erro da
-        // média] = σ/√n < σ = E[erro de UMA tentativa])
-        assert!(
-            venceu as f64 / reps as f64 >= 0.6,
-            "auto-consistência venceu só {}/{}",
-            venceu,
-            reps
-        );
-    }
-
-    // ------------------------------------------------------------------
-    // Quebra-cabeça (v0.7.0) — gates Q-1..Q-6 (provas r-31)
-    // ------------------------------------------------------------------
-
-    fn cenario_quebra_cabeca()
-        -> (Tensor, crate::verificador::VerificadorNcm, crate::arvore_pesos::ArvorePesos) {
-        let dev = Device::Cpu;
-        let mut rng = RngDeterministico::novo(777);
-        // "conhecimento treinado": 12 conceitos (d=8) com estrutura
-        let m = 12usize;
-        let d = 8usize;
-        let v: Vec<f32> = (0..m * d).map(|i| rng.normal_padrao() as f32).collect();
-        let conceitos = Tensor::from_vec(v, (m, d), &dev).unwrap();
-        // verificador calibrado com um "verificador" sintético: logits
-        // favoráveis ao agregado médio dos conceitos
-        let mut verif = crate::verificador::VerificadorNcm::novo();
-        let _ = &mut verif;
-        let mut arvore = crate::arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
-        let _ = &mut arvore;
-        (conceitos, verif, arvore)
-    }
-
-    fn logits_fn_exemplo(x: &Tensor) -> Result<Tensor> {
-        // logits determinísticos correlacionados com a norma do agregado —
-        // quanto mais "concentrado" o agregado, maior a confiança
-        let norma = x.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
-        let base = (norma * 2.0).min(8.0);
-        let v: Vec<f32> = vec![base as f32, 0.5, 0.2, 0.1];
-        Ok(Tensor::from_vec(v, (4,), x.device())?)
-    }
-
-    /// Q-2/Q-3: todo ACEITO tem conf ≥ τ_c; rejeições não aplicam delta;
-    /// potencial monotônico (confiança acumulada só cresce nos aceites).
-    #[test]
-    fn quebra_cabeca_soundness_e_potencial() -> Result<()> {
-        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
-        let cfg = ConfigQuebraCabeca::novo(4, 10, 0.55);
-        let mut rng = RngDeterministico::novo(4242);
-        let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
-        for rod in &r.rodadas {
-            if rod.aceito {
-                assert!(
-                    rod.confianca >= cfg.tau_c,
-                    "Q-2: aceito com conf {} < τ_c {}",
-                    rod.confianca,
-                    cfg.tau_c
-                );
-                assert!(rod.delta_aplicado > 0.0, "aceite aplica delta > 0");
-            } else {
-                assert_eq!(rod.delta_aplicado, 0.0, "Q-3: rejeitado não aplica delta");
-            }
-        }
-        // potencial monotônico: Σ conf dos aceitos ≤ Σ max(conf, τ_c) das rodadas
-        let pot: f64 = r.rodadas.iter().filter(|x| x.aceito).map(|x| x.confianca).sum();
-        assert!(pot >= 0.0);
-        // Q-5: invariantes da árvore preservadas
-        arvore.invariantes_ok().expect("Q-5: invariantes T-A1 preservadas");
-        Ok(())
-    }
-
-    /// Q-4: terminação — nunca excede n_rodadas_max nem roda sem parar.
-    #[test]
-    fn quebra_cabeca_termina() -> Result<()> {
-        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
-        let cfg = ConfigQuebraCabeca::novo(3, 6, 0.99); // τ inalcançável
-        let mut rng = RngDeterministico::novo(1);
-        let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
-        assert!(r.rodadas.len() <= 6, "Q-4: orçamento respeitado");
-        assert_eq!(r.aceitos, 0, "τ inalcançável ⇒ nenhum aceite");
-        assert!(r.rejeitados > 0);
-        Ok(())
-    }
-
-    /// Q-4b: rejeições incrementam a PUNIÇÃO no nó pensamento (sinal FNH).
-    #[test]
-    fn quebra_cabeca_punicao_sobe() -> Result<()> {
-        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
-        let no_pens = arvore.no("pensamento").unwrap();
-        let antes = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0);
-        let cfg = ConfigQuebraCabeca::novo(3, 5, 0.999);
-        let mut rng = RngDeterministico::novo(9);
-        let _ = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
-        let depois = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0);
-        assert!(depois > antes, "punição {depois} deve > {antes} após rejeições");
-        Ok(())
-    }
-
-    /// Rotação/ortogonalidade: ‖xQ‖_F = ‖x‖_F (preserva energia) e a
-    /// remontagem com rotação difere da sem rotação (exploração real).
-    #[test]
-    fn quebra_cabeca_rotacao_preserva_norma() -> Result<()> {
-        let dev = Device::Cpu;
-        let mut rng = RngDeterministico::novo(31);
-        let v: Vec<f32> = (0..5 * 6).map(|_| rng.normal_padrao() as f32).collect();
-        let x = Tensor::from_vec(v, (5, 6), &dev)?;
-        let q = q_ortogonal_deterministica(6, &mut rng, &dev)?;
-        let xq = x.matmul(&q)?;
-        let nx = x.sqr()?.sum_all()?.to_scalar::<f32>()?;
-        let nxq = xq.sqr()?.sum_all()?.to_scalar::<f32>()?;
-        assert!(
-            (nx - nxq).abs() / nx < 1e-4,
-            "‖xQ‖_F = {nxq} deve ≈ ‖x‖_F = {nx} (ortogonalidade)"
-        );
-        // Q é ortogonal exato
-        let delta = crate::stiefel::erro_ortogonalidade(&q)?;
-        assert!(delta < 1e-6, "δ_ort(Q) = {delta}");
-        // remontagem COM rotação difere da SEM rotação
-        let d2 = (&xq - &x)?.abs()?.max_all()?.to_scalar::<f32>()?;
-        assert!(d2 > 1e-3, "rotação deve explorar (dif = {d2})");
-        Ok(())
-    }
-
-    /// Determinismo: mesma semente ⇒ mesmas rodadas (reprodutibilidade).
-    #[test]
-    fn quebra_cabeca_deterministico() -> Result<()> {
-        let (c1, v1, mut a1) = cenario_quebra_cabeca();
-        let (_, v2, mut a2) = cenario_quebra_cabeca();
-        let cfg = ConfigQuebraCabeca::novo(4, 8, 0.5);
-        let mut r1 = RngDeterministico::novo(123);
-        let mut r2 = RngDeterministico::novo(123);
-        let q1 = quebra_cabeca_inovar(&c1, &v1, &logits_fn_exemplo, &mut a1, &cfg, &mut r1)?;
-        let q2 = quebra_cabeca_inovar(&c1, &v2, &logits_fn_exemplo, &mut a2, &cfg, &mut r2)?;
-        assert_eq!(q1.rodadas.len(), q2.rodadas.len());
-        for (x, y) in q1.rodadas.iter().zip(q2.rodadas.iter()) {
-            assert_eq!(x.permutacao_pecas, y.permutacao_pecas, "mesma semente ⇒ mesma remontagem");
-            assert!((x.confianca - y.confianca).abs() < 1e-12);
-            assert_eq!(x.aceito, y.aceito);
-        }
-        Ok(())
-    }
-}

src/pensamento/quebra_cabeca.rs

@@ -0,0 +1,233 @@
+//! `pensamento::quebra_cabeca` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+// ---------------------------------------------------------------------------
+// QUEBRA-CABEÇA pós-treinamento (v0.7.0 — inovação com o conhecimento
+// treinado; requisito do usuário; provas Q-1..Q-6 em r-31)
+// ---------------------------------------------------------------------------
+
+/// Configuração do quebra-cabeça (r-28 §4.3).
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigQuebraCabeca {
+    /// K peças em que o conhecimento é quebrado.
+    pub n_pecas: usize,
+    /// orçamento B de rodadas (terminação Q-4).
+    pub n_rodadas_max: usize,
+    /// limiar de validade (mesmo τ_c calibrado do verificador — Q-2).
+    pub tau_c: f64,
+    /// teto do ajuste por componente na árvore (regulação).
+    pub delta_max: f64,
+    /// remonta as peças com mistura ORTOGONAL por peça (rotação/ortogonalidade).
+    pub rotacao_ortogonal: bool,
+    /// para a execução após este nº de rodadas consecutivas sem aceite.
+    pub paciencia: usize,
+}
+
+impl Default for ConfigQuebraCabeca {
+    fn default() -> Self {
+        ConfigQuebraCabeca {
+            n_pecas: 4,
+            n_rodadas_max: 12,
+            tau_c: 0.55,
+            delta_max: 0.05,
+            rotacao_ortogonal: true,
+            paciencia: 5,
+        }
+    }
+}
+
+impl ConfigQuebraCabeca {
+    pub fn novo(n_pecas: usize, n_rodadas: usize, tau_c: f64) -> Self {
+        ConfigQuebraCabeca {
+            n_pecas,
+            n_rodadas_max: n_rodadas,
+            tau_c,
+            delta_max: 0.05,
+            rotacao_ortogonal: true,
+            paciencia: (n_rodadas / 2).max(2),
+        }
+    }
+}
+
+/// Uma rodada do quebra-cabeça.
+#[derive(Debug, Clone)]
+pub struct RodadaQuebraCabeca {
+    pub rodada: usize,
+    /// permutação das peças aplicada na remontagem (reordenação).
+    pub permutacao_pecas: Vec<usize>,
+    /// confiança NCM do candidato remontado (reavaliação).
+    pub confianca: f64,
+    /// conf ≥ τ_c ⇒ VÁLIDO (ajusta a árvore); senão PUNIDO (descarta).
+    pub aceito: bool,
+    /// delta aplicado na árvore (0 quando descartado).
+    pub delta_aplicado: f64,
+    /// rotações ortogonais usadas (quando ativas) — por peça.
+    pub usou_rotacao: bool,
+}
+
+/// Resultado consolidado do quebra-cabeça.
+#[derive(Debug, Clone)]
+pub struct ResultadoQuebraCabeca {
+    pub rodadas: Vec<RodadaQuebraCabeca>,
+    pub aceitos: usize,
+    pub rejeitados: usize,
+    pub confianca_base: f64,
+    pub confianca_melhor: f64,
+    pub telemetria: HashMap<String, f64>,
+}
+
+/// **Quebra-cabeça de inovação pós-treinamento** (r-28 §4.3):
+/// 1. quebra o conhecimento treinado `conceitos` (m, d) em K peças por
+///    permutação aleatória das linhas (Fisher–Yates com RNG determinístico);
+/// 2. remonta as peças em nova ordem (e com mistura ortogonal por peça
+///    quando `rotacao_ortogonal`) — "descobrir novas possibilidades";
+/// 3. reavalia cada remontagem pelo verificador NCM (calibrado — V-2);
+///    VÁLIDO (conf ≥ τ_c) ⇒ ajuste regulado na árvore de pesos indexada
+///    (nó "pensamento", crédito fundo-topo); PUNIDO ⇒ descarta e o incremento
+///    de punição sobe no nó (alimenta o gate do FNH — integração v0.7.0);
+/// 4. repete até o orçamento B ou a paciência esgotar (Q-4).
+///
+/// **Provas (r-31):** Q-1 cobertura (permutações uniformes ⇒ S_K no suporte;
+/// rotações varrem O(d)); Q-2 soundness herdada (mesmo limiar calibrado do
+/// verificador — P(aceite inválido) ≤ 1−τ_c+ECE); Q-3 potencial monotônico
+/// (Φ_r = Σ conf dos aceitos é não-decrescente; rejeições não tocam Φ);
+/// Q-4 terminação (B finito, rodadas O(m·d)); Q-5 invariantes da árvore
+/// preservadas (ajustes só tocam métricas, nunca a estrutura — T-A1 intacto;
+/// agregação pós-ajuste mantém T-A2); Q-6 causalidade (permutação e confiança
+/// medidas antes do ajuste — filtração F_r).
+pub fn quebra_cabeca_inovar(
+    conceitos: &Tensor,
+    verificador: &crate::verificador::VerificadorNcm,
+    logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
+    arvore: &mut crate::arvore_pesos::ArvorePesos,
+    cfg: &ConfigQuebraCabeca,
+    rng: &mut RngDeterministico,
+) -> Result<ResultadoQuebraCabeca> {
+    let dev = conceitos.device().clone();
+    let (m, d) = (conceitos.dims()[0], conceitos.dims()[1]);
+    let k = cfg.n_pecas.clamp(1, m);
+    let no_pens = arvore.no("pensamento").unwrap_or(0);
+
+    // linha de base: confiança do conhecimento original (agregado médio)
+    let base_agg = conceitos.mean(0)?;
+    let conf_base = {
+        let lg = logits_fn(&base_agg)?;
+        verificador.confianca_1d(&lg)?
+    };
+
+    let mut rodadas = Vec::new();
+    let mut aceitos = 0usize;
+    let mut rejeitados = 0usize;
+    let mut conf_melhor = conf_base;
+    let mut sem_aceite = 0usize;
+
+    for r in 1..=cfg.n_rodadas_max {
+        if sem_aceite >= cfg.paciencia {
+            break;
+        }
+        // (1) QUEBRA: permutação de linhas Fisher–Yates (Q-6: amostrada ANTES)
+        let mut perm: Vec<usize> = (0..m).collect();
+        for i in (1..m).rev() {
+            let j = rng.inteiro(i + 1);
+            perm.swap(i, j);
+        }
+        // fatia em K peças contíguas (tamanhos quase iguais)
+        let tamanho = (m + k - 1) / k;
+        let mut pecas = Vec::with_capacity(k);
+        let mut ini = 0usize;
+        while ini < m {
+            let fim = (ini + tamanho).min(m);
+            let idx: Vec<u32> = perm[ini..fim].iter().map(|&x| x as u32).collect();
+            let pedaco = conceitos.index_select(&Tensor::from_vec(idx, (fim - ini,), &dev)?, 0)?;
+            pecas.push(pedaco);
+            ini = fim;
+        }
+        // (2) REMONTA: nova ordem aleatória das peças (permutação de peças)
+        let mut perm_pecas: Vec<usize> = (0..pecas.len()).collect();
+        for i in (1..pecas.len()).rev() {
+            let j = rng.inteiro(i + 1);
+            perm_pecas.swap(i, j);
+        }
+        let mut remontada = Vec::with_capacity(pecas.len());
+        for &pi in &perm_pecas {
+            let mut pedaco = pecas[pi].clone();
+            if cfg.rotacao_ortogonal && d >= 2 {
+                // mistura ortogonal da peça: Q ∈ O(d) via polar de gaussiana
+                // do RNG determinístico (preserva normas — ‖xQ‖_F = ‖x‖_F)
+                let q = q_ortogonal_deterministica(d, rng, &dev)?;
+                pedaco = pedaco.matmul(&q)?;
+            }
+            remontada.push(pedaco);
+        }
+        let candidata = Tensor::cat(&remontada, 0)?; // (m, d) remontado
+        // (3) REAVALIAÇÃO pelo verificador NCM (Q-2: mesmo limiar calibrado)
+        let agg = candidata.mean(0)?;
+        let lg = logits_fn(&agg)?;
+        let conf = verificador.confianca_1d(&lg)?;
+        let aceito = conf >= cfg.tau_c;
+        let delta = if aceito {
+            // VÁLIDO: ajusta a árvore bidirecional (indexada, com teto)
+            let escalado = (conf - cfg.tau_c).min(cfg.delta_max);
+            arvore.aplicar_ajuste_indexado(no_pens, "confianca", escalado, cfg.delta_max)
+        } else {
+            // PUNIDO: descarta; a punição sobe no nó (sinal para o gate FNH)
+            rejeitados += 1;
+            sem_aceite += 1;
+            arvore.aplicar_ajuste_indexado(no_pens, "punicao", cfg.delta_max * 0.5, cfg.delta_max);
+            0.0
+        };
+        if aceito {
+            aceitos += 1;
+            sem_aceite = 0;
+            conf_melhor = conf_melhor.max(conf);
+        }
+        rodadas.push(RodadaQuebraCabeca {
+            rodada: r,
+            permutacao_pecas: perm_pecas,
+            confianca: conf,
+            aceito,
+            delta_aplicado: delta,
+            usou_rotacao: cfg.rotacao_ortogonal,
+        });
+    }
+    // crédito fundo-topo após todas as rodadas (T-A2)
+    arvore.agregar_fundo_topo("confianca");
+    arvore.agregar_fundo_topo("punicao");
+
+    let n_rod = rodadas.len();
+    let mut telemetria = HashMap::new();
+    telemetria.insert("rodadas".into(), n_rod as f64);
+    telemetria.insert("aceitos".into(), aceitos as f64);
+    telemetria.insert("rejeitados".into(), rejeitados as f64);
+    telemetria.insert("confianca_base".into(), conf_base);
+    telemetria.insert("confianca_melhor".into(), conf_melhor);
+    telemetria.insert(
+        "taxa_aceitacao".into(),
+        if n_rod > 0 { aceitos as f64 / n_rod as f64 } else { 0.0 },
+    );
+    telemetria.insert("rotacao_ativa".into(), if cfg.rotacao_ortogonal { 1.0 } else { 0.0 });
+    Ok(ResultadoQuebraCabeca {
+        rodadas,
+        aceitos,
+        rejeitados,
+        confianca_base: conf_base,
+        confianca_melhor: conf_melhor,
+        telemetria,
+    })
+}
+
+/// Q ∈ O(d) determinística: gaussiana do RNG próprio → retração polar.
+/// Ortogonal EXATA (δ_ort ≤ 1e-6) e reprodutível (mesma semente ⇒ mesmo Q).
+pub fn q_ortogonal_deterministica(
+    d: usize,
+    rng: &mut RngDeterministico,
+    dev: &Device,
+) -> Result<Tensor> {
+    let n = d * d;
+    let v: Vec<f32> = (0..n).map(|_| rng.normal_padrao() as f32).collect();
+    let g = Tensor::from_vec(v, (d, d), dev)?;
+    crate::stiefel::retrair_polar_frobenius(&g, 90)
+}

src/pensamento/testes.rs

@@ -0,0 +1,303 @@
+//! `pensamento::testes` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+
+#[cfg(test)]
+mod testes {
+    use super::*;
+
+    #[test]
+    fn teste_confianca_extremos() {
+        // T-P1: Dirac ⇒ conf = 1; uniforme ⇒ conf = 0
+        let dev = Device::Cpu;
+        let dirac = Tensor::from_vec(vec![100.0f32, 0.0, 0.0, 0.0], (1, 4), &dev).unwrap();
+        let uniforme = Tensor::from_vec(vec![0.0f32; 4], (1, 4), &dev).unwrap();
+        let c1 = confianca_de_logits(&dirac).unwrap();
+        let c0 = confianca_de_logits(&uniforme).unwrap();
+        assert!(c1 > 0.999, "conf dirac = {c1}");
+        assert!(c0 < 0.001, "conf uniforme = {c0}");
+    }
+
+    #[test]
+    fn teste_tp3_projetar_ridge_minimiza() {
+        // T-P3: r* da projeção ridge tem resíduo ≤ qualquer perturbação
+        let dev = Device::Cpu;
+        let w = Tensor::randn(0f32, 1.0, (8, 3), &dev).unwrap();
+        let r_alvo = Tensor::randn(0f32, 1.0, (8, 5), &dev).unwrap();
+        let r = projetar_ridge(&w, &r_alvo, 1e-6).unwrap();
+        let residuo = |rr: &Tensor| {
+            let d = (w.matmul(rr).unwrap() - &r_alvo).unwrap();
+            d.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64
+        };
+        let f0 = residuo(&r);
+        let mut rng = RngDeterministico::novo(1);
+        for _ in 0..30 {
+            let pert: Vec<f32> = (0..15).map(|_| rng.normal(0.0, 0.1) as f32).collect();
+            let rp = (Tensor::from_vec(pert, (3, 5), &dev).unwrap() + &r).unwrap();
+            let fp = residuo(&rp);
+            assert!(f0 <= fp + 1e-6, "residuo r* = {f0} > perturbado {fp}");
+        }
+    }
+
+    #[test]
+    fn teste_tp4_terminacao_e_orcamento() {
+        // o ciclo d SEMPRE termina em ≤ orçamento iterações (potencial
+        // Φ = B − k); com verificador impossível, termina com
+        // orcamento_esgotado = 1.
+        let dev = Device::Cpu;
+        let mut motor = MotorPensamento::novo(6, 4, 3, 0.99, 5, &dev).unwrap();
+        let cond = Tensor::randn(0f32, 1.0, (6,), &dev).unwrap();
+        let mut rng = RngDeterministico::novo(2);
+        let res = motor
+            .raciocinar(&cond, &|_| 0.0, &mut rng) // verificador sempre 0
+            .unwrap();
+        assert!(res.iteracoes <= 5, "iterações = {} > orçamento", res.iteracoes);
+        assert_eq!(res.telemetria.get("orcamento_esgotado"), Some(&1.0));
+        assert!(res.resposta.is_some(), "melhor candidato ainda é retornado");
+    }
+
+    #[test]
+    fn teste_tp5_neutralidade_no_nascimento() {
+        // gate = 0 ⇒ saída da atenção integrada é BIT-A-BIT a da base
+        let dev = Device::Cpu;
+        let motor = MotorPensamento::novo(8, 8, 3, 0.5, 3, &dev).unwrap();
+        let q = Tensor::randn(0f32, 1.0, (1, 4, 8), &dev).unwrap();
+        let k = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
+        let v = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
+        let cand = Tensor::randn(0f32, 1.0, (3, 8), &dev).unwrap();
+        let y_int = motor.atencao_integrada(&q, &k, &v, &cand).unwrap();
+        // atenção base pura
+        let scores = (q.matmul(&k.transpose(1, 2).unwrap()).unwrap() / (8f64).sqrt()).unwrap();
+        let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1).unwrap();
+        let y_base = attn.matmul(&v).unwrap();
+        let dif = (&y_int - &y_base).unwrap().abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(dif == 0.0, "gate=0 deveria dar bit-a-bit, dif = {dif}");
+    }
+
+    #[test]
+    fn teste_treino_cooperativo_e_agregacao() {
+        // item a: as tentativas + combinador APRENDEM a função alvo; a
+        // agregação converge para o alvo melhor que uma tentativa isolada
+        // no pior caso (verificação numérica honesta em escala pequena).
+        let dev = Device::Cpu;
+        let mut motor = MotorPensamento::novo(6, 4, 3, 0.5, 3, &dev).unwrap();
+        let vars = motor.vars();
+        let mut otim = crate::treino::AdamWManual::novo(vars, 5e-3, 0.0);
+        let mut rng = RngDeterministico::novo(4);
+        // alvo: função não-linear determinística de cond
+        let dados: Vec<(Vec<f32>, Vec<f32>)> = (0..256)
+            .map(|_| {
+                let c: Vec<f32> = (0..6).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+                let a: Vec<f32> = (0..4)
+                    .map(|j| {
+                        (c[j % 6] * 0.5 + (c[(j + 1) % 6] * c[(j + 2) % 6]) * 0.3 + 0.1) as f32
+                    })
+                    .collect();
+                (c, a)
+            })
+            .collect();
+        let cs: Vec<f32> = dados.iter().flat_map(|(c, _)| c.clone()).collect();
+        let as_: Vec<f32> = dados.iter().flat_map(|(_, a)| a.clone()).collect();
+        let cond = Tensor::from_vec(cs, (256, 6), &dev).unwrap();
+        let alvo = Tensor::from_vec(as_, (256, 4), &dev).unwrap();
+        let mut perda0 = f64::NAN;
+        let mut perda1 = f64::NAN;
+        for passo in 0..200 {
+            let perda = motor.perda_treino(&cond, &alvo).unwrap();
+            if passo == 0 {
+                perda0 = perda.to_scalar::<f32>().unwrap() as f64;
+            }
+            perda1 = perda.to_scalar::<f32>().unwrap() as f64;
+            otim.passo(crate::treino::grads_achatados(&perda, &motor.vars()).unwrap());
+        }
+        assert!(perda1 < perda0 * 0.5, "treino cooperativo: {perda0} → {perda1}");
+        // agregação: verificador = negativo do erro quadrático médio
+        let mut rng2 = RngDeterministico::novo(9);
+        let cand = motor.candidatos(&cond.get(0).unwrap(), 0.0, &mut rng2).unwrap();
+        let (resp, pesos) = motor.agregar(&cand).unwrap();
+        assert_eq!(resp.dims().to_vec(), vec![1, 4]);
+        let soma: f64 = pesos.iter().sum();
+        assert!((soma - 1.0).abs() < 1e-9, "pesos somam {soma}");
+        assert!(pesos.iter().all(|&p| p >= 0.0));
+    }
+
+    #[test]
+    fn teste_tp2_auto_consistencia_numérica() {
+        // T-P2 numérico: N tentativas com viés comum pequeno; a média
+        // agregada tem erro menor que a tentativa mediana (redução de
+        // variância) na maioria das repetições.
+        let dev = Device::Cpu;
+        let mut rng = RngDeterministico::novo(6);
+        let alvo = [1.0f64, 2.0, -1.0, 0.5];
+        let mut venceu = 0;
+        let reps = 200;
+        for _ in 0..reps {
+            let n = 7;
+            let erros: Vec<f64> = (0..n)
+                .map(|_| {
+                    alvo
+                        .iter()
+                        .map(|&a| {
+                            let ruido = rng.normal(0.0, 1.0);
+                            (a + ruido - a).abs()
+                        })
+                        .sum::<f64>()
+                })
+                .collect();
+            let media: Vec<f64> = (0..4)
+                .map(|j| {
+                    (0..n).map(|i| alvo[j] + rng.normal(0.0, 1.0)).sum::<f64>() / n as f64
+                })
+                .collect();
+            let erro_media: f64 = media.iter().zip(alvo.iter()).map(|(m, a)| (m - a).abs()).sum();
+            let mut ordenado = erros.clone();
+            ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap());
+            let mediana = ordenado[n / 2];
+            if erro_media <= mediana {
+                venceu += 1;
+            }
+        }
+        // a média vence a mediana na grande maioria dos casos (E[erro da
+        // média] = σ/√n < σ = E[erro de UMA tentativa])
+        assert!(
+            venceu as f64 / reps as f64 >= 0.6,
+            "auto-consistência venceu só {}/{}",
+            venceu,
+            reps
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // Quebra-cabeça (v0.7.0) — gates Q-1..Q-6 (provas r-31)
+    // ------------------------------------------------------------------
+
+    fn cenario_quebra_cabeca()
+        -> (Tensor, crate::verificador::VerificadorNcm, crate::arvore_pesos::ArvorePesos) {
+        let dev = Device::Cpu;
+        let mut rng = RngDeterministico::novo(777);
+        // "conhecimento treinado": 12 conceitos (d=8) com estrutura
+        let m = 12usize;
+        let d = 8usize;
+        let v: Vec<f32> = (0..m * d).map(|i| rng.normal_padrao() as f32).collect();
+        let conceitos = Tensor::from_vec(v, (m, d), &dev).unwrap();
+        // verificador calibrado com um "verificador" sintético: logits
+        // favoráveis ao agregado médio dos conceitos
+        let mut verif = crate::verificador::VerificadorNcm::novo();
+        let _ = &mut verif;
+        let mut arvore = crate::arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
+        let _ = &mut arvore;
+        (conceitos, verif, arvore)
+    }
+
+    fn logits_fn_exemplo(x: &Tensor) -> Result<Tensor> {
+        // logits determinísticos correlacionados com a norma do agregado —
+        // quanto mais "concentrado" o agregado, maior a confiança
+        let norma = x.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+        let base = (norma * 2.0).min(8.0);
+        let v: Vec<f32> = vec![base as f32, 0.5, 0.2, 0.1];
+        Ok(Tensor::from_vec(v, (4,), x.device())?)
+    }
+
+    /// Q-2/Q-3: todo ACEITO tem conf ≥ τ_c; rejeições não aplicam delta;
+    /// potencial monotônico (confiança acumulada só cresce nos aceites).
+    #[test]
+    fn quebra_cabeca_soundness_e_potencial() -> Result<()> {
+        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
+        let cfg = ConfigQuebraCabeca::novo(4, 10, 0.55);
+        let mut rng = RngDeterministico::novo(4242);
+        let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
+        for rod in &r.rodadas {
+            if rod.aceito {
+                assert!(
+                    rod.confianca >= cfg.tau_c,
+                    "Q-2: aceito com conf {} < τ_c {}",
+                    rod.confianca,
+                    cfg.tau_c
+                );
+                assert!(rod.delta_aplicado > 0.0, "aceite aplica delta > 0");
+            } else {
+                assert_eq!(rod.delta_aplicado, 0.0, "Q-3: rejeitado não aplica delta");
+            }
+        }
+        // potencial monotônico: Σ conf dos aceitos ≤ Σ max(conf, τ_c) das rodadas
+        let pot: f64 = r.rodadas.iter().filter(|x| x.aceito).map(|x| x.confianca).sum();
+        assert!(pot >= 0.0);
+        // Q-5: invariantes da árvore preservadas
+        arvore.invariantes_ok().expect("Q-5: invariantes T-A1 preservadas");
+        Ok(())
+    }
+
+    /// Q-4: terminação — nunca excede n_rodadas_max nem roda sem parar.
+    #[test]
+    fn quebra_cabeca_termina() -> Result<()> {
+        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
+        let cfg = ConfigQuebraCabeca::novo(3, 6, 0.99); // τ inalcançável
+        let mut rng = RngDeterministico::novo(1);
+        let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
+        assert!(r.rodadas.len() <= 6, "Q-4: orçamento respeitado");
+        assert_eq!(r.aceitos, 0, "τ inalcançável ⇒ nenhum aceite");
+        assert!(r.rejeitados > 0);
+        Ok(())
+    }
+
+    /// Q-4b: rejeições incrementam a PUNIÇÃO no nó pensamento (sinal FNH).
+    #[test]
+    fn quebra_cabeca_punicao_sobe() -> Result<()> {
+        let (conceitos, verif, mut arvore) = cenario_quebra_cabeca();
+        let no_pens = arvore.no("pensamento").unwrap();
+        let antes = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0);
+        let cfg = ConfigQuebraCabeca::novo(3, 5, 0.999);
+        let mut rng = RngDeterministico::novo(9);
+        let _ = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?;
+        let depois = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0);
+        assert!(depois > antes, "punição {depois} deve > {antes} após rejeições");
+        Ok(())
+    }
+
+    /// Rotação/ortogonalidade: ‖xQ‖_F = ‖x‖_F (preserva energia) e a
+    /// remontagem com rotação difere da sem rotação (exploração real).
+    #[test]
+    fn quebra_cabeca_rotacao_preserva_norma() -> Result<()> {
+        let dev = Device::Cpu;
+        let mut rng = RngDeterministico::novo(31);
+        let v: Vec<f32> = (0..5 * 6).map(|_| rng.normal_padrao() as f32).collect();
+        let x = Tensor::from_vec(v, (5, 6), &dev)?;
+        let q = q_ortogonal_deterministica(6, &mut rng, &dev)?;
+        let xq = x.matmul(&q)?;
+        let nx = x.sqr()?.sum_all()?.to_scalar::<f32>()?;
+        let nxq = xq.sqr()?.sum_all()?.to_scalar::<f32>()?;
+        assert!(
+            (nx - nxq).abs() / nx < 1e-4,
+            "‖xQ‖_F = {nxq} deve ≈ ‖x‖_F = {nx} (ortogonalidade)"
+        );
+        // Q é ortogonal exato
+        let delta = crate::stiefel::erro_ortogonalidade(&q)?;
+        assert!(delta < 1e-6, "δ_ort(Q) = {delta}");
+        // remontagem COM rotação difere da SEM rotação
+        let d2 = (&xq - &x)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(d2 > 1e-3, "rotação deve explorar (dif = {d2})");
+        Ok(())
+    }
+
+    /// Determinismo: mesma semente ⇒ mesmas rodadas (reprodutibilidade).
+    #[test]
+    fn quebra_cabeca_deterministico() -> Result<()> {
+        let (c1, v1, mut a1) = cenario_quebra_cabeca();
+        let (_, v2, mut a2) = cenario_quebra_cabeca();
+        let cfg = ConfigQuebraCabeca::novo(4, 8, 0.5);
+        let mut r1 = RngDeterministico::novo(123);
+        let mut r2 = RngDeterministico::novo(123);
+        let q1 = quebra_cabeca_inovar(&c1, &v1, &logits_fn_exemplo, &mut a1, &cfg, &mut r1)?;
+        let q2 = quebra_cabeca_inovar(&c1, &v2, &logits_fn_exemplo, &mut a2, &cfg, &mut r2)?;
+        assert_eq!(q1.rodadas.len(), q2.rodadas.len());
+        for (x, y) in q1.rodadas.iter().zip(q2.rodadas.iter()) {
+            assert_eq!(x.permutacao_pecas, y.permutacao_pecas, "mesma semente ⇒ mesma remontagem");
+            assert!((x.confianca - y.confianca).abs() < 1e-12);
+            assert_eq!(x.aceito, y.aceito);
+        }
+        Ok(())
+    }
+}

src/python/calibracao.rs

@@ -0,0 +1,134 @@
+//! `python::calibracao` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// **V-1..V-3:** calibra o verificador NCM em logits retidos e devolve
+/// temperatura, ECE antes/depois, NLL antes/depois e o τ_c por quantil DKW.
+#[pyfunction]
+pub(crate) fn calibrar_verificador(
+    logits: Vec<Vec<f32>>,
+    alvos: Vec<usize>,
+    epsilon: f64,
+) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        let (n, k) = (logits.len(), logits.first().map(|l| l.len()).unwrap_or(1));
+        let flat: Vec<f32> = logits.into_iter().flatten().collect();
+        let lt = candle_core::Tensor::from_vec(flat, (n, k), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let at = candle_core::Tensor::from_vec(
+            alvos.iter().map(|&a| a as u32).collect::<Vec<u32>>(), (n,), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut v = verificador::VerificadorNcm::novo();
+        let (e_antes, e_depois) = v.ajustar(&lt, &at)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let confs: Vec<f64> = verificador::confianca_por_linha(&lt)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
+            .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
+            .to_vec1::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
+            .iter().map(|x| *x as f64).collect();
+        let tau_c = verificador::limiar_por_erro(&confs, epsilon);
+        let d_ = serde_json::json!({
+            "temperatura": v.temperatura, "ece_antes": e_antes, "ece_depois": e_depois,
+            "nll_antes": v.n_ll_antes, "nll_depois": v.n_ll_depois,
+            "tau_c": tau_c, "epsilon": epsilon, "n": n,
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+/// **Demo do verificador NCM substituindo o oráculo** (r-21 §3.1): treina
+/// um classificador pequeno, calibra T* em dados retidos, mede ECE, τ_c
+/// (DKW) e a soundness empírica `P(erro|aceito) ≤ 1−τ_c+ECE`; compara com
+/// o ORÁCULO (que usa o alvo — impossível em produção) no mesmo problema.
+#[pyfunction]
+pub(crate) fn demo_verificador_ncm(n: usize, k: usize, semente: u64) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        crate::rng::definir_semente(semente);
+        let mut rng = crate::rng::RngDeterministico::novo(semente);
+        // dados sintéticos com DRIFT (treino ≠ consulta — força OOD leve)
+        let gerar = |rng: &mut crate::rng::RngDeterministico, m: usize, desloc: f64|
+            -> (candle_core::Tensor, Vec<usize>) {
+            let mut l = Vec::with_capacity(m * k);
+            let mut a = Vec::with_capacity(m);
+            for _ in 0..m {
+                let alvo = rng.inteiro(k);
+                a.push(alvo);
+                for j in 0..k {
+                    let base = if j == alvo { 2.5 } else { 0.0 };
+                    l.push((base + rng.normal(0.0, 1.2) as f32 + desloc as f32) as f32);
+                }
+            }
+            let lt = candle_core::Tensor::from_vec(l, (m, k), &dev).unwrap();
+            (lt, a)
+        };
+        let (lt_tre, alvos_tre) = gerar(&mut rng, n, 0.0);
+        let (lt_val, alvos_val) = gerar(&mut rng, n / 2, 0.3);
+        // mini-classificador: matriz W (k, k) treinada por softmax-CE
+        let w = candle_core::Tensor::randn(0f32, 0.1, (k, k), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let w_var = candle_core::Var::from_tensor(&w)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let at_t = candle_core::Tensor::from_vec(
+            alvos_tre.iter().map(|&a| a as u32).collect::<Vec<u32>>(), (n,), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut otim = treino::AdamWManual::novo(vec![w_var.clone()], 0.05, 0.0);
+        for _ in 0..120 {
+            let logits = lt_tre.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap();
+            let ce = candle_nn::loss::cross_entropy(&logits, &at_t).unwrap();
+            let g = treino::grads_achatados(&ce, &[w_var.clone()]).unwrap();
+            otim.passo(g);
+        }
+        // logits de validação com o modelo treinado
+        let logits_val = lt_val.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap();
+        let at_v = candle_core::Tensor::from_vec(
+            alvos_val.iter().map(|&a| a as u32).collect::<Vec<u32>>(), (n / 2,), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        // calibração (V-1) + soundness (V-2) + quantil (V-3)
+        let mut v = verificador::VerificadorNcm::novo();
+        let (ece_antes, ece_depois) = v.ajustar(&logits_val, &at_v)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let confs: Vec<f64> = v.confianca(&logits_val).unwrap()
+            .flatten_all().unwrap().to_vec1::<f32>().unwrap().iter().map(|x| *x as f64).collect();
+        let corretos: Vec<bool> = logits_val.argmax(candle_core::D::Minus1).unwrap()
+            .eq(&at_v).unwrap().to_dtype(candle_core::DType::U32).unwrap()
+            .flatten_all().unwrap().to_vec1::<u32>().unwrap()
+            .iter().map(|x| *x == 1).collect();
+        let tau_c = verificador::limiar_por_erro(&confs, 0.25);
+        let (mut erro_aceito, mut n_aceito) = (0usize, 0usize);
+        for (c, ok) in confs.iter().zip(corretos.iter()) {
+            if *c >= tau_c {
+                n_aceito += 1;
+                if !ok {
+                    erro_aceito += 1;
+                }
+            }
+        }
+        let p_erro = erro_aceito as f64 / n_aceito.max(1) as f64;
+        let cota = (1.0 - tau_c) + ece_depois + 0.06;
+        // ORÁCULO no mesmo problema (usa o alvo — só para contraste)
+        let acerto_oraculo = corretos.iter().filter(|c| **c).count() as f64 / corretos.len() as f64;
+        let d_ = serde_json::json!({
+            "versao": verificador::versao(), "n": n, "k": k,
+            "temperatura_calibrada": v.temperatura,
+            "ece_antes": ece_antes, "ece_depois": ece_depois,
+            "nll_antes": v.n_ll_antes, "nll_depois": v.n_ll_depois,
+            "tau_c_dkw": tau_c,
+            "p_erro_aceito": p_erro, "cota_soundness": cota,
+            "soundness_ok": p_erro <= cota,
+            "calibracao_melhorou": ece_depois < ece_antes,
+            "acerto_oraculo_referencia": acerto_oraculo,
+            "verificador_sem_oraculo": true,
+            "gates": {
+                "gate_v1_calibracao": ece_depois < ece_antes,
+                "gate_v2_soundness": p_erro <= cota,
+                "gate_v3_tau_positivo": tau_c > 0.0 && tau_c < 1.0,
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}

src/python/demos_qwen.rs

@@ -0,0 +1,359 @@
+//! `python::demos_qwen` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// **v0.8.0 — análise/prova/teste das 4 propostas Qwen3.8** (r-33): mede
+/// custo e exatidão de (1) Newton analítico vs golden-section (verificador),
+/// (2) Cayley vs polar (FNH), (3) árvore pós-ordem iterativa vs recursiva,
+/// (4) MoE vetorizada vs referência (valores + gradiente restaurado — bug
+/// v080-1), e re-executa a ablação JEPA de 3 braços com a correção.
+#[pyfunction]
+#[allow(deprecated)] // mede o bug v080-1 intencionalmente (fwd = oráculo)
+pub(crate) fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
+    use candle_core::{Device, Tensor};
+    use std::time::Instant;
+    let dev = Device::Cpu;
+
+    // ---------- (1) Newton vs golden-section (verificador) ----------
+    let mut rng = crate::rng::RngDeterministico::novo(808);
+    let (n, k) = (1024usize, 32usize);
+    let mut lv = Vec::with_capacity(n * k);
+    let mut av = Vec::with_capacity(n);
+    for _ in 0..n {
+        let alvo = rng.inteiro(k) as u32;
+        av.push(alvo);
+        for j in 0..k {
+            let base = if j as u32 == alvo { 3.0 } else { 0.0 };
+            lv.push(base + rng.normal(0.0, 1.0) as f32);
+        }
+    }
+    let lt = Tensor::from_vec(lv, (n, k), &dev).unwrap();
+    let at = Tensor::from_vec(av, (n,), &dev).unwrap();
+    let t0 = Instant::now();
+    let (t_g, _, nll_g) = verificador::calibrar_temperatura(&lt, &at).unwrap();
+    let tempo_golden = t0.elapsed().as_secs_f64();
+    let t0 = Instant::now();
+    let (t_n, _, nll_n, n_aval) =
+        verificador::calibrar_temperatura_newton(&lt, &at, 40).unwrap();
+    let tempo_newton = t0.elapsed().as_secs_f64();
+
+    // ---------- (2) Cayley vs polar (FNH) ----------
+    let n_rot = 16usize;
+    let r = fnh::RotacaoSkew::nova(n_rot, &dev).unwrap();
+    let th: Vec<f32> = (0..n_rot * (n_rot - 1) / 2)
+        .map(|i| ((i as f32) * 0.11) % 0.5)
+        .collect();
+    r.theta
+        .set(&Tensor::from_vec(th, (n_rot * (n_rot - 1) / 2,), &dev).unwrap())
+        .unwrap();
+    let rep = 25usize;
+    let t0 = Instant::now();
+    let mut delta_polar = 0.0;
+    for _ in 0..rep {
+        delta_polar = crate::stiefel::erro_ortogonalidade(&r.rotacao_polar().unwrap()).unwrap();
+    }
+    let tempo_polar = t0.elapsed().as_secs_f64() / rep as f64;
+    let t0 = Instant::now();
+    let mut delta_cayley = 0.0;
+    for _ in 0..rep {
+        delta_cayley = crate::stiefel::erro_ortogonalidade(&r.rotacao_cayley().unwrap()).unwrap();
+    }
+    let tempo_cayley = t0.elapsed().as_secs_f64() / rep as f64;
+
+    // ---------- (3) árvore iterativa vs recursiva ----------
+    let mut arv = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
+    let mut pai = 1usize;
+    for i in 0..20_000u32 {
+        pai = arv.anexar_filho(pai, &format!("c{i}"), 1);
+    }
+    arv.nos[pai].metricas.insert("m".into(), 1.0);
+    let t0 = Instant::now();
+    let total_it = arv.agregar_fundo_topo("m");
+    let tempo_arv_it = t0.elapsed().as_secs_f64();
+    // repõe TODAS as métricas locais (a agregação sobrescreveu com os
+    // agregados) — só a folha tem valor; o resto volta a 0 — e roda a
+    // recursiva (profundidade 20k ok na thread principal do Python)
+    for no in arv.nos.iter_mut() {
+        no.metricas.insert("m".into(), 0.0);
+    }
+    arv.nos[pai].metricas.insert("m".into(), 1.0);
+    let t0 = Instant::now();
+    let total_rec = arv.agregar_fundo_topo_rec("m");
+    let tempo_arv_rec = t0.elapsed().as_secs_f64();
+
+    // ---------- (4) MoE vetorizada: valores + gradiente + custo ----------
+    let (nm, dm, em) = (256usize, 32usize, 8usize);
+    let xv: Vec<f32> = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+    let x = Tensor::from_vec(xv, (nm, dm), &dev).unwrap();
+    let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap();
+    let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    let s_vet = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    let dif_moe = (&s_ref.saida - &s_vet.saida)
+        .unwrap()
+        .abs()
+        .unwrap()
+        .max_all()
+        .unwrap()
+        .to_scalar::<f32>()
+        .unwrap() as f64;
+    let rep_moe = 10usize;
+    let t0 = Instant::now();
+    for _ in 0..rep_moe {
+        let _ = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    }
+    let tempo_moe_ref = t0.elapsed().as_secs_f64() / rep_moe as f64;
+    let t0 = Instant::now();
+    for _ in 0..rep_moe {
+        let _ = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    }
+    let tempo_moe_vet = t0.elapsed().as_secs_f64() / rep_moe as f64;
+    // normas de gradiente (bug v080-1: fwd = 0; vetorizada > 0)
+    let norma = |vet: bool| -> (f64, f64) {
+        let s = if vet {
+            moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap()
+        } else {
+            moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap()
+        };
+        let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+        let gs = perda.backward().unwrap();
+        let mut nr = 0.0;
+        for v in moe.roteador.vars() {
+            if let Some(g) = gs.get(&v) {
+                nr += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+            }
+        }
+        let mut ne = 0.0;
+        for e in &moe.especialistas {
+            for v in e.vars() {
+                if let Some(g) = gs.get(&v) {
+                    ne += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+                }
+            }
+        }
+        (nr, ne)
+    };
+    let (grad_ref_r, grad_ref_e) = norma(false);
+    let (grad_vet_r, grad_vet_e) = norma(true);
+
+    // ---------- (5) re-ablação JEPA 3 braços (gradiente restaurado) ----------
+    let xv: Vec<f32> = (0..64 * 12).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+    let xj = Tensor::from_vec(xv, (64, 12), &dev).unwrap();
+    let mut ablac = serde_json::Map::new();
+    for modo in ["pequena", "densa", "moe"] {
+        let rj = moe_redirecionavel::treinar_jepa_com_moe(&xj, modo, 120, 0.5, 42).unwrap();
+        ablac.insert(
+            modo.into(),
+            serde_json::json!({
+                "perda_inicial": rj.perda_pred_inicial,
+                "perda_final": rj.perda_pred_final,
+                "queda_pct": 100.0 * (1.0 - rj.perda_pred_final / rj.perda_pred_inicial.max(1e-9)),
+            }),
+        );
+    }
+
+    let d_ = serde_json::json!({
+        "versao": "qwen-v080-1.0",
+        "newton_vs_golden": {
+            "t_golden": t_g, "t_newton": t_n, "dif_t": (t_g - t_n).abs(),
+            "nll_golden": nll_g, "nll_newton": nll_n,
+            "nll_dif": (nll_g - nll_n).abs(),
+            "n_aval_newton": n_aval,
+            "tempo_golden_s": tempo_golden, "tempo_newton_s": tempo_newton,
+            "speedup": tempo_golden / tempo_newton.max(1e-9),
+            "gates": {
+                "mesmo_t": (t_g - t_n).abs() < 1e-3,
+                "nll_nao_piora": nll_n <= nll_g + 1e-4,
+                "menos_avaliacoes": n_aval < 36,
+            },
+        },
+        "cayley_vs_polar": {
+            "delta_ort_polar": delta_polar, "delta_ort_cayley": delta_cayley,
+            "tempo_polar_s": tempo_polar, "tempo_cayley_s": tempo_cayley,
+            "speedup": tempo_polar / tempo_cayley.max(1e-9),
+            "gates": {
+                "ambos_exatos": delta_polar < 1e-6 && delta_cayley < 1e-6,
+                "cayley_mais_rapido": tempo_cayley < tempo_polar,
+            },
+        },
+        "arvore_iter_vs_rec": {
+            "n_nos": arv.n_nos(),
+            "total_iter": total_it, "total_rec": total_rec,
+            "bit_a_bit": total_it.to_bits() == total_rec.to_bits(),
+            "tempo_iter_s": tempo_arv_it, "tempo_rec_s": tempo_arv_rec,
+            "gates": { "iguais_bit_a_bit": total_it == total_rec },
+        },
+        "moe_vetorizada": {
+            "max_dif_valores": dif_moe,
+            "tempo_ref_s": tempo_moe_ref, "tempo_vet_s": tempo_moe_vet,
+            "grad_roteador_ref": grad_ref_r, "grad_especialistas_ref": grad_ref_e,
+            "grad_roteador_vet": grad_vet_r, "grad_especialistas_vet": grad_vet_e,
+            "gates": {
+                "valores_iguais": dif_moe < 1e-4,
+                "bug_v080_1_confirmado": grad_ref_r == 0.0 && grad_ref_e == 0.0,
+                "gradiente_restaurado": grad_vet_r > 0.0 && grad_vet_e > 0.0,
+            },
+        },
+        "ablacao_jepa_3_bracos_v080": ablac,
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}
+
+
+/// **v0.9.0 — veredito executável das críticas Qwen3.8 (r-34):** mede os
+/// aprimoramentos contra as referências v0.8.0 (oráculos preservados):
+/// (1) skew O(n²) via index_add — bit-a-bit + tempo + memória analítica;
+/// (2) calibrar vetorial — bit-a-bit em 3 passos EMA + tempo;
+/// (3) forward canônico (ex-fwd_vetorizado) — regressão de valores e
+///     gradiente;
+/// (4) newtypes de domínio — rejeição de fora-de-domínio.
+#[pyfunction]
+pub(crate) fn demo_criticas_v090(py: Python) -> PyResult<PyObject> {
+    use candle_core::{Device, Tensor};
+    use std::time::Instant;
+    let dev = Device::Cpu;
+    let mut rng = crate::rng::RngDeterministico::novo(909);
+
+    // ---------- (1) skew: index_add O(n²) vs matmul de seleção O(n⁴) ----------
+    let mut skew_rel = serde_json::Map::new();
+    let mut bits_todos = true;
+    for &n in &[16usize, 64, 128] {
+        let r = fnh::RotacaoSkew::nova(n, &dev).unwrap();
+        let m = n * (n - 1) / 2;
+        let th: Vec<f32> = (0..m).map(|_| rng.uniforme_intervalo(-0.9, 0.9) as f32).collect();
+        r.theta.set(&Tensor::from_vec(th, (m,), &dev).unwrap()).unwrap();
+        // bit-a-bit (F-13)
+        let an = r.skew().unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let ar = r.skew_matmul_referencia().unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let bits_iguais = an.iter().zip(ar.iter()).all(|(a, b)| a.to_bits() == b.to_bits());
+        bits_todos &= bits_iguais;
+        // tempo (referência esquentada 1×; média de 5)
+        let _ = r.skew_matmul_referencia().unwrap();
+        let t0 = Instant::now();
+        for _ in 0..5 { let _ = r.skew_matmul_referencia().unwrap(); }
+        let t_ref = t0.elapsed().as_secs_f64() / 5.0;
+        let _ = r.skew().unwrap();
+        let t0 = Instant::now();
+        for _ in 0..5 { let _ = r.skew().unwrap(); }
+        let t_novo = t0.elapsed().as_secs_f64() / 5.0;
+        let bytes_ref = (m * n * n * 4) as f64;
+        let bytes_novo = ((n * n + 3 * m) * 4 + 2 * m * 4) as f64;
+        skew_rel.insert(
+            format!("n_{n}"),
+            serde_json::json!({
+                "tempo_ref_s": t_ref, "tempo_novo_s": t_novo,
+                "speedup": t_ref / t_novo.max(1e-12),
+                "bytes_ref_selecao": bytes_ref, "bytes_novo": bytes_novo,
+                "razao_memoria": bytes_ref / bytes_novo,
+                "bits_iguais": bits_iguais,
+            }),
+        );
+    }
+
+    // ---------- (2) calibrar: tensor vs laços nativos ----------
+    let (d_out, d_in, n_lin) = (512usize, 512usize, 4096usize);
+    let wv: Vec<f32> = (0..d_out * d_in).map(|_| rng.uniforme_intervalo(-2.0, 2.0) as f32).collect();
+    let w = Tensor::from_vec(wv, (d_out, d_in), &dev).unwrap();
+    let xv: Vec<f32> = (0..n_lin * d_in).map(|_| rng.uniforme_intervalo(-3.0, 3.0) as f32).collect();
+    let x = Tensor::from_vec(xv, (n_lin, d_in), &dev).unwrap();
+    let mut s_novo = fnh::SuavizadorQuant::novo(0.5, 0.98);
+    let mut s_tens = fnh::SuavizadorQuant::novo(0.5, 0.98);
+    let mut s_ref = fnh::SuavizadorQuant::novo(0.5, 0.98);
+    let mut bits_cal = true;
+    for _ in 0..3 {
+        s_novo.calibrar(&w, &x).unwrap();
+        s_tens.calibrar_tensor(&w, &x).unwrap();
+        s_ref.calibrar_referencia(&w, &x).unwrap();
+        for (a, b) in s_novo.w_max.as_ref().unwrap().iter().zip(s_ref.w_max.as_ref().unwrap()) {
+            bits_cal &= a.to_bits() == b.to_bits();
+        }
+        for (a, b) in s_novo.x_max.as_ref().unwrap().iter().zip(s_ref.x_max.as_ref().unwrap()) {
+            bits_cal &= a.to_bits() == b.to_bits();
+        }
+    }
+    // tempo (esquentadas 1×; média de 5)
+    let _ = s_ref.calibrar_referencia(&w, &x);
+    let t0 = Instant::now();
+    for _ in 0..5 { s_ref.calibrar_referencia(&w, &x).unwrap(); }
+    let t_cal_ref = t0.elapsed().as_secs_f64() / 5.0;
+    let _ = s_novo.calibrar(&w, &x);
+    let t0 = Instant::now();
+    for _ in 0..5 { s_novo.calibrar(&w, &x).unwrap(); }
+    let t_cal_novo = t0.elapsed().as_secs_f64() / 5.0;
+    let _ = s_tens.calibrar_tensor(&w, &x);
+    let t0 = Instant::now();
+    for _ in 0..5 { s_tens.calibrar_tensor(&w, &x).unwrap(); }
+    let t_cal_tens = t0.elapsed().as_secs_f64() / 5.0;
+
+    // ---------- (3) forward: regressão de valores + gradiente ----------
+    let (nm, dm, em) = (256usize, 32usize, 8usize);
+    let xv2: Vec<f32> = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+    let x2 = Tensor::from_vec(xv2, (nm, dm), &dev).unwrap();
+    #[allow(deprecated)] // oráculo do bug v080-1 (r-33 §5)
+    let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap();
+    #[allow(deprecated)]
+    let s_refm = moe.fwd(&x2, moe_redirecionavel::Papel::Codificador).unwrap();
+    let s_fwd = moe.forward(&x2, moe_redirecionavel::Papel::Codificador).unwrap();
+    let dif_moe = (&s_refm.saida - &s_fwd.saida).unwrap().abs().unwrap()
+        .max_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+    let perda = s_fwd.saida.sqr().unwrap().sum_all().unwrap();
+    let gs = perda.backward().unwrap();
+    let mut gr = 0.0f64;
+    for v in moe.roteador.vars() {
+        if let Some(g) = gs.get(&v) {
+            gr += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+        }
+    }
+    let mut ge = 0.0f64;
+    for e in &moe.especialistas {
+        for v in e.vars() {
+            if let Some(g) = gs.get(&v) {
+                ge += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+            }
+        }
+    }
+
+    // ---------- (4) newtypes de domínio (T-V1) ----------
+    let rejeita = crate::tipos::Probabilidade::novo(7.0).is_err()
+        && crate::tipos::Probabilidade::novo(-0.5).is_err()
+        && crate::tipos::Probabilidade::novo(f64::NAN).is_err()
+        && crate::tipos::GateAtivacao::novo(1.5).is_err();
+    let aceita = crate::tipos::Probabilidade::novo(0.37).unwrap().valor() == 0.37;
+    let gate_tipado = fnh::GatePunicao::default()
+        .valor_tipado(&crate::tipos::Probabilidade::novo(0.9).unwrap())
+        .valor();
+
+    let d_ = serde_json::json!({
+        "versao": "criticas-v090-1.0",
+        "skew_index_add": {
+            "por_n": skew_rel,
+            "gates": {
+                "bits_iguais_todos_n": bits_todos,
+            },
+        },
+        "calibrar_zero_copia": {
+            "bits_iguais_3_passos": bits_cal,
+            "tempo_ref_s": t_cal_ref, "tempo_novo_s": t_cal_novo,
+            "tempo_tensor_s": t_cal_tens,
+            "speedup_zero_copia": t_cal_ref / t_cal_novo.max(1e-12),
+            "razao_tensor_vs_zero_copia": t_cal_tens / t_cal_novo.max(1e-12),
+            "gates": { "bit_a_bit": bits_cal, "nao_regride": t_cal_novo <= t_cal_ref * 1.05 },
+        },
+        "forward_canonico": {
+            "max_dif_valores_vs_oraculo": dif_moe,
+            "grad_roteador": gr, "grad_especialistas": ge,
+            "gates": {
+                "valores_iguais": dif_moe < 1e-4,
+                "gradiente_ativo": gr > 0.0 && ge > 0.0,
+            },
+        },
+        "newtypes_dominio": {
+            "rejeita_fora_do_dominio": rejeita,
+            "aceita_dentro": aceita,
+            "gate_tipado_em_0_9": gate_tipado,
+            "gates": { "fronteira_validada": rejeita && aceita },
+        },
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}

src/python/fnh_arvore.rs

@@ -0,0 +1,344 @@
+//! `python::fnh_arvore` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+use super::nucleo::ConfigPy;
+use super::treino_fases::{carregar_gerador, carregar_tokenizador};
+
+
+
+// ---------------------------------------------------------------------------
+// v0.7.0 — bindings dos módulos novos (FNH, árvore, quebra-cabeça, NLP/NLG)
+// ---------------------------------------------------------------------------
+
+/// Árvore de pesos indexada (arestas duplas) exposta ao Python.
+#[pyclass(name = "ArvorePesos")]
+pub(crate) struct ArvorePesosPy {
+    arvore: arvore_pesos::ArvorePesos,
+}
+
+#[pymethods]
+impl ArvorePesosPy {
+    #[staticmethod]
+    #[pyo3(signature = (contagens=None))]
+    fn nova(contagens: Option<std::collections::HashMap<String, usize>>) -> Self {
+        let c = contagens.unwrap_or_default();
+        ArvorePesosPy { arvore: arvore_pesos::ArvorePesos::nova(&c) }
+    }
+
+    fn invariantes_ok(&self) -> bool {
+        self.arvore.invariantes_ok().is_ok()
+    }
+
+    fn agregar(&mut self, metrica: &str) -> f64 {
+        self.arvore.agregar_fundo_topo(metrica)
+    }
+
+    fn aplicar_ajuste(
+        &mut self,
+        no: &str,
+        metrica: &str,
+        delta: f64,
+        delta_max: f64,
+    ) -> PyResult<f64> {
+        let idx = self
+            .arvore
+            .no(no)
+            .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?;
+        Ok(self.arvore.aplicar_ajuste_indexado(idx, metrica, delta, delta_max))
+    }
+
+    fn definir_metrica(&mut self, no: &str, metrica: &str, valor: f64) -> PyResult<()> {
+        let idx = self
+            .arvore
+            .no(no)
+            .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?;
+        self.arvore.nos[idx].metricas.insert(metrica.to_string(), valor);
+        Ok(())
+    }
+
+    fn metrica(&self, no: &str, metrica: &str) -> PyResult<f64> {
+        let idx = self
+            .arvore
+            .no(no)
+            .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?;
+        Ok(self.arvore.nos[idx].metricas.get(metrica).copied().unwrap_or(0.0))
+    }
+
+    fn regular(&mut self, origem: &str, delta: f64, lambda: f64) -> PyResult<()> {
+        let idx = self
+            .arvore
+            .no(origem)
+            .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{origem}' inexistente")))?;
+        self.arvore.regular_topo_fundo(idx, delta, lambda);
+        Ok(())
+    }
+
+    fn dump(&self) -> PyResult<PyObject> {
+        Python::with_gil(|py| {
+            let nos: Vec<serde_json::Value> = self
+                .arvore
+                .nos
+                .iter()
+                .map(|no| {
+                    serde_json::json!({
+                        "nome": no.nome, "ini": no.ini, "fim": no.fim,
+                        "profundidade": no.profundidade,
+                        "metricas": no.metricas,
+                    })
+                })
+                .collect();
+            let d = serde_json::json!({
+                "n_nos": self.arvore.n_nos(),
+                "n_params": self.arvore.n_params,
+                "invariantes_ok": self.arvore.invariantes_ok().is_ok(),
+                "nos": nos,
+            });
+            Ok(pythonize::pythonize(py, &d)?.into())
+        })
+    }
+}
+
+
+/// Demo/gate da camada FNH sobre o backbone: mede o efeito do gate de
+/// punição nas rotações aprendíveis (ablação: π baixa vs π alta).
+#[pyfunction]
+#[pyo3(signature = (d_in=8, d_out=6, passos=60, seed=42))]
+pub(crate) fn demo_fnh(py: Python, d_in: usize, d_out: usize, passos: usize, seed: u64) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let mut rng = rng::RngDeterministico::novo(seed);
+    let mut camada = fnh::CamadaFNH::nova(d_in, d_out, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fnh: {e}")))?;
+    let x: Vec<f32> = (0..4 * d_in).map(|_| rng.normal_padrao() as f32).collect();
+    let xt = candle_core::Tensor::from_vec(x, (4, d_in), &dev)
+        .map_err(py_err)?;
+    camada
+        .suavizador
+        .calibrar(camada.base.w.as_tensor(), &xt)
+        .map_err(py_err)?;
+    // treino curto com punição ALTA (gate abre) vs BAIXA (gate fechado)
+    let mut resumo = serde_json::Map::new();
+    for (rotulo, punicao) in [("baixa", 0.1f64), ("alta", 0.95)] {
+        let mut cam = fnh::CamadaFNH::nova(d_in, d_out, &dev).map_err(py_err)?;
+        // mesma semente de pesos: copia os valores
+        let _ = &mut cam;
+        let mut hub = telemetria::TelemetryHub::novo(None);
+        let mut perdas = Vec::new();
+        for p in 0..passos {
+            // ruído no x a cada passo (regime não-estacionário leve)
+            let ruido: Vec<f32> = (0..4 * d_in)
+                .map(|_| (rng.normal(0.0, 0.05)) as f32)
+                .collect();
+            let xt2 = (&xt
+                + &candle_core::Tensor::from_vec(ruido, (4, d_in), &dev).map_err(py_err)?)
+            .map_err(py_err)?;
+            let y = cam.forward(&xt2, punicao).map_err(py_err)?;
+            // alvo: saída da camada base (auto-referência: regular para W)
+            let z_ref = cam.linear_sem_bias(&xt2, cam.base.w.as_tensor()).map_err(py_err)?;
+            let perda = (&y).sub(&z_ref).map_err(py_err)?.sqr().map_err(py_err)?.sum_all().map_err(py_err)?;
+            perdas.push(perda.to_scalar::<f32>().map_err(py_err)? as f64);
+            let grads = perda.backward().map_err(py_err)?;
+            // gradiente descendente manual simples nos θ das rotações
+            if let Some(g) = grads.get(&cam.r_wp.theta) {
+                let gv = g.flatten_all().map_err(py_err)?.to_vec1::<f32>().map_err(py_err)?;
+                let th = cam.r_wp.theta.as_tensor().flatten_all().map_err(py_err)?.to_vec1::<f32>().map_err(py_err)?;
+                let novo: Vec<f32> = th.iter().zip(gv.iter()).map(|(t, g_)| t - 0.05 * g_).collect();
+                cam.r_wp
+                    .theta
+                    .set(&candle_core::Tensor::from_vec(novo, th.len(), &dev).map_err(py_err)?)
+                    .map_err(py_err)?;
+            }
+            hub.registrar("fnh_gate", cam.gate_ultimo);
+            hub.registrar("fnh_punicao", punicao);
+            hub.registrar("perda", perdas[p]);
+            let _ = p;
+        }
+        let theta_norma: f64 = cam
+            .r_wp
+            .theta
+            .as_tensor()
+            .flatten_all()
+            .map_err(py_err)?
+            .to_vec1::<f32>()
+            .map_err(py_err)?
+            .iter()
+            .map(|v| (*v as f64).powi(2))
+            .sum::<f64>()
+            .sqrt();
+        let delta_ort = cam.r_wp.erro_ortogonalidade().map_err(py_err)?;
+        resumo.insert(
+            format!("punicao_{rotulo}"),
+            serde_json::json!({
+                "gate_final": cam.gate_ultimo,
+                "theta_norma": theta_norma,
+                "delta_ort": delta_ort,
+                "perda_inicial": perdas[0],
+                "perda_final": perdas[perdas.len() - 1],
+            }),
+        );
+    }
+    let _ = &mut camada;
+    let d = serde_json::json!({
+        "versao": "fnh-0.7.0",
+        "resumo": resumo,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// **Quebra-cabeça sobre o conhecimento TREINADO REAL** (script 63):
+/// carrega o tokenizador (codebook do nível `nivel` — o conhecimento
+/// aprendido dos dados reais) e o gerador (a cabeça real como logits_fn
+/// do verificador); executa o protocolo completo de r-30 Q-AD.
+#[pyfunction]
+#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_pecas=4, n_rodadas=12, tau_c=0.4, nivel=0, seed=777))]
+pub(crate) fn quebra_cabeca_real(
+    cfg: &ConfigPy,
+    caminho_tokenizador: &str,
+    caminho_gerador: &str,
+    n_pecas: usize,
+    n_rodadas: usize,
+    tau_c: f64,
+    nivel: usize,
+    seed: u64,
+) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        crate::rng::definir_semente(seed);
+        let mut rng = rng::RngDeterministico::novo(seed);
+        let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("tok: {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!("ger: {e}")))?;
+        ger.carregar(caminho_gerador)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("ger carregar: {e}")))?;
+        let nivel = nivel.min(tok.quants.len().saturating_sub(1));
+        // conhecimento treinado REAL: codebook Stiefel (K, d_lat)
+        let codebook = tok
+            .quants[nivel]
+            .codebook()
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("codebook: {e}")))?;
+        let d_lat = codebook.dims()[1];
+        let k = ger.k;
+        // δ_ort REAL do codebook treinado (rotação Stiefel em treino — A2)
+        let delta_ort_codebook = tok.quants[nivel]
+            .delta_ort()
+            .unwrap_or(1.0);
+        // logits_fn REAL: agregado (d_lat,) → proj_entrada → norm → cabeça
+        let proj = &ger.proj_entrada;
+        let norm = &ger.norm_entrada;
+        let cabeca = &ger.cabeca.cabecas[nivel];
+        let logits_fn = move |x: &candle_core::Tensor| -> candle_core::Result<candle_core::Tensor> {
+            let h = proj.fwd(&x.reshape((1, d_lat))?)?;
+            let h = norm.fwd(&h)?;
+            let lg = cabeca.fwd(&h)?;
+            lg.reshape((k,))
+        };
+        // verificador com temperatura calibrada pela fase C quando
+        // disponível; default 1,0 (a cota V-2 aplica-se com ECE medido)
+        let verif = verificador::VerificadorNcm::novo();
+        let mut arvore = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
+        let cfg_qc = pensamento::ConfigQuebraCabeca::novo(n_pecas, n_rodadas, tau_c);
+        let r = pensamento::quebra_cabeca_inovar(&codebook, &verif, &logits_fn, &mut arvore, &cfg_qc, &mut rng)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("qc: {e}")))?;
+        let rodadas: Vec<serde_json::Value> = r
+            .rodadas
+            .iter()
+            .map(|x| {
+                serde_json::json!({
+                    "rodada": x.rodada, "confianca": x.confianca,
+                    "aceito": x.aceito, "delta": x.delta_aplicado,
+                })
+            })
+            .collect();
+        let d_ = serde_json::json!({
+            "versao": "quebra-cabeca-real-0.7.0",
+            "nivel": nivel,
+            "delta_ort_codebook": delta_ort_codebook,
+            "n_conceitos": codebook.dims()[0],
+            "d_lat": d_lat,
+            "aceitos": r.aceitos,
+            "rejeitados": r.rejeitados,
+            "confianca_base": r.confianca_base,
+            "confianca_melhor": r.confianca_melhor,
+            "telemetria": r.telemetria,
+            "rodadas": rodadas,
+            "arvore_invariantes": arvore.invariantes_ok().is_ok(),
+            "punicao_no_pensamento": arvore
+                .no("pensamento")
+                .and_then(|i| arvore.nos[i].metricas.get("punicao").copied())
+                .unwrap_or(0.0),
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+/// Demo/gate do quebra-cabeça sobre conceitos SINTÉTICOS estruturados
+/// (validação de mecanismo; a avaliação com dados reais vive no script 63).
+#[pyfunction]
+#[pyo3(signature = (m=24, d=8, n_pecas=4, n_rodadas=12, tau_c=0.35, seed=777))]
+pub(crate) fn demo_quebra_cabeca(
+    py: Python,
+    m: usize,
+    d: usize,
+    n_pecas: usize,
+    n_rodadas: usize,
+    tau_c: f64,
+    seed: u64,
+) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let mut rng = rng::RngDeterministico::novo(seed);
+    // conceitos estruturados: cluster dominante +1 (média direcional) com
+    // 25% de outliers fracos — o agregado TEM direção (sem cancelamento)
+    let mut v = Vec::with_capacity(m * d);
+    for i in 0..m {
+        let centro = if i < m / 4 { 0.2 } else { 1.0 };
+        for j in 0..d {
+            v.push((centro + rng.normal(0.0, 0.25)) as f32);
+        }
+    }
+    let conceitos = candle_core::Tensor::from_vec(v, (m, d), &dev).map_err(py_err)?;
+    // logits_fn ASSIMÉTRICO: projeção fixa W_proj (rotação-sensível — a
+    // agregação simétrica seria invariante sob permutação/rotação, e o
+    // backbone real é exatamente o avaliador NÃO-invariente da prática).
+    let mut wv = Vec::with_capacity(d * 4);
+    for _ in 0..d * 4 {
+        wv.push((rng.normal_padrao() as f32) * 2.5);
+    }
+    let w_proj = candle_core::Tensor::from_vec(wv, (d, 4), &dev).map_err(py_err)?;
+    // verificador com temperatura padrão
+    let verif = verificador::VerificadorNcm::novo();
+    let logits_fn = |x: &candle_core::Tensor| -> candle_core::Result<candle_core::Tensor> {
+        // logits = xᵀ·W_proj (4,) — sensível à direção do agregado
+        x.reshape((1, d))?.matmul(&w_proj)?.reshape((4,))
+    };
+    let mut arvore = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
+    let cfg = pensamento::ConfigQuebraCabeca::novo(n_pecas, n_rodadas, tau_c);
+    let r = pensamento::quebra_cabeca_inovar(&conceitos, &verif, &logits_fn, &mut arvore, &cfg, &mut rng)
+        .map_err(py_err)?;
+    let rodadas: Vec<serde_json::Value> = r
+        .rodadas
+        .iter()
+        .map(|x| {
+            serde_json::json!({
+                "rodada": x.rodada, "confianca": x.confianca,
+                "aceito": x.aceito, "delta": x.delta_aplicado,
+            })
+        })
+        .collect();
+    let d_ = serde_json::json!({
+        "versao": "quebra-cabeca-0.7.0",
+        "aceitos": r.aceitos,
+        "rejeitados": r.rejeitados,
+        "confianca_base": r.confianca_base,
+        "confianca_melhor": r.confianca_melhor,
+        "telemetria": r.telemetria,
+        "rodadas": rodadas,
+        "arvore_invariantes": arvore.invariantes_ok().is_ok(),
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}

src/python/jepa_treinos.rs

@@ -0,0 +1,251 @@
+//! `python::jepa_treinos` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// Treina uma variante JEPA (7 variantes por máscara; lejepa/mcjepa/bjepa
+/// têm funções próprias) sobre patches (n, d) com grade dada.
+#[pyfunction]
+pub(crate) fn treinar_jepa(py: Python, dados: Vec<Vec<f64>>, grid: Vec<usize>, variante: String, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = jepa::CfgJepa::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                for (k, val) in o {
+                    match k.as_str() {
+                        "d_emb" => c.d_emb = val.as_u64().unwrap_or(32) as usize,
+                        "epocas" => c.epocas = val.as_u64().unwrap_or(60) as usize,
+                        "lr" => c.lr = val.as_f64().unwrap_or(3e-3),
+                        "m" => c.m = val.as_f64().unwrap_or(0.99),
+                        "lambda_vc" => c.lambda_vc = val.as_f64().unwrap_or(0.5),
+                        "gamma_vc" => c.gamma_vc = val.as_f64().unwrap_or(1.0),
+                        "frac_mascara" => c.frac_mascara = val.as_f64().unwrap_or(0.35),
+                        "semente" => c.semente = val.as_u64().unwrap_or(42),
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+    let var = match variante.as_str() {
+        "image" => jepa::VarianteJepa::ImageJepa,
+        "vjepa2" => jepa::VarianteJepa::VJepa2,
+        "audio" => jepa::VarianteJepa::AudioJepa,
+        "point" => jepa::VarianteJepa::PointJepa,
+        "jepa3d" => jepa::VarianteJepa::Jepa3D,
+        "brain" => jepa::VarianteJepa::BrainJepa,
+        "tjepa" => jepa::VarianteJepa::TJepa,
+        _ => jepa::VarianteJepa::TJepa,
+    };
+    let grid2 = if grid.is_empty() { vec![t.dim(0).unwrap_or(1)] } else { grid };
+    let rel = jepa::treinar_variante(
+        &t,
+        &|_n, r| jepa::mascara_por_variante(var, &grid2, c.frac_mascara, r),
+        &c,
+        var,
+        None,
+        &dev,
+    )
+    .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "versao": jepa::versao(),
+        "variante": rel.variante,
+        "perda_inicial": rel.perda_inicial,
+        "perda_final": rel.perda_final,
+        "perda_pred_inicial": rel.perda_pred_inicial,
+        "perda_pred_final": rel.perda_pred_final,
+        "queda_pct": if rel.perda_pred_inicial.is_finite() && rel.perda_pred_inicial > 0.0 {
+            100.0 * (1.0 - rel.perda_pred_final / rel.perda_pred_inicial)
+        } else { 0.0 },
+        "std_emb_inicial": rel.std_emb_inicial,
+        "std_emb_final": rel.std_emb_final,
+        "colapso_evitado": rel.std_emb_final > 0.05,
+        "n_patches": rel.n_patches,
+        "epocas": rel.epocas,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Treina LeJEPA (edição-condicionado): dados + instruções + editados.
+#[pyfunction]
+pub(crate) fn treinar_lejepa(py: Python, dados: Vec<Vec<f64>>, edits: Vec<Vec<f64>>, editados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let e = tensor_de_2d(edits, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let y = tensor_de_2d(editados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = jepa::CfgJepa::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; }
+                if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; }
+                if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); }
+                if let Some(x) = o.get("semente") { c.semente = x.as_u64().unwrap_or(42); }
+            }
+        }
+    }
+    let rel = jepa::treinar_lejepa(&t, &e, &y, &c, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "variante": rel.variante, "perda_inicial": rel.perda_inicial,
+        "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final,
+        "colapso_evitado": rel.std_emb_final > 0.05,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Treina MC-JEPA (cruz-modal): duas modalidades pareadas.
+#[pyfunction]
+pub(crate) fn treinar_mcjepa(py: Python, mod_a: Vec<Vec<f64>>, mod_b: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let a = tensor_de_2d(mod_a, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let b = tensor_de_2d(mod_b, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = jepa::CfgJepa::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; }
+                if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; }
+                if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); }
+            }
+        }
+    }
+    let rel = jepa::treinar_mcjepa(&a, &b, &c, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "variante": rel.variante, "perda_inicial": rel.perda_inicial,
+        "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final,
+        "colapso_evitado": rel.std_emb_final > 0.05,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Treina BJEPA (bidirecional com consistência de ciclo) sobre sequência.
+#[pyfunction]
+pub(crate) fn treinar_bjepa(py: Python, serie: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(serie, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = jepa::CfgJepa::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; }
+                if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; }
+                if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); }
+            }
+        }
+    }
+    let rel = jepa::treinar_bjepa(&t, &c, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "variante": rel.variante, "perda_inicial": rel.perda_inicial,
+        "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final,
+        "colapso_evitado": rel.std_emb_final > 0.05,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Demo SonicMoE: roteamento top-k com capacidade e perda de balanceamento.
+#[pyfunction]
+pub(crate) fn demo_sonic_moe(py: Python, n: usize, d: usize, n_expertos: usize, top_k: usize, capacidade: usize) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let moe = jepa::SonicMoe::novo(d, n_expertos, top_k, capacidade, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let x = candle_core::Tensor::randn(0f32, 1.0, (n, d), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let s = moe.fwd(&x).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let aux = s.perda_aux.to_scalar::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64;
+    let d_ = serde_json::json!({
+        "versao": jepa::versao(),
+        "carga_por_especialista": s.carga,
+        "descartados": s.descartados,
+        "perda_aux": aux,
+        "capacidade_respeitada": s.carga.iter().all(|&c| c <= capacidade),
+        "saida_forma": s.saida.dims().to_vec(),
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}
+
+
+/// Demo ReplaySSM: estabilidade + replay em cenário de troca de tarefa.
+#[pyfunction]
+pub(crate) fn demo_replay_ssm(py: Python, passos: usize, alpha: f64) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let mut ssm = jepa::ReplaySsm::novo(4, 6, alpha, 8, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut otim = crate::treino::AdamWManual::novo(ssm.vars(), 1e-2, 0.0);
+    let x_antigo = candle_core::Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut hist = Vec::new();
+    for _ in 0..passos {
+        let h = ssm.scan(&x_antigo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let alvo = h.detach();
+        let (pt, pn, pr) = ssm.passo_treino(&x_antigo, &alvo, &mut otim)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        hist.push(serde_json::json!({"total": pt, "novo": pn, "replay": pr}));
+    }
+    let x_novo = candle_core::Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    for _ in 0..passos {
+        let h = ssm.scan(&x_novo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let alvo = h.detach();
+        let _ = ssm.passo_treino(&x_novo, &alvo, &mut otim)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    }
+    let h_fin = ssm.scan(&x_antigo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mag = h_fin.sqr().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
+        .max_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
+        .to_scalar::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64;
+    let d_ = serde_json::json!({
+        "versao": jepa::versao(),
+        "alpha_replay": alpha,
+        "historico": hist,
+        "magnitudes_finitas": mag.is_finite(),
+        "magnitude_max_pos_troca": mag,
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}
+
+
+/// Extrai patches 2D de uma imagem achatada (C, H, W) — adaptador Image-JEPA.
+#[pyfunction]
+pub(crate) fn patches_2d(img: Vec<f32>, c: usize, h: usize, w: usize, ph: usize, pw: usize) -> PyResult<Vec<Vec<f32>>> {
+    let dev = candle_core::Device::Cpu;
+    let t = candle_core::Tensor::from_vec(img, (c, h, w), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let p = jepa::em_patches_2d(&t, ph, pw)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    p.to_vec2::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+}
+
+
+/// Extrai patches canal-independentes de série temporal (C, T) — T-JEPA.
+#[pyfunction]
+pub(crate) fn patches_serie(ts: Vec<f32>, c: usize, t: usize, pt: usize) -> PyResult<Vec<Vec<f32>>> {
+    let dev = candle_core::Device::Cpu;
+    let tt = candle_core::Tensor::from_vec(ts, (c, t), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let p = jepa::em_patches_serie(&tt, pt)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    p.to_vec2::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+}
+
+
+/// Extrai grupos FPS de nuvem de pontos (n, d) — Point-JEPA.
+#[pyfunction]
+pub(crate) fn grupos_pontos(pc: Vec<Vec<f64>>, k: usize, m: usize, semente: u64) -> PyResult<Vec<Vec<f64>>> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(pc, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut rng = crate::rng::RngDeterministico::novo(semente);
+    let g = jepa::em_grupos_pontos(&t, k, m, &mut rng)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let out = g.to_vec2::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    Ok(out.into_iter().map(|l| l.into_iter().map(|v| v as f64).collect()).collect())
+}

src/python/mod.rs

@@ -0,0 +1,145 @@
+//! FFI Python (PyO3) — dividida por domínio (v0.10.0, r-35 §2).
+
+//! FFI Python (PyO3) do KHTST_RUST — todo o `#[pymodule]`, os
+//! `#[pyfunction]`/`#[pyclass]` e a cola Python (conversões,
+//! callbacks, demos) vivem AQUI desde a v0.9.0 (antes: lib.rs,
+//! ~105 kB — crítica "God Object" do agente Qwen3.8, r-34 §5).
+//! A lógica de domínio (src/*.rs) não importa pyo3: `cargo test
+//! --no-default-features` executa a suíte SEM linkar o Python.
+//!
+//! Regra da casa mantida: nenhuma funcionalidade da superfície
+//! Python foi removida — os mesmos símbolos são registrados no
+//! `nucleo_rust`.
+
+use pyo3::prelude::*;
+
+use crate::*;
+
+// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
+mod calibracao;
+mod demos_qwen;
+mod fnh_arvore;
+mod jepa_treinos;
+mod moe;
+mod nlp_nlg;
+mod nucleo;
+mod pensamento_demos;
+mod som;
+mod treino_fases;
+
+
+// ---- itens mantidos no próprio mod.rs ----
+
+
+
+/// Adaptador FFI→domínio (v0.9.0): embrulha um callable Python no tipo de
+/// domínio `treino::CallbackTreino` — `treino.rs` não importa pyo3.
+fn callback_treino_de_py(callback: Option<pyo3::Bound<'_, pyo3::PyAny>>) -> treino::CallbackTreino {
+    use std::sync::Arc;
+    match callback {
+        None => None,
+        Some(c) => {
+            let f: pyo3::Py<pyo3::PyAny> = c.unbind();
+            let g: Arc<dyn Fn(&serde_json::Value) + Send + Sync> =
+                Arc::new(move |dados: &serde_json::Value| {
+                    pyo3::Python::with_gil(|py| {
+                        if let Ok(obj) = pythonize::pythonize(py, dados) {
+                            let _ = f.call1(py, (obj,));
+                        }
+                    });
+                });
+            Some(g)
+        }
+    }
+}
+
+
+// ===========================================================================
+// v0.5.0 — suíte SOM 4D, suíte JEPA, Pensamento, telemetria robusta
+// ===========================================================================
+
+fn tensor_de_2d(dados: Vec<Vec<f64>>, dev: &candle_core::Device) -> candle_core::Result<candle_core::Tensor> {
+    let d = dados.first().map(|r| r.len()).unwrap_or(1).max(1);
+    let n = dados.len();
+    let flat: Vec<f32> = dados.into_iter().flat_map(|r| r.into_iter().map(|x| x as f32).collect::<Vec<_>>()).collect();
+    candle_core::Tensor::from_vec(flat, (n, d), dev)
+}
+
+
+// ---------------------------------------------------------------------------
+// v0.6.0 — verificador NCM (sem oráculo), fase C, MoE redirecionável,
+// acoplador duplex e autoajuste
+// ---------------------------------------------------------------------------
+
+/// Converte matriz f64 → Tensor (n, d) F32.
+fn tensor_f64_2d(v: &[Vec<f64>], dev: &candle_core::Device) -> candle_core::Result<candle_core::Tensor> {
+    let (n, d) = (v.len(), v.first().map(|l| l.len()).unwrap_or(0));
+    candle_core::Tensor::from_vec(v.iter().flatten().cloned().collect(), (n, d), dev)
+}
+
+
+fn py_err(e: candle_core::Error) -> pyo3::PyErr {
+    pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))
+}
+
+
+#[pymodule]
+fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    pyo3_log::init();
+    m.add_function(wrap_pyfunction!(nucleo::versao, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::info_build, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::lint_config, m)?)?;
+    m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_a, m)?)?;
+    m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_b, m)?)?;
+    m.add_function(wrap_pyfunction!(treino_fases::gerar_amostras, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::verificar_mascara, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::verificar_stiefel, m)?)?;
+    // v0.10.0 — checkpoints atômicos com prova de integridade
+    m.add_function(wrap_pyfunction!(nucleo::checkpoint_valido, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::checkpoint_manifesto, m)?)?;
+    m.add_function(wrap_pyfunction!(nucleo::sha256_arquivo, m)?)?;
+    // v0.5.0 — SOM 4D / JEPA / Pensamento
+    m.add_function(wrap_pyfunction!(som::treinar_som4d, m)?)?;
+    m.add_function(wrap_pyfunction!(som::treinar_gng, m)?)?;
+    m.add_function(wrap_pyfunction!(som::treinar_hsom, m)?)?;
+    m.add_function(wrap_pyfunction!(som::demo_tsom, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::treinar_jepa, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::treinar_lejepa, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::treinar_mcjepa, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::treinar_bjepa, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::demo_sonic_moe, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::demo_replay_ssm, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::classificar_erro, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::confianca_de_logits, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::projetar_ridge, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::demo_pensamento, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::patches_2d, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::patches_serie, m)?)?;
+    m.add_function(wrap_pyfunction!(jepa_treinos::grupos_pontos, m)?)?;
+    // v0.6.0
+    m.add_function(wrap_pyfunction!(calibracao::calibrar_verificador, m)?)?;
+    m.add_function(wrap_pyfunction!(calibracao::demo_verificador_ncm, m)?)?;
+    m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_c, m)?)?;
+    m.add_function(wrap_pyfunction!(moe::demo_moe_redirecionavel, m)?)?;
+    m.add_function(wrap_pyfunction!(moe::jepa_com_moe, m)?)?;
+    m.add_function(wrap_pyfunction!(moe::som_com_moe, m)?)?;
+    m.add_function(wrap_pyfunction!(moe::demo_acoplador_duplo, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::demo_pensamento_ncm, m)?)?;
+    m.add_function(wrap_pyfunction!(pensamento_demos::demo_autoajuste, m)?)?;
+    m.add_function(wrap_pyfunction!(fnh_arvore::demo_fnh, m)?)?;
+    m.add_function(wrap_pyfunction!(fnh_arvore::demo_quebra_cabeca, m)?)?;
+    m.add_function(wrap_pyfunction!(fnh_arvore::quebra_cabeca_real, m)?)?;
+    m.add_function(wrap_pyfunction!(nlp_nlg::demo_nlp_nlg, m)?)?;
+    m.add_function(wrap_pyfunction!(som::demo_autoajuste_som, m)?)?;
+    // v0.8.0 — análise/prova/teste das propostas Qwen3.8
+    m.add_function(wrap_pyfunction!(demos_qwen::demo_qwen_v080, m)?)?;
+    // v0.9.0 — veredito executável das críticas Qwen3.8 (r-34)
+    m.add_function(wrap_pyfunction!(demos_qwen::demo_criticas_v090, m)?)?;
+    m.add_class::<nucleo::BpePy>()?;
+    m.add_class::<nucleo::ConfigPy>()?;
+    m.add_class::<nucleo::PonteDuplaPy>()?;
+    #[cfg(feature = "ponte_async")]
+    m.add_class::<nucleo::PonteAsyncPy>()?;
+    m.add_class::<fnh_arvore::ArvorePesosPy>()?;
+    Ok(())
+}

src/python/moe.rs

@@ -0,0 +1,190 @@
+//! `python::moe` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// **MoE redirecionável — demo completa (M-R1..M-R5):** neutralidade da
+/// atenção própria (M-R2), invariância de capacidade/perda auxiliar sob
+/// redirecionamento (M-R1), paralelismo medido (M-R3), water-filling por
+/// QE vs uniforme (M-R5) e fechamento da classe (M-R4 — via permutação).
+#[pyfunction]
+pub(crate) fn demo_moe_redirecionavel(d: usize, n: usize, semente: u64) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        crate::rng::definir_semente(semente);
+        let mut rng = crate::rng::RngDeterministico::novo(semente);
+        let x: Vec<f32> = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+        let x = candle_core::Tensor::from_vec(x, (n, d), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut moe = moe_redirecionavel::MoeRedirecionavel::novo(d, 8, 2, n, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        // M-R2: neutralidade no nascimento
+        let g0 = moe.atencao.gate.as_tensor().to_scalar::<f32>().unwrap();
+        let y0 = moe.atencao.fwd(&x).unwrap();
+        let dif0 = (&y0 - &x).unwrap().sqr().unwrap().sum_all().unwrap()
+            .to_scalar::<f32>().unwrap() as f64;
+        // abre o gate (mecanismo ativo)
+        moe.atencao.gate.set(&candle_core::Tensor::new(1.0f32, &dev).unwrap()).unwrap();
+        // M-R1: invariância sob redirecionamento
+        let s_enc = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+        let carga_antes: usize = s_enc.carga.iter().sum();
+        let perda_antes = s_enc.perda_aux.to_scalar::<f32>().unwrap() as f64;
+        let permuta: Vec<usize> = (0..8).map(|i| (i + 1) % 8).collect();
+        moe.redirecionar(&permuta);
+        let s_enc2 = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+        let carga_depois: usize = s_enc2.carga.iter().sum();
+        let perda_depois = s_enc2.perda_aux.to_scalar::<f32>().unwrap() as f64;
+        // M-R3: paralelismo medido (enc ∥ dec em 2 threads)
+        let (_e, _dc, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap();
+        // M-R5: water-filling vs uniforme (cota analítica)
+        let qes: Vec<f64> = vec![0.15, 0.4, 1.0, 0.25, 0.6, 0.1, 0.35, 0.5];
+        let c_wf = moe_redirecionavel::alocar_por_qe(&qes, 16);
+        let c_un = vec![2usize; 8];
+        let cota = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::<f64>();
+        let (cota_wf, cota_un) = (cota(&c_wf), cota(&c_un));
+        let d_ = serde_json::json!({
+            "versao": moe_redirecionavel::versao(), "d": d, "n": n,
+            "valor_gate_no_nascimento": g0, "neutralidade_dif": dif0,
+            "carga_antes": carga_antes, "carga_depois": carga_depois,
+            "perda_aux_antes": perda_antes, "perda_aux_depois": perda_depois,
+            "t_paralelo_s": t_par, "t_sequencial_s": t_seq, "speedup": speedup,
+            "alocacao_water_filling": c_wf, "cota_wf": cota_wf, "cota_uniforme": cota_un,
+            "gates": {
+                "gate_mr1_capacidade": carga_antes == carga_depois,
+                "gate_mr1_perda_aux": (perda_antes - perda_depois).abs() < 2.0 + 1e-6,
+                "gate_mr2_neutralidade": dif0 == 0.0 && g0 == 0.0,
+                "gate_mr3_paralelismo": t_par < t_seq,
+                "gate_mr5_water_filling": cota_wf <= cota_un + 1e-9,
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+/// **JEPA com MoE redirecionável (ablação de 3 braços):** `modo` ∈
+/// {"pequena", "densa", "moe"} — o braço "densa" tem a capacidade TOTAL dos
+/// especialistas SEM roteamento (isola o ganho do roteamento em si).
+#[pyfunction]
+pub(crate) fn jepa_com_moe(
+    patches: Vec<Vec<f32>>,
+    modo: String,
+    passos: usize,
+    frac_mascara: f64,
+    semente: u64,
+) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        let t = tensor_f64_2d(&patches.into_iter().map(|l| l.into_iter().map(|x| x as f64).collect()).collect::<Vec<Vec<f64>>>(), &dev)
+            .and_then(|t| t.to_dtype(candle_core::DType::F32))
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let modo: &'static str = match modo.as_str() {
+            "pequena" => "pequena",
+            "densa" => "densa",
+            _ => "moe",
+        };
+        let r = moe_redirecionavel::treinar_jepa_com_moe(&t, modo, passos, frac_mascara, semente)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let d_ = serde_json::json!({
+            "modo": r.modo, "perda_pred_inicial": r.perda_pred_inicial,
+            "perda_pred_final": r.perda_pred_final, "perda_vc_final": r.perda_vc_final,
+            "std_emb": r.std_emb, "carga_max": r.carga_max, "descartados": r.descartados,
+            "queda_abs": r.perda_pred_inicial - r.perda_pred_final,
+            "aprendeu": r.perda_pred_final < r.perda_pred_inicial,
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+/// **SOM refinado por MoE com water-filling (M-R5) + redirecionamento
+/// para decodificador:** treina um 4D-SOM, refina com MoE (QE′ < QE),
+/// compara com alocação uniforme e mede a decodificação pós-redirect.
+#[pyfunction]
+pub(crate) fn som_com_moe(
+    dados: Vec<Vec<f64>>,
+    lado: usize,
+    passos: usize,
+    semente: u64,
+) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dev = candle_core::Device::Cpu;
+        let t = tensor_f64_2d(&dados, &dev)
+            .and_then(|t| t.to_dtype(candle_core::DType::F32))
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        // treina o 4D-SOM (r-19: S4-1/S4-2/S4-3) — som4d opera em F32
+        let cfg_som = som4d::CfgSom4D { nx: lado, ny: lado, nz: lado, nt: lado, ..Default::default() };
+        let som = som4d::treinar_som4d(&t, &cfg_som, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let centroides: Vec<Vec<f64>> = som.prototipos.clone();
+        // refinamento MoE (mesmo tensor F32; centroides seguem em f64)
+        let r = moe_redirecionavel::refinar_som_com_moe(&t, &centroides, passos, semente)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let d_ = serde_json::json!({
+            "qe_antes": r.qe_antes, "qe_depois_water_filling": r.qe_depois,
+            "qe_depois_uniforme": r.qe_alocacao_uniforme,
+            "carga_por_celula": r.carga_por_celula,
+            "tempo_treino_s": r.tempo_treino_s,
+            "mse_decodificador_pos_redirect": r.mse_decodificador,
+            "reducao_qe_pct": 100.0 * (r.qe_antes - r.qe_depois) / r.qe_antes.max(1e-12),
+            "gates": {
+                "gate_moe_refina": r.qe_depois < r.qe_antes,
+                "gate_wf_melhor_uniforme": r.qe_depois <= r.qe_alocacao_uniforme * 1.02,
+                "gate_redirect_decodifica": r.mse_decodificador < r.qe_antes.powi(2),
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+/// **AcopladorDuplo — demo do protocolo lag-1 síncrono** (AC-1/AC-2):
+/// rodadas duplex Pensamento↔backbone com correções decaindo (co-adaptação)
+/// e confiança subindo; zero deadlocks/timeouts (P.1/P.2 herdados).
+#[pyfunction]
+pub(crate) fn demo_acoplador_duplo(rodadas: usize, timeout_ms: u64) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let mut ac = acoplador::AcopladorDuplo::nova(16, timeout_ms);
+        let mut rng = crate::rng::RngDeterministico::novo(77);
+        let mut conf = 0.05f64;
+        let mut traj = Vec::new();
+        for k in 0..rodadas {
+            let estado = acoplador::EstadoModelo {
+                a: vec![0.1 * (k % 7) as f32; 16],
+                b: vec![rng.normal(0.0, 0.3) as f32; 16],
+                c: vec![0.05; 8],
+                confianca: conf,
+                nivel: k % 7,
+                passo: k,
+            };
+            let _ = ac.rodada(estado).map_err(|e|
+                pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            // correção fresca: decaindo com a confiança (co-adaptação)
+            let amplitude = (1.0 - conf).max(0.05);
+            let delta: Vec<f32> = (0..16).map(|i| amplitude as f32 * ((i % 5) as f32 - 2.0) * 0.1).collect();
+            ac.registrar_correcao(acoplador::Correcao {
+                delta, acordo: 0.6 + 0.3 * conf, confianca_agregada: conf,
+                iteracao: k, pesos: vec![0.25; 4],
+            });
+            traj.push(conf);
+            conf = (conf + 0.04 + rng.uniforme() * 0.02).min(0.99);
+        }
+        let t = &ac.telemetria;
+        let p = ac.estatisticas();
+        let d_ = serde_json::json!({
+            "versao": acoplador::versao(), "rodadas": t.rodadas,
+            "timeouts": t.timeouts, "tempo_total_ms": t.tempo_total_ms,
+            "soma_norma_delta": t.soma_norma_delta,
+            "conf_final": traj.last(), "conf_trajetoria_len": traj.len(),
+            "envios_a_para_b": p.envios_a_para_b, "envios_b_para_a": p.envios_b_para_a,
+            "maior_sobreposicao_us": t.maior_sobreposicao_us,
+            "gates": {
+                "gate_terminou": t.rodadas == rodadas as u64,
+                "gate_sem_timeout": t.timeouts == 0,
+                "gate_duplex_simultaneo": p.envios_a_para_b == p.envios_b_para_a && p.envios_a_para_b == rodadas as u64,
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}

src/python/nlp_nlg.rs

@@ -0,0 +1,69 @@
+//! `python::nlp_nlg` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// Demo/gate das unidades NLP/NLG sobre estados ocultos sintéticos
+/// (nascimento neutro + gates + coerência de bigramas + especulativo).
+#[pyfunction]
+#[pyo3(signature = (d=32, t=6, seed=11))]
+pub(crate) fn demo_nlp_nlg(py: Python, d: usize, t: usize, seed: u64) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let mut rng = rng::RngDeterministico::novo(seed);
+    let v: Vec<f32> = (0..2 * t * d).map(|_| rng.normal_padrao() as f32).collect();
+    let h = candle_core::Tensor::from_vec(v, (2, t, d), &dev).map_err(py_err)?;
+    // NLP: enriquecimento aditivo — neutro no nascimento
+    let mut nlp = nlp::UnidadeNlp::nova(d, &dev).map_err(|e| {
+        pyo3::exceptions::PyRuntimeError::new_err(format!("nlp (d%4): {e}"))
+    })?;
+    let h_enr = nlp.enriquecer(&h).map_err(py_err)?;
+    let dif_nlp = (&h).sub(&h_enr).map_err(py_err)?.abs().map_err(py_err)?.max_all().map_err(py_err)?.to_scalar::<f32>().map_err(py_err)? as f64;
+    // intenção
+    let (intencoes, confs) = nlp.intencao_argmax(&h).map_err(py_err)?;
+    // NLG: plano + condicionamento neutro + coerência
+    let mut nlg = nlg::UnidadeNlg::nova(d, 4096, &dev).map_err(py_err)?;
+    let plano = nlg.plano(&h).map_err(py_err)?;
+    let p8 = candle_core::Tensor::randn(0f32, 1f32, (nlg::N_EIXOS_ESTILO,), &dev).map_err(py_err)?;
+    let p01 = candle_nn::ops::sigmoid(&p8).map_err(py_err)?;
+    let h_cond = nlg.condicionar(&h, Some(&p01)).map_err(py_err)?;
+    let dif_nlg = (&h).sub(&h_cond).map_err(py_err)?.abs().map_err(py_err)?.max_all().map_err(py_err)?.to_scalar::<f32>().map_err(py_err)? as f64;
+    // coerência: contexto observado vs candidato novo
+    let ctx = vec![5u32, 6, 7, 8, 9];
+    nlg.observar_contexto(&ctx);
+    let s_mesmo = nlg.score_coerencia(&ctx);
+    let s_novo = nlg.score_coerencia(&[50u32, 51, 52, 53]);
+    // especulativo: aceitação típica + stats
+    let mut espec = nlg::DecodificadorEspeculativo::novo(4, 0.95, 10);
+    let logits = candle_core::Tensor::from_vec(vec![3.0f32, 0.2, 0.1, 0.05], (4,), &dev)
+        .map_err(py_err)?;
+    let mut aceites = 0usize;
+    for _ in 0..30 {
+        let (_, ok) = espec.verificar_e_corrigir(&logits, &[0, 1]).map_err(py_err)?;
+        if ok {
+            aceites += 1;
+        }
+    }
+    let d_ = serde_json::json!({
+        "versao": "nlp-nlg-0.7.0",
+        "nlp_gate_medio": nlp.gate_medio,
+        "nlp_dif_nascimento": dif_nlp,
+        "nlp_intencoes": intencoes,
+        "nlp_confiancas": confs,
+        "nlg_plano_forma": plano.dims(),
+        "nlg_dif_nascimento": dif_nlg,
+        "nlg_coerencia_mesmo": s_mesmo,
+        "nlg_coerencia_novo": s_novo,
+        "espec_aceitacao_media": espec.stats.aceitacao_media,
+        "espec_speedup": espec.stats.speedup_estimado,
+        "espec_aceites_30": aceites,
+        "gates": {
+            "nlp_neutro": dif_nlp == 0.0,
+            "nlg_neutro": dif_nlg == 0.0,
+            "gate_medio_ok": (nlp.gate_medio - 0.119).abs() < 0.05,
+            "coerencia_ok": s_mesmo > 0.9 && s_novo < 0.1,
+            "espec_ok": espec.stats.aceitacao_media > 0.8,
+        },
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}

src/python/nucleo.rs

@@ -0,0 +1,239 @@
+//! `python::nucleo` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+#[pyfunction]
+pub(crate) fn versao() -> &'static str {
+    concat!("khtst-rust-", env!("CARGO_PKG_VERSION"))
+}
+
+
+#[pyfunction]
+pub(crate) fn info_build() -> String {
+    format!(
+        "rustc={}; perfil={}; features={}; alvo={}",
+        build_info::RUSTC_VERSION,
+        build_info::PROFILE,
+        build_info::FEATURES_STR,
+        build_info::TARGET,
+    )
+}
+
+
+/// Lint de config com sugestões por Levenshtein (diagnóstico de digitação).
+#[pyfunction]
+pub(crate) fn lint_config(py: Python, 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 achatado = diagnostico::achatar(&v);
+    let avisos = diagnostico::lint_chaves(&achatado);
+    let saida: Vec<serde_json::Value> = avisos
+        .iter()
+        .map(|a| serde_json::json!({
+            "chave": a.chave, "sugestao": a.sugestao, "causa": a.causa, "correcao": a.correcao,
+        }))
+        .collect();
+    Ok(pythonize::pythonize(py, &serde_json::json!(saida))?.into())
+}
+
+
+#[pyclass(name = "Bpe")]
+pub(crate) struct BpePy {
+    bpe: tokens::Bpe,
+}
+
+#[pymethods]
+impl BpePy {
+    #[staticmethod]
+    fn treinar(textos: Vec<String>, vocab_alvo: usize) -> PyResult<Self> {
+        Ok(BpePy { bpe: tokens::Bpe::treinar(&textos, vocab_alvo) })
+    }
+
+    #[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}")))?;
+        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)
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("formato BPE inválido"))?;
+        Ok(BpePy { bpe })
+    }
+
+    fn codificar(&mut self, texto: &str) -> Vec<u32> {
+        self.bpe.codificar(texto)
+    }
+
+    fn decodificar(&self, ids: Vec<u32>) -> String {
+        self.bpe.decodificar(&ids)
+    }
+
+    fn salvar(&self, caminho: &str) -> PyResult<()> {
+        let txt = serde_json::to_string(&self.bpe.para_json()).unwrap();
+        crate::checkpoint::salvar_atomico(caminho, &txt)
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
+        Ok(())
+    }
+
+    #[getter]
+    fn n_vocab(&self) -> usize {
+        self.bpe.n_vocab()
+    }
+}
+
+
+#[pyclass(name = "Config")]
+pub(crate) struct ConfigPy {
+    pub(crate) cfg: config::ConfigKhtst,
+    caminho: Option<String>,
+}
+
+#[pymethods]
+impl ConfigPy {
+    #[new]
+    #[allow(never_type_fallback)]
+    #[pyo3(signature = (caminho=None))]
+    fn new(caminho: Option<String>) -> PyResult<Self> {
+        let cfg = match &caminho {
+            Some(c) => {
+                let txt = std::fs::read_to_string(c)
+                    .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{c}: {e}")))?;
+                let v: serde_json::Value = serde_json::from_str(&txt)
+                    .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
+                serde_json::from_value(v)
+                    .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("config: {e}")))?
+            }
+            None => config::ConfigKhtst::default(),
+        };
+        cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err)?;
+        Ok(ConfigPy { cfg, caminho })
+    }
+
+    fn validar(&self) -> PyResult<()> {
+        self.cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err)
+    }
+
+    fn checar_orcamento_cache(&self) -> PyResult<usize> {
+        self.cfg.checar_orcamento_cache().map_err(pyo3::exceptions::PyValueError::new_err)
+    }
+
+    fn resumo(&self) -> String {
+        format!(
+            "modelo(vocab={}, d={}, camadas={}, ctx={}) ncm(L={}, niveis={:?}, K={}, d_lat={}, modo={}, ativo={})",
+            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.ncm.k_por_nivel, self.cfg.ncm.d_lat, self.cfg.ncm.modo_quantizacao, self.cfg.ncm.ativo,
+        )
+    }
+
+    #[getter]
+    fn l_niveis(&self) -> usize {
+        self.cfg.l_niveis()
+    }
+}
+
+
+#[pyclass(name = "PonteDupla")]
+pub(crate) struct PonteDuplaPy {
+    ponte: ponte::PonteDupla,
+}
+
+#[pymethods]
+impl PonteDuplaPy {
+    #[new]
+    #[pyo3(signature = (capacidade=64, timeout_ms=2000))]
+    fn new(capacidade: usize, timeout_ms: u64) -> Self {
+        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)
+            .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
+        Ok((ma.carga, mb.carga))
+    }
+
+    fn demo_professor_aluno(&self, 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()
+        })
+        .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
+        Python::with_gil(|py| {
+            Ok(pythonize::pythonize(py, &serde_json::to_value(&stats).unwrap())?.into())
+        })
+    }
+
+    fn estatisticas(&self) -> PyResult<PyObject> {
+        let s = self.ponte.estatisticas();
+        Python::with_gil(|py| {
+            Ok(pythonize::pythonize(py, &serde_json::to_value(&s).unwrap())?.into())
+        })
+    }
+}
+
+
+#[cfg(feature = "ponte_async")]
+#[pyclass(name = "PonteAsync")]
+pub(crate) struct PonteAsyncPy {
+    interna: std::sync::Arc<ponte::assincrona::PonteAsync>,
+}
+
+#[cfg(feature = "ponte_async")]
+#[pymethods]
+impl PonteAsyncPy {
+    #[new]
+    #[pyo3(signature = (capacidade=64, timeout_ms=2000))]
+    fn new(capacidade: usize, timeout_ms: u64) -> Self {
+        PonteAsyncPy { interna: std::sync::Arc::new(ponte::assincrona::PonteAsync::nova(capacidade, timeout_ms)) }
+    }
+
+    /// Corrotina: `await ponte.trocar(a, b, nivel)` — duplex simultânea.
+    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 {
+            let (ma, mb) = p.rodada_async(carga_a, carga_b, nivel)
+                .await
+                .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
+            Ok::<_, PyErr>((ma.carga, mb.carga))
+        })
+    }
+}
+
+
+/// Utilitários de prova expostos ao Python (V-série da suíte).
+#[pyfunction]
+pub(crate) fn verificar_mascara(cfg: &ConfigPy) -> PyResult<usize> {
+    let dev = candle_core::Device::Cpu;
+    let m = mascaras::mascara_block_causal(&cfg.cfg.ncm.niveis, gerador::N_PREFIXO, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    mascaras::contar_vazamentos(&cfg.cfg.ncm.niveis, gerador::N_PREFIXO, &m)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+}
+
+
+#[pyfunction]
+pub(crate) fn verificar_stiefel(k: usize, d: usize) -> PyResult<f64> {
+    let dev = candle_core::Device::Cpu;
+    let c = stiefel::init_stiefel(k, d, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    stiefel::erro_ortogonalidade(&c.transpose(0, 1).unwrap()).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+}
+
+#[pyfunction]
+pub(crate) fn checkpoint_valido(caminho: &str) -> bool {
+    crate::checkpoint::validar(caminho)
+}
+
+#[pyfunction]
+pub(crate) fn checkpoint_manifesto(caminho: &str) -> Option<String> {
+    std::fs::read_to_string(crate::checkpoint::caminho_manifesto(caminho)).ok()
+}
+
+#[pyfunction]
+pub(crate) fn sha256_arquivo(caminho: &str) -> Option<String> {
+    std::fs::read(caminho).ok().map(|d| crate::checkpoint::sha256_hex(&d))
+}

src/python/pensamento_demos.rs

@@ -0,0 +1,367 @@
+//! `python::pensamento_demos` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// Classificação de erro por taxonomia (diagnóstico de refatoração).
+#[pyfunction]
+pub(crate) fn classificar_erro(msg: String) -> Vec<(String, String, String)> {
+    diagnostico::classificar_erro(&msg)
+        .into_iter()
+        .map(|(a, b, c)| (a.to_string(), b.to_string(), c.to_string()))
+        .collect()
+}
+
+
+/// Confiança de uma distribuição (T-P1): `1 − H(softmax(z))/log K`.
+#[pyfunction]
+pub(crate) fn confianca_de_logits(logits: Vec<f32>) -> PyResult<f64> {
+    let dev = candle_core::Device::Cpu;
+    let k = logits.len();
+    let t = candle_core::Tensor::from_vec(logits, (1, k), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    pensamento::confianca_de_logits(&t).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
+}
+
+
+/// Projeção ridge (T-P3 — montador algébrico): `r* = (WᵀW+εI)⁻¹Wᵀr`.
+#[pyfunction]
+pub(crate) fn projetar_ridge(w: Vec<Vec<f64>>, r_alvo: Vec<Vec<f64>>, eps: f64) -> PyResult<Vec<Vec<f64>>> {
+    let dev = candle_core::Device::Cpu;
+    let wt = tensor_de_2d(w, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let rt = tensor_de_2d(r_alvo, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let r = pensamento::projetar_ridge(&wt, &rt, eps)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let out = r.to_vec2::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    Ok(out.into_iter().map(|l| l.into_iter().map(|v| v as f64).collect()).collect())
+}
+
+
+/// Demo completa da tecnologia Pensamento: treino cooperativo das N redes
+/// (item a) + ciclo d com verificador externo simulado + telemetria.
+#[pyfunction]
+pub(crate) fn demo_pensamento(
+    py: Python,
+    d_cond: usize,
+    d_saida: usize,
+    n_tentativas: usize,
+    passos_treino: usize,
+    limiar_conf: f64,
+    orcamento: usize,
+    semente: u64,
+) -> PyResult<PyObject> {
+    use candle_core::Tensor;
+    let dev = candle_core::Device::Cpu;
+    crate::rng::definir_semente(semente);
+    let mut motor = pensamento::MotorPensamento::novo(d_cond, d_saida, n_tentativas, limiar_conf, orcamento, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut otim = crate::treino::AdamWManual::novo(motor.vars(), 5e-3, 0.0);
+    let mut rng = crate::rng::RngDeterministico::novo(semente);
+
+    // dados sintéticos: alvo = função determinística não-linear de cond (d=a+b+c)
+    let n_dados = 256usize;
+    let conds: Vec<Vec<f32>> = (0..n_dados)
+        .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect())
+        .collect();
+    let alvos: Vec<Vec<f32>> = conds
+        .iter()
+        .map(|c| {
+            (0..d_saida)
+                .map(|j| {
+                    let cj = c[j % d_cond];
+                    let ck = c[(j + 1) % d_cond];
+                    0.5 * cj + 0.3 * cj * ck + 0.1
+                })
+                .collect()
+        })
+        .collect();
+    let cond_t = Tensor::from_vec(conds.into_iter().flatten().collect(), (n_dados, d_cond), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let alvo_t = Tensor::from_vec(alvos.into_iter().flatten().collect(), (n_dados, d_saida), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+
+    // item a: treino cooperativo
+    let mut perda_hist = Vec::new();
+    for passo in 0..passos_treino {
+        let perda = motor.perda_treino(&cond_t, &alvo_t)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        perda_hist.push(perda.to_scalar::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64);
+        otim.passo(crate::treino::grads_achatados(&perda, &motor.vars())
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
+        let _ = passo;
+    }
+
+    // item c+d: consulta fora do padrão (OOD) — confiança baixa ⇒ Pensamento
+    let consulta: Vec<f32> = (0..d_cond).map(|j| 3.0 + (j as f32) * 0.1).collect();
+    let consulta_t = Tensor::from_vec(consulta, (d_cond,), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    // verificador externo: negativo do MSE contra o alvo verdadeiro da consulta
+    let alvo_verdadeiro: Vec<f32> = (0..d_saida)
+        .map(|j| {
+            let cj = 3.0 + (j % d_cond) as f32 * 0.1;
+            let ck = 3.0 + ((j + 1) % d_cond) as f32 * 0.1;
+            0.5 * cj + 0.3 * cj * ck + 0.1
+        })
+        .collect();
+    let alvo_verd = Tensor::from_vec(alvo_verdadeiro.clone(), (d_saida,), &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let verifica = |resp: &Tensor| -> f64 {
+        // confiança = 1/(1+10·MSE) — medível e causaL (só da resposta)
+        let dif = (resp.broadcast_as((1, d_saida)).unwrap() - &alvo_verd.broadcast_as((1, d_saida)).unwrap()).unwrap();
+        let mse = dif.sqr().unwrap().mean_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+        1.0 / (1.0 + 10.0 * mse)
+    };
+    let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1);
+    let res = motor.raciocinar(&consulta_t, &verifica, &mut rng2)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+
+    // linha de base SEM pensamento: uma tentativa isolada, sem agregação
+    let base = motor.tentativas[0].fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap())
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let conf_base = verifica(&base);
+    let conf_pensamento = res.confianca;
+
+    let d_ = serde_json::json!({
+        "versao": pensamento::versao(),
+        "n_tentativas": n_tentativas,
+        "perda_treino_inicial": perda_hist.first(),
+        "perda_treino_final": perda_hist.last(),
+        "treino_aprendeu": perda_hist.last().copied().unwrap_or(f64::INFINITY) < perda_hist.first().copied().map(|p| p * 0.5).unwrap_or(f64::INFINITY),
+        "iteracoes_ciclo_d": res.iteracoes,
+        "confianca_base_1_rede": conf_base,
+        "confianca_pensamento": conf_pensamento,
+        "ganho_confianca": conf_pensamento - conf_base,
+        "orcamento_esgotado": res.telemetria.get("orcamento_esgotado").copied().unwrap_or(0.0),
+        "telemetria": res.telemetria,
+        "eventos_ciclo": res.trajetoria.iter().map(|e| match e {
+            pensamento::EventoCiclo::Planejamento { iteracao, temperatura } =>
+                serde_json::json!({"tipo": "planejamento", "iteracao": iteracao, "temperatura": temperatura}),
+            pensamento::EventoCiclo::DistribuicaoCompetencias { por_tentativa } =>
+                serde_json::json!({"tipo": "distribuicao", "pesos": por_tentativa}),
+            pensamento::EventoCiclo::RePlanejamento { motivo } =>
+                serde_json::json!({"tipo": "replanejamento", "motivo": motivo}),
+            pensamento::EventoCiclo::Resposta { confianca, iteracoes } =>
+                serde_json::json!({"tipo": "resposta", "confianca": confianca, "iteracoes": iteracoes}),
+        }).collect::<Vec<_>>(),
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}
+
+
+/// **Ciclo d do Pensamento com o VERIFICADOR NCM** (produção, sem oráculo):
+/// backbone CABEÇA TREINADA (alvo → classes) + verificador calibrado em
+/// dados retidos; N tentativas agregadas; ganho medido em consultas retidas
+/// EM DISTRIBUIÇÃO (onde a calibração vale — V-2) e OOD reportado à parte.
+#[pyfunction]
+pub(crate) fn demo_pensamento_ncm(
+    d_cond: usize,
+    d_saida: usize,
+    n_tentativas: usize,
+    passos_treino: usize,
+    limiar_conf: f64,
+    orcamento: usize,
+    semente: u64,
+) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        use candle_core::Tensor;
+        let dev = candle_core::Device::Cpu;
+        crate::rng::definir_semente(semente);
+        let mut motor = pensamento::MotorPensamento::novo(
+            d_cond, d_saida, n_tentativas, limiar_conf, orcamento, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut otim = treino::AdamWManual::novo(motor.vars(), 5e-3, 0.0);
+        let mut rng = crate::rng::RngDeterministico::novo(semente);
+        // ---- dados sintéticos (item a: treino cooperativo) ----
+        let n_dados = 320usize;
+        let conds: Vec<Vec<f32>> = (0..n_dados)
+            .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect())
+            .collect();
+        let alvos: Vec<Vec<f32>> = conds.iter().map(|c| {
+            (0..d_saida).map(|j| {
+                let cj = c[j % d_cond];
+                let ck = c[(j + 1) % d_cond];
+                0.5 * cj + 0.3 * cj * ck + 0.1
+            }).collect()
+        }).collect();
+        let mk = |c: &[f32], j: usize| -> f32 {
+            let cj = c[j % d_cond];
+            let ck = c[(j + 1) % d_cond];
+            0.5 * cj + 0.3 * cj * ck + 0.1
+        };
+        let cond_t = Tensor::from_vec(conds.iter().flatten().cloned().collect(), (n_dados, d_cond), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let alvo_t = Tensor::from_vec(alvos.iter().flatten().cloned().collect(), (n_dados, d_saida), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        // ---- BACKBONE (cabeça treinada): alvo → classes K ----
+        // classe = faixa do 1º componente do alvo (aprendível, mensurável)
+        let k_classes = 12usize;
+        let classes: Vec<u32> = alvos
+            .iter()
+            .map(|a| {
+                let v = a[0];
+                let f = (((v + 2.0) / 4.0) * (k_classes as f32)).floor();
+                (f.clamp(0.0, (k_classes - 1) as f32)) as u32
+            })
+            .collect();
+        let cabeca = crate::jepa::MlpJepa::novo(d_saida, 4 * d_saida, k_classes, &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let classe_t = Tensor::from_vec(classes.clone(), (n_dados,), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0);
+        for _ in 0..200 {
+            let logits = cabeca.fwd(&alvo_t)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let ce = candle_nn::loss::cross_entropy(&logits, &classe_t)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars())
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
+        }
+        // ---- VERIFICADOR calibrado em RETIDOS (metade final) ----
+        let n_ret = n_dados / 2;
+        let (alvo_ret, clas_ret) = (
+            alvo_t.narrow(0, n_ret, n_dados - n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
+            classe_t.narrow(0, n_ret, n_dados - n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
+        );
+        let logits_ret = cabeca.fwd(&alvo_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut verif = verificador::VerificadorNcm::novo();
+        let (ece_antes, ece_depois) = verif.ajustar(&logits_ret, &clas_ret)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        // logits_fn: resposta (1, d_saida) → logits do backbone (1, K)
+        let logits_fn = |resp: &Tensor| -> candle_core::Result<Tensor> {
+            cabeca.fwd(resp)
+        };
+        // ---- treino cooperativo do motor (item a) ----
+        let cond_tr = cond_t.narrow(0, 0, n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let alvo_tr = alvo_t.narrow(0, 0, n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut hist = Vec::new();
+        for _ in 0..passos_treino {
+            let perda = motor.perda_treino(&cond_tr, &alvo_tr)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let pv = perda.to_scalar::<f32>()
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64;
+            hist.push(pv);
+            otim.passo(treino::grads_achatados(&perda, &motor.vars())
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
+        }
+        // ---- consultas RETIDAS em distribuição (ganho medido AQUI) ----
+        let n_consultas = 8usize;
+        let mut confs_base = Vec::new();
+        let mut confs_pens = Vec::new();
+        let mut iteracoes = Vec::new();
+        for qi in 0..n_consultas {
+            let consulta: Vec<f32> = conds[n_ret + qi].clone();
+            let consulta_t = Tensor::from_vec(consulta, (d_cond,), &dev)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1 + qi as u64);
+            let res = motor.raciocinar_ncm(&consulta_t, &verif, &logits_fn, &mut rng2)
+                .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+            // base: 1 tentativa isolada, mesma verificação NCM
+            let base = motor.tentativas[0]
+                .fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap()).unwrap();
+            let conf_base = verif.confianca_1d(&logits_fn(&base).unwrap()).unwrap();
+            confs_base.push(conf_base);
+            confs_pens.push(res.confianca);
+            iteracoes.push(res.iteracoes);
+        }
+        let media = |v: &[f64]| v.iter().sum::<f64>() / v.len().max(1) as f64;
+        let (conf_base_m, conf_pens_m) = (media(&confs_base), media(&confs_pens));
+        let iteracoes_media = iteracoes.iter().sum::<usize>() as f64 / iteracoes.len().max(1) as f64;
+        // ---- consulta OOD (reporte honesto — sem gate de ganho) ----
+        let consulta_ood: Vec<f32> = (0..d_cond).map(|j| 3.0 + (j as f32) * 0.1).collect();
+        let consulta_ood_t = Tensor::from_vec(consulta_ood, (d_cond,), &dev)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let mut rng3 = crate::rng::RngDeterministico::novo(semente + 99);
+        let res_ood = motor.raciocinar_ncm(&consulta_ood_t, &verif, &logits_fn, &mut rng3)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+        let base_ood = motor.tentativas[0]
+            .fwd(&consulta_ood_t.broadcast_as((1, d_cond)).unwrap()).unwrap();
+        let conf_base_ood = verif.confianca_1d(&logits_fn(&base_ood).unwrap()).unwrap();
+        let _ = mk;
+        let d_ = serde_json::json!({
+            "versao": "pensamento-0.6.0-ncm",
+            "n_tentativas": n_tentativas,
+            "perda_treino_inicial": hist.first(), "perda_treino_final": hist.last(),
+            "treino_aprendeu": hist.last().copied() < hist.first().map(|p| p * 0.5),
+            "ece_verificador_antes": ece_antes, "ece_verificador_depois": ece_depois,
+            "temperatura_calibrada": verif.temperatura,
+            "iteracoes_ciclo_d_media": iteracoes_media,
+            "confianca_base_1_rede": conf_base_m,
+            "confianca_pensamento": conf_pens_m,
+            "ganho_confianca": conf_pens_m - conf_base_m,
+            "confianca_ood_base": conf_base_ood,
+            "confianca_ood_pensamento": res_ood.confianca,
+            "iteracoes_ood": res_ood.iteracoes,
+            "orcamento_esgotado_ood": res_ood.telemetria.get("orcamento_esgotado").copied().unwrap_or(0.0),
+            "verificador": "ncm-calibrado (sem oraculo)",
+            "gates": {
+                "gate_verificador_sem_oraculo": true,
+                "gate_calibrado": ece_depois <= ece_antes,
+                "gate_ganho_nao_negativo": conf_pens_m >= conf_base_m - 1e-3,
+                "gate_terminou": iteracoes_media <= orcamento as f64,
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}
+
+
+
+/// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta
+/// o controlador com sinais sintéticos medidos e verifica cada regra.
+#[pyfunction]
+pub(crate) fn demo_autoajuste(semente: u64) -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let mut hub = telemetria::TelemetryHub::novo(None);
+        let mut rng = crate::rng::RngDeterministico::novo(semente);
+        let mut auto = controlador::AutoAjustePensamento::novo(0.5, 8, 2);
+        // A-1: confianças com mistura (60% altas ~0.85–0.95, 40% baixas ~0.25–0.40)
+        // ⇒ quantil 0.75 cai no grupo alto (posições 0.6–1.0) ≈ 0.85+0.375·0.1 ≈ 0.89
+        for _ in 0..200 {
+            let c = if rng.uniforme() < 0.6 { 0.85 + rng.uniforme() * 0.1 } else { 0.25 + rng.uniforme() * 0.15 };
+            auto.confs_retidas.push(c);
+        }
+        let tau = auto.ajustar_tau_c(0.25, &mut hub);
+        // A-3: acordos altos (0.88 ⇒ p̂ = (1+√0.76)/2 ≈ 0.936 ⇒ N = ln(20)/(2·0.436²) ≈ 7.9 ⇒ 8)
+        for _ in 0..32 {
+            auto.acordos.push(0.88);
+        }
+        let n_ajustado = auto.ajustar_n(0.05, 16, &mut hub);
+        // A-5: ganhos estáveis positivos (n=64 ⇒ 3º termo Bernstein ≈ 0.14 < 0.30) ⇒ gate sobe
+        for _ in 0..64 {
+            auto.ajustar_gate(0.30, 0.05, &mut hub);
+        }
+        let g_final = auto.gate_g;
+        // A-2: ganhos decaindo geometricamente
+        for k in 0..12 {
+            auto.ganhos_por_iteracao.push(0.25 * 0.6f64.powi(k));
+        }
+        let b_ajustado = auto.ajustar_orcamento(0.02, &mut hub);
+        // A-4: UCB1 com 3 braços
+        let mut u = controlador::Ucb1::novo(vec!["n1".into(), "n4_moe".into(), "n4".into()]);
+        for _ in 0..200 {
+            let braco = u.escolher();
+            let media = match braco { 0 => 0.35, 1 => 0.80, _ => 0.55 };
+            let r = (media + rng.normal(0.0, 0.06) as f64).clamp(0.0, 1.0);
+            u.registrar(braco, r);
+        }
+        let medias = u.medias();
+        let melhor = medias.iter().enumerate().max_by(|a, b| a.1.partial_cmp(b.1).unwrap()).map(|(i, _)| i).unwrap_or(0);
+        let d_ = serde_json::json!({
+            "versao": "autoajuste-0.6.0",
+            "tau_c_final": tau, "n_tentativas_final": n_ajustado,
+            "gate_final": g_final, "orcamento_b_final": b_ajustado,
+            "ajustes_auditados": hub.eventos_ajuste.len(),
+            "ucb1_medias": medias, "ucb1_melhor_braco": u.nomes[melhor],
+            "ucb1_arrependimento_medio": u.arrependimento_empirico() / 200.0,
+            "gates": {
+                "gate_a1_tau_quantil": (tau - 0.89).abs() < 0.08,
+                "gate_a3_n_reduzido": n_ajustado <= 8,
+                "gate_a5_gate_subiu": g_final > 0.0,
+                "gate_a2_b_finito": b_ajustado >= 1 && b_ajustado <= 16,
+                "gate_a4_ucb1_achou": u.nomes[melhor] == "n4_moe",
+            },
+        });
+        Ok(pythonize::pythonize(py, &d_)?.into())
+    })
+}

src/python/som.rs

@@ -0,0 +1,180 @@
+//! `python::som` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+
+/// Treina um 4D-SOM e devolve telemetria completa (EQ/TE/massa/cobertura).
+#[pyfunction]
+pub(crate) fn treinar_som4d(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = som4d::CfgSom4D::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                for (k, val) in o {
+                    match k.as_str() {
+                        "nx" => c.nx = val.as_u64().unwrap_or(4) as usize,
+                        "ny" => c.ny = val.as_u64().unwrap_or(4) as usize,
+                        "nz" => c.nz = val.as_u64().unwrap_or(4) as usize,
+                        "nt" => c.nt = val.as_u64().unwrap_or(4) as usize,
+                        "epocas" => c.epocas = val.as_u64().unwrap_or(50) as usize,
+                        "sigma0" => c.sigma0 = val.as_f64().unwrap_or(2.0),
+                        "sigma1" => c.sigma1 = val.as_f64().unwrap_or(0.5),
+                        "eta0" => c.eta0 = val.as_f64().unwrap_or(0.5),
+                        "eta1" => c.eta1 = val.as_f64().unwrap_or(0.05),
+                        "semente" => c.semente = val.as_u64().unwrap_or(42),
+                        "espalhada" => {
+                            c.inicializacao = if val.as_bool().unwrap_or(false) {
+                                som4d::Inicializacao4D::Espalhada
+                            } else {
+                                som4d::Inicializacao4D::Dados
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+    let som = som4d::treinar_som4d(&t, &c, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "versao": som4d::versao(),
+        "celulas": som.n_celulas(),
+        "grade": [som.nx, som.ny, som.nz, som.nt],
+        "eq_inicial": som.eq_inicial,
+        "eq_final": som.eq_final,
+        "te_final": som.te_final,
+        "historico_eq_te": som.historia,
+        "massa_soma": som.massa.iter().sum::<f64>(),
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Treina um GNG e devolve telemetria (vértices, arestas, componentes, EQ).
+#[pyfunction]
+pub(crate) fn treinar_gng(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = som4d::CfgGng::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                for (k, val) in o {
+                    match k.as_str() {
+                        "passos" => c.passos = val.as_u64().unwrap_or(4000) as usize,
+                        "max_vertices" => c.max_vertices = val.as_u64().unwrap_or(60) as usize,
+                        "lambda" => c.lambda = val.as_u64().unwrap_or(50) as usize,
+                        "eps_b" => c.eps_b = val.as_f64().unwrap_or(0.05),
+                        "eps_n" => c.eps_n = val.as_f64().unwrap_or(0.006),
+                        "idade_max" => c.idade_max = val.as_u64().unwrap_or(50) as u32,
+                        "semente" => c.semente = val.as_u64().unwrap_or(42),
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+    let g = som4d::treinar_gng(&t, &c)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let d = serde_json::json!({
+        "versao": som4d::versao(),
+        "vertices": g.vertices.len(),
+        "arestas": g.arestas.len(),
+        "componentes_conexas": g.n_componentes_conexas(),
+        "insercoes": g.insercoes,
+        "eq_medio": g.eq_medio,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Treina um H-SOM e devolve a decomposição hierárquica (Teo H-1).
+#[pyfunction]
+pub(crate) fn treinar_hsom(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut c = som4d::CfgHSom::default();
+    if let Some(js) = &cfg {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(js) {
+            if let Some(o) = v.as_object() {
+                if let Some(x) = o.get("celulas_finas") {
+                    c.celulas_finas = x.as_u64().unwrap_or(9) as usize;
+                }
+                if let Some(x) = o.get("epocas_finas") {
+                    c.epocas_finas = x.as_u64().unwrap_or(20) as usize;
+                }
+            }
+        }
+    }
+    let h = som4d::treinar_hsom(&t, &c, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let cota = h.eq_grosso + 2.0 * h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt();
+    let d = serde_json::json!({
+        "versao": som4d::versao(),
+        "eq_hierarquico": h.eq_hierarquico,
+        "eq_grosso": h.eq_grosso,
+        "r_fino": h.r_fino,
+        "cota_teo_h1": cota,
+        "cota_respeitada": h.eq_hierarquico <= cota + 1e-9,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Demo T-SOM: streaming com deriva controlada — rastreio (Teo T-1).
+#[pyfunction]
+pub(crate) fn demo_tsom(py: Python, dados_iniciais: Vec<Vec<f64>>, janela: Vec<Vec<f64>>, passos: usize, gamma: f64) -> PyResult<PyObject> {
+    let dev = candle_core::Device::Cpu;
+    let t0 = tensor_de_2d(dados_iniciais, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let cfg = som4d::CfgTSom {
+        cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() },
+        gamma,
+        janela: janela.len(),
+    };
+    let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev)
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
+    let mut historico = Vec::new();
+    for _ in 0..passos {
+        let eq = ts.passo(&janela);
+        historico.push(eq);
+    }
+    let d = serde_json::json!({
+        "versao": som4d::versao(),
+        "gamma": gamma,
+        "eq_temporal_historico": historico,
+        "t_passos": ts.t,
+    });
+    Ok(pythonize::pythonize(py, &d)?.into())
+}
+
+
+/// Demo/gate do auto-ajuste SOM com tetos (S-AB/S-SL).
+#[pyfunction]
+pub(crate) fn demo_autoajuste_som(py: Python) -> PyResult<PyObject> {
+    let mut a = controlador::AutoAjusteSom::novo(0.5, 1.0);
+    let (al_qe, _) = a.passo(1.0, 0.0, 0.0);
+    let (al_cross, sg_cross) = a.passo(0.0, 0.0, 1.0);
+    let (al_max, sg_max) = a.passo(1.0, 1.0, 1.0);
+    let mut parou_5chunks = false;
+    for _ in 0..5 {
+        parou_5chunks = a.avaliar_parada(0.95, 0.1, 0.1, false, true, false, false);
+    }
+    let d_ = serde_json::json!({
+        "versao": "som-autoadjust-0.7.0",
+        "alfa_qe_alta": al_qe, "alfa_crossing": al_cross, "sigma_crossing": sg_cross,
+        "alfa_max": al_max, "sigma_max": sg_max,
+        "parou_5chunks": parou_5chunks,
+        "motivo": a.motivo_parada,
+        "gates": {
+            "tetos_ok": al_max <= 1.0 + 1e-9 && sg_max <= 2.0 + 1e-9,
+            "piso_ok": al_cross >= 0.5 - 1e-9,
+            "qe_sobe": al_qe > 0.5,
+            "stop_dispara": parou_5chunks,
+        },
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}

src/python/treino_fases.rs

@@ -0,0 +1,228 @@
+//! `python::treino_fases` — extraído do monólito na v0.10.0
+//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
+
+use super::*;
+
+use super::nucleo::ConfigPy;
+
+
+/// Treina a fase A (tokenizador). Devolve dict com resumo + telemetria.
+#[pyfunction]
+#[pyo3(signature = (cfg, sequencias, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None))]
+pub(crate) fn treinar_fase_a(
+    cfg: &ConfigPy,
+    sequencias: Vec<Vec<u32>>,
+    caminho_telemetria: Option<String>,
+    caminho_checkpoint: Option<String>,
+    callback: Option<Bound<'_, PyAny>>,
+    teto_seg: Option<f64>,
+) -> PyResult<PyObject> {
+    let cb = callback_treino_de_py(callback);
+    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!({
+            "resumo": {
+                "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
+                "perda_final": resumo.perda_final, "acc_recon": resumo.acc_recon,
+                "delta_ort_max": resumo.delta_ort_max,
+                "perplexidade_codebook": resumo.perplexidade_codebook,
+                "monotonia_prefixo": resumo.monotonia_prefixo,
+                "escore_aprendizado": resumo.escore_aprendizado,
+            },
+            "telemetria": hub.dump(),
+        });
+        Ok(pythonize::pythonize(py, &dados)?.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))]
+pub(crate) fn treinar_fase_b(
+    cfg: &ConfigPy,
+    sequencias: Vec<Vec<u32>>,
+    caminho_tokenizador: &str,
+    caminho_telemetria: Option<String>,
+    caminho_checkpoint: Option<String>,
+    callback: Option<Bound<'_, PyAny>>,
+    teto_seg: Option<f64>,
+) -> PyResult<PyObject> {
+    let cb = callback_treino_de_py(callback);
+    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!({
+            "resumo": {
+                "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
+                "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
+                "escore_aprendizado": resumo.escore_aprendizado,
+            },
+            "telemetria": hub.dump(),
+        });
+        Ok(pythonize::pythonize(py, &dados)?.into())
+    })
+}
+
+
+pub(crate) 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(())
+}
+
+
+/// Gera amostras com NFE = L e devolve textos decodificados (modo conceitos).
+#[pyfunction]
+#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_amostras=2, parar_no_nivel=None, greedy=true))]
+pub(crate) fn gerar_amostras(
+    cfg: &ConfigPy,
+    caminho_tokenizador: &str,
+    caminho_gerador: &str,
+    n_amostras: usize,
+    parar_no_nivel: Option<usize>,
+    greedy: bool,
+) -> 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,
+            "niveis_usados": nivel_final, "ids_tokens": textos_ids,
+            "temperaturas": amostrador.temperaturas,
+        });
+        Ok(pythonize::pythonize(py, &d)?.into())
+    })
+}
+
+
+fn decodificar_textos(tok: &tokenizador::TokenizadorConceitos, zhat: Option<&candle_core::Tensor>, b: 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}"))
+}
+
+
+pub(crate) 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(())
+}
+
+
+/// **FASE C — treino conjunto Pensamento↔backbone** (dados reais).
+#[pyfunction]
+pub(crate) fn treinar_fase_c(
+    cfg: &ConfigPy,
+    sequencias: Vec<Vec<u32>>,
+    caminho_tokenizador: &str,
+    passos: usize,
+    caminho_gerador: Option<String>,
+    caminho_telemetria: Option<String>,
+    callback: Option<Bound<'_, PyAny>>,
+    teto_seg: Option<f64>,
+) -> PyResult<PyObject> {
+    let cb = callback_treino_de_py(callback);
+    let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria);
+    let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx);
+    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_c(&cfg.cfg, &tok, &dados, &mut hub, &cb, teto_seg, passos, caminho_gerador.as_deref())
+        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase C: {e}")))?;
+    Python::with_gil(|py| {
+        let dados = serde_json::json!({
+            "resumo": {
+                "passos": resumo.passos,
+                "ce_inicial": resumo.ce_inicial,
+                "ce_final": resumo.ce_final,
+                "ce_gatilhada_sem_correcao": resumo.ce_gatilhada_sem_correcao,
+                "ce_gatilhada_com_correcao": resumo.ce_gatilhada_com_correcao,
+                "confianca_media_inicial": resumo.confianca_media_inicial,
+                "confianca_media_final": resumo.confianca_media_final,
+                "confianca_pos_correcao": resumo.confianca_pos_correcao,
+                "taxa_gatilho": resumo.taxa_gatilho,
+                "ece_antes": resumo.ece_antes,
+                "ece_depois": resumo.ece_depois,
+                "temperatura_calibrada": resumo.temperatura_calibrada,
+                "tau_c": resumo.tau_c,
+                "taxa_conflito_pcgrad": resumo.taxa_conflito_pcgrad,
+                "decaimento_delta": resumo.decaimento_delta,
+                "acordos_medios": resumo.acordos_medios,
+                "escore_aprendizado": resumo.escore_aprendizado,
+                "rodadas_acoplador": resumo.rodadas_acoplador,
+                "timeouts_acoplador": resumo.timeouts_acoplador,
+                "maior_sobreposicao_us": resumo.maior_sobreposicao_us,
+            },
+            "painel_v060": hub.painel_v060(),
+            "telemetria": hub.dump(),
+        });
+        Ok(pythonize::pythonize(py, &dados)?.into())
+    })
+}