KHTST v23 — auditoria independente integrada: correções válidas aplicadas com provas (doc 35, Teos 35.1-35.14) e claims refutadas documentadas (doc 35 §11). PCGrad PROJETA (fator=dot/n2, g=gm+(ga-fator*gm) — 0 violações I1/I2/I3 em 100.083 pares; o antigo reescalava e violava a não-piora em 25,3%); RoPE com OFFSET de cache (desloc absoluto propagado — score de decode varia com t; era constante 2,756113); tronco 5:1 REAL (n_camadas=6, validação do campo que constrói o tronco; L=3 reprovado); checkpoint ATÔMICO (tmp+fsync+replace+fsync-dir, hash obrigatória, antigos por último); IPC lê a capacidade do HEADER (divergência=ValueError, fallback+Cython); dedup texto+entrada+saida+midia (29,5%->8,7%) + NFC; filtro P9 sem vazamento eval->treino (9 benchmarks pulados, hendrycks em train, Fable train); acumulação sem viés na retomada; hub com buffer + fechar(); mecanismo árvore VIVO (A-23, y+0*y_a=y bit a bit); erratas doc 26/28 (Sigma 1/tau diverge, T_tau=168,76, dH/dT=Var/T3, h^2/12 densidade contínua); auditoria HARDENED em auditoria_independente/ (4 scripts com assert+exit, 4/4 verdes); corpus real fresco 1612 registros com P9 (MATH-500 PULADA); A/B pareado 48 passos + grad peso_arvore vivo medido; suíte v23 35/35, regressão v1-v22 zero, verificar_tudo 49✓

.gitattributes

@@ -52,3 +52,4 @@ src/khtst/ipc/khtst_ipc.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merg
 graficos/v19/v19_evidencias.png filter=lfs diff=lfs merge=lfs -text
 src/khtst/acelerado/mamba3hot.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 graficos/v22/v22_evidencias.png filter=lfs diff=lfs merge=lfs -text
+graficos/v23/v23_evidencias.png filter=lfs diff=lfs merge=lfs -text

PLANO_KHMAMBAJEPA.md

@@ -244,6 +244,27 @@ honestidade.
   atualizados TODA versão; redundâncias removidas.
 ---
 
+## 6b'''. Verificação v23 (resumo executável)
+
+- Suíte v23 NOVA: **35/35 verdes** (doc 35 citado: PCGrad I1/I2/I3 na
+  implementação REAL; RoPE bit a bit + translação + decode variável;
+  checkpoint atômico a–d; IPC divergência (fallback+Cython); dedup/NFC;
+  5:1 no campo real; acumulação sem viés; buffer de telemetria; erratas
+  E-01..E-04).
+- REGRESSÃO v1–v22 TODA VERDE (25/36/✓/37/32/48/44/21/✓/✓/28/27/40/—/✓/56
+  /46/34/38/40/35) + verificar_tudo **49✓/0✗**; 2 falhas de regressão
+  PRÉ-EXISTENTES corrigidas (v21 §5: produtores movidos ao mixin v22;
+  v1/v2: configs de teste fora do contrato 5:1).
+- Auditoria independente (2026-10-17) INTEGRADA: 14 correções válidas
+  aplicadas com provas (doc 35, Teos 35.1–35.14); 5 claims refutadas
+  documentadas; scripts hardened em `auditoria_independente/` (4/4 verdes
+  com assert + exit code).
+- Corpus real FRESCO com filtro P9 (`scripts/36_teste_v23.py --coletar`):
+  1612 registros (3 tarefas), MATH-500 PULADA (benchmark fora do treino),
+  hendrycks em train; A/B pareado 48 passos (uma variável: semântica v≤22
+  ablation vs v23) + gradiente do peso_arvore VIVO medido no treino real;
+  figuras em `graficos/v23/` (script 37).
+
 ## 6b''. Verificação v22 (resumo executável)
 
 - Suíte v22 NOVA: **46/46 verdes** (Teos 34.1–34.11 citados: neutralidade

README.md

@@ -100,6 +100,66 @@ gradiente**. Provas em `docs/matematica/27`.
 > --teto_horas 9.0 --continuar_ate_horas 8.0 --estados_hf`).
 
 
+## O que há de novo no v23 — AUDITORIA INDEPENDENTE INTEGRADA: PCGrad PROJETA (e não reescala) · RoPE COM OFFSET DE CACHE · TRONCO 5:1 REAL (n_camadas=6) · CHECKPOINT ATÔMICO · IPC LÊ O HEADER · SEM VAZAMENTO EVAL→TREINO · ERRATAS DE MATEMÁTICA (provas em `docs/matematica/35`, auditoria hardened em `auditoria_independente/`)
+
+Uma auditoria independente (2026-10-17, espelho v22) auditou o projeto com
+scripts numpy-puros; o v23 **re-verificou cada claim contra o código real**
+(5 claims refutadas — §11 do doc 35), aplicou as correções válidas com PROVAS
+(Teos 35.1–35.14) e transformou os scripts da auditoria em rede de regressão
+com `assert` + exit code:
+
+- **PCGrad correto (A-01, Teo 35.1)** — `fator = dot/n2` com
+  `g = gm + (ga − fator·gm)` (Yu et al., 2020, Alg. 2): projeta g_aux no
+  complemento ortogonal. O código antigo REESCALAVA (25,3% dos conflitos
+  violavam a não-piora; pior caso 1,73×) e a "correção" intermediária do
+  auditor DOBRAVA o conflito (⟨g_aux′,g_main⟩ = 2·dot). Medido: 0 violações
+  de I1/I2/I3 na implementação real (398 pares torch + 100.083 numpy).
+- **RoPE com offset de cache (A-03, Teo 35.8)** — `aplicar_rope(q,k,desloc)`
+  com posição absoluta propagada por gerar/SessaoKHTST: o score de decode
+  VARIA com t (era CONSTANTE 2,756113 para t=1,2,3,10 — o modelo não
+  distinguia posição 1 de 100). Prefill desloc=0 é v≤22 bit a bit.
+- **Tronco 5:1 de verdade (A-04, Teo 35.5)** — `modelo.n_camadas = 6`
+  (5 Mamba + 1 NoPE exato) e a validação checa o campo que CONSTRÓI o tronco
+  (antes checava config morta; L=3 entregue tinha ZERO NoPE — reprovado).
+- **Checkpoint atômico (I-03, Teo 35.3)** — tmp + fsync + os.replace +
+  fsync do diretório; hash SHA-256 OBRIGATÓRIA (meta ausente ⟹ rejeitado);
+  antigos apagados SÓ depois do novo par completo (crash ⟹ estado anterior
+  carregável).
+- **IPC lê a capacidade do header (I-01, Teo 35.4)** — anexar com size
+  divergente do produtor levanta ValueError imediato (fallback E Cython;
+  antes: 0 frames ou corrupção CRC32 em silêncio). Header 256B compatível.
+- **Dedup + NFC (T-02/T-08, Teos 35.6/35.7)** — chave
+  texto+entrada+saída+mídia única nos 3 consumidores (descarte real cai de
+  29,5% para 8,7%); NFC idempotente na ingestão (BPE treinado em NFC; NFD
+  custava 1,198× tokens).
+- **Sem vazamento eval→treino (T-03, Teo 35.14)** — 9 fontes de benchmark
+  (MMMU/MMMU-Pro/OCRBench/COCO-Caption/weikaih-eval/ASR×3/MATH-500 — todas
+  só-validation/test, verificado no datasets-server) marcadas
+  `papel:"avaliacao"` e PULADAS na coleta de treino; hendrycks migrou para o
+  split train real; válvula explícita `KHTST_INCLUIR_AVALIACAO=1`.
+- **A-23 (Teo 35.13)** — o mecanismo ÁRVORE estava INERTE desde a v8
+  (curto-circuito `peso≠0` matava o gradiente do peso nascido 0): em treino
+  y_a é sempre computado e `y + 0·y_a = y` bit a bit (nascimento neutro
+  preservado); gradiente vivo medido no treino real (−14,16 no passo 48).
+- **Robustez (A-05/A-19/A-22)** — acumulação de gradiente sem viés na
+  retomada (divide pelo tamanho REAL do grupo); telemetria com buffer
+  (64 linhas/2 s + `fechar()`; era ~20 open/close por passo); `avaliar()`
+  vazio agora ALERTA (não some em silêncio).
+- **Erratas de matemática (E-01/E-02/E-03/E-04)** — Σ1/τ DIVERGE (removido
+  "< ∞" do doc 26); T_τ = 600/ln 35 ≈ 168,76 (não 308,1 — e o τ(600)=0,300
+  medido confirma); dH/dT = Var_p(z)/T³ (não /T²); h²/12 exige densidade
+  contínua (átomos na grade ⟹ 0).
+- **Provas do que a auditoria alegou e NÃO sobreviveu (doc 35 §11)** —
+  E-05 (L_bal float), I-05 (peso_moe órfão), A-21 (conv sem guarda) e o
+  número 0,1502 do E-04: refutados contra o código v22/23 com arquivo:linha.
+- **Auditoria hardened (P15)** — os 4 scripts numpy-puros agora em
+  `auditoria_independente/` com assert + exit code (antes só printavam);
+  suíte v23 nova: **35/35 verdes**; regressão v1–v22 toda verde +
+  `verificar_tudo` 49✓/0✗; A/B pareado real 48 passos (corpus FRESCO de
+  1612 registros reais coletado com o filtro P9 — MATH-500 PULADA,
+  leitura honesta no doc 35 §14).
+
+
 ## O que há de novo no v22 — FECHAMENTO 18/18 DA TABELA v17: OS 10 PRODUTORES RESTANTES COM MEDIÇÕES REAIS · APLIERS NOVOS (ABMO/CIAR/CRESCEMENTO/PESO_SOM) · TREINO REAL PAREADO (provas em `docs/matematica/34`, memória em `PLANO_KHMAMBAJEPA.md`)
 
 - **Estado do otimizador — 4 sinais (doc 34 §2, Teos 34.1–34.5)**:

RELATORIO_KHTST.md

@@ -1269,3 +1269,49 @@ expansão/poda SOM zeradas na fase A (honesto); custo dos acumuladores
 não decompõe as causas dos ~2% de s/passo; o produtor τ_qk da v21 NÃO
 estava morto (a v22 generaliza o filtro e aumenta a frescura — não é
 correção de bug).
+
+## 22. v23 — Auditoria independente integrada: correções válidas aplicadas com provas, claims refutadas documentadas, corpus sem vazamento
+
+**Fonte:** auditoria externa de 2026-10-17 (7 arquivos: PLANO_MELHORIAS_KHTST.md,
+EXECUTAVEL.md, CORRECAO_A01_PCGrad.md, modelo_ram.py, verif_pcgrad_invariantes.py,
+verif_pcgrad_rope.py, verif_cinza_lipschitz.py) sobre o espelho v22. O v23
+re-verificou CADA claim contra o código real antes de agir — 5 claims caíram
+(§11 do doc 35), o resto foi corrigido com provas (doc 35, Teos 35.1–35.14).
+
+**Correções aplicadas (arquivo:linha no commit):**
+| Achado | Correção v23 | Prova |
+|---|---|---|
+| A-01 PCGrad reescala | `fator=dot/n2`, `g=gm+(ga−fator·gm)` (cirurgia_grad.py) | Teo 35.1; suíte v23 §1: 0 violações I1/I2/I3 (398 pares torch; 100.083 numpy) |
+| A-03 RoPE sem offset | `desloc` em aplicar_rope + propagação (modelo.gerar, SessaoKHTST, MoA, blocos) | Teo 35.8; suíte v23 §2: prefill bit a bit, translação exata, decode VARIA com t |
+| A-04 tronco 3 camadas (0 NoPE) | `n_camadas=6` + validação do campo REAL (validacao.py) | Teo 35.5; suíte v23 §6: L=3 reprovado, L=6 ⟹ 5:1 |
+| I-03 checkpoint não-atômico | tmp+fsync+os.replace+fsync(dir); hash obrigatória; apagar por último | Teo 35.3; suíte v23 §3 (a–d) |
+| I-01 IPC header nunca lido | anexar valida capacidade (fallback + Cython; .so recompilado) | Teo 35.4; suíte v23 §4 |
+| T-02 dedup 29,5% | `_chave_dedup` (texto+entrada+saída+mídia) única nos 3 consumidores | Teo 35.7; descarte 29,5%→8,7% |
+| T-03/T-01 splits de avaliação + Fable "lite" | `papel:"avaliacao"` em 9 fontes benchmark (probe datasets-server), hendrycks→train, Fable→train; filtro P9 com evento PULADA | Teo 35.14; coleta real: MATH-500 PULADA, 1612 registros |
+| T-08 NFD | NFC na ingestão (idempotente — Teo 35.6) | suíte v23 §5 |
+| A-05 acumulação com viés na retomada | divide pelo tamanho REAL do grupo (`_n_acc_atual`) | Teo 35.9; suíte v23 §7 |
+| A-19 hub open/close por linha | buffer 64 linhas/2 s + `fechar()` no scripts/04 | Teo 35.10; suíte v23 §8 |
+| A-22 avaliar() vazio silencioso | alerta explícito no hub/stdout | — |
+| A-23 árvore INERTE desde a v8 | em treino y_a sempre computado; `y+0·y_a = y` bit a bit | Teo 35.13; grad medido no treino real (−14,16) |
+| P16 docstring Lipschitz falso | vit_lra.py cita o bound real do Teo 27.7(ii-a) | verif_cinza_lipschitz.py (razão ≤1; 2δ violado 45× no pixel escuro) |
+| E-01/E-02 (doc 26) | erratas: Σ1/τ DIVERGE; T_τ=600/ln 35≈168,76 (τ(600)=0,300 confirma) | Teo 35.12; suíte v23 §9a-b |
+| E-03/E-04 (doc 28) | erratas: dH/dT=Var/T³ (FD 0,985); h²/12 exige densidade contínua | Teo 35.11; suíte v23 §9c-d |
+| P15 scripts sem assert | auditoria hardened em `auditoria_independente/` (assert + exit code, 4/4 verdes) | — |
+| P12 suíte torch-dependente | tests/conftest.py: coleta vira skip com mensagem clara sem torch | — |
+
+**Claims da auditoria REFUTADAS contra o código real (não aplicadas):**
+E-05 (`perda_lb` é tensor com gradiente — treinador.py:606), I-05
+(`razao_moe_ce` produzido no mixin v22 — tabela 18/18 real), A-21 (único
+call site da conv profunda é guardado por `_hot is not None` — kernel.py:199),
+número 0,1502 do E-04 (internamente inconsistente: E[Δ²] ≤ max|Δ|² = 6,8e-4;
+o ponto qualitativo entrou na errata com o contra-exemplo EXATO on-grid).
+
+**Teste real (scripts/36_teste_v23.py + 37_graficos_v23.py):** corpus FRESCO
+1612 registros (3 tarefas, P9 auditado — MATH-500 PULADA, hendrycks em train);
+A/B pareado exato 48 passos com UMA variável (semântica v≤22 ablation via
+monkeypatch vs v23 limpo): baseline 9,671→7,974 (1,213×) vs v23 9,719→8,497
+(1,144×), ΔCE +0,134 — leitura honesta idêntica ao precedente v22: os fixes
+são de CORREÇÃO com invariantes provados; corrida curta não mede o valor
+(que é estrutural: não-piora garantida, posição relativa restaurada, árvore
+viva, treino sem vazamento). Regressão: 21 suítes verdes (v1–v23) +
+verificar_tudo 49✓/0✗. Gráfico: graficos/v23/v23_evidencias.png.

auditoria_independente/CORRECAO_A01_PCGrad.md

@@ -0,0 +1,86 @@
+# CORREÇÃO A-01 — PCGrad projeta o gradiente ERRADO
+
+> **APLICADA NO v23 (2026-10-18).** O patch abaixo está em produção em
+> `src/khtst/treino/cirurgia_grad.py` (`fator = dot / n2_main` com
+> `g = gm + (ga - fator * gm)`) — provas no doc 35 §1 (Teo 35.1: invariantes
+> I1/I2/I3 com 0 violações em 100.083 pares numpy + 398 pares torch na
+> implementação REAL), regressão em `auditoria_independente/verif_pcgrad_
+> invariantes.py` e `tests/test_khtst_v23.py` §1. O teste de aceite esperado
+> no fim deste arquivo é agora o comportamento observado.
+#
+# Arquivo original: src/khtst/treino/cirurgia_grad.py
+# Linhas originais: 90-101 (bloco `fator` e composição `g`)
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# O PROBLEMA (o bug é real; a correção anterior dos agentes tinha sinal trocado)
+# ─────────────────────────────────────────────────────────────────────────────
+# Código original (treino/cirurgia_grad.py:90-101):
+#     projetado = dot < 0.0 and n2_main > eps
+#     fator = -dot / n2_main if projetado else 0.0
+#     ...
+#     g = gm + (fator * ga if projetado else ga)
+#
+# Isso NÃO é projeção: é uma REESCALA de g_aux por um escalar. A garantia do
+# PCGrad (Yu et al., 2020) não é atendida.
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# A CORREÇÃO
+# ─────────────────────────────────────────────────────────────────────────────
+# PCGrad Alg. 2 (2 tarefas), com dot = <g_main, g_aux> e n2 = ||g_main||²:
+#     se dot < 0:   g_aux' = g_aux - (dot / n2) * g_main
+#     total        = g_main + g_aux'
+#
+# ATENÇÃO AO SINAL: o multiplicador de g_main é (dot / n2) — que é NEGATIVO
+# quando há conflito. A variante `fator = -dot/n2` combinada com
+# `g = gm + (ga - fator*gm)` (correção anterior dos agentes) computa
+# g_aux' = g_aux + (dot/n2)*g_main, ou seja:
+#     <g_aux', g_main> = dot + dot = 2*dot < 0
+# → o conflito é DOBRADO, não removido. Medido: 100.083/100.083 pares
+# violam a ortogonalidade (ver /workspace/khtst_audit/minha_verificacao/
+# verif_pcgrad_invariantes.py).
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# INVARIANTES QUE A VERSÃO CORRETA SATISFAZ (com prova)
+# ─────────────────────────────────────────────────────────────────────────────
+# I1  <g_aux', g_main> = <g_aux,g_main> - (dot/n2)*<g_main,g_main>
+#                       = dot - dot = 0                                  ✔
+# I2  ||g_aux'||² = ||g_aux||² - (dot/n2)²·||g_main||²
+#                       = ||g_aux||² - dot²/n2  ≤  ||g_aux||²            ✔ (contração)
+# I3  <g_total, g_main> = <g_main,g_main> + <g_aux',g_main> = n2 ≥ 0   ✔
+#     <g_total, g_aux'> = <g_main,g_aux'> + ||g_aux'||² = ||g_aux'||² ≥ 0 ✔
+#
+# Custo: uma subtração vetorial por parâmetro — O(P), desprezível ao lado
+# do backward. Nenhuma mudança de hiperparâmetro.
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# PATCH (aplicar sobre as linhas 90-101 do arquivo original)
+# ─────────────────────────────────────────────────────────────────────────────
+#      projetado = dot < 0.0 and n2_main > eps
+#      with torch.no_grad():
+# -        fator = -dot / n2_main if projetado else 0.0
+# +        # Yu et al. (2020), Alg. 2: o multiplicador de g_main e (dot/n2),
+# +        # que e NEGATIVO quando ha conflito. Usar -dot/n2 aqui dobra o
+# +        # conflito (<g_aux', g_main> = 2*dot < 0) em vez de remove-lo.
+# +        fator = dot / n2_main if projetado else 0.0
+#      for p, gm, ga in zip(params, g_main, g_aux):
+#          if gm is None and ga is None:
+#              continue
+#          if gm is None:
+#              g = ga
+#          elif ga is None:
+#              g = gm
+#          else:
+# -            g = gm + (fator * ga if projetado else ga)
+# +            # projeta g_aux no complemento ortogonal de g_main
+# +            g = gm + (ga - fator * gm if projetado else ga)
+#          p.grad = g.detach() if p.grad is None else p.grad + g.detach()
+#      return {"pcgrad/dot": dot, "pcgrad/projetado": float(projetado),
+#              "pcgrad/fator": fator}
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# TESTE DE ACEITE (sem torch: substitua torch.no_grad por contexto nulo)
+# ─────────────────────────────────────────────────────────────────────────────
+#   python3 /workspace/khtst_audit/minha_verificacao/verif_pcgrad_invariantes.py
+#   esperado:  variante 'correto'  viola I1=0, I2=0, I3=0
+#              variante 'atual'    viola I1 em ~100% dos pares
+#              variante 'agente'   viola I1 em 100% dos pares (pior que o original)

auditoria_independente/EXECUTAVEL.md

@@ -0,0 +1,281 @@
+# EXECUTAVEL — como rodar a auditoria e as correções do KHTST
+
+> **ATUALIZAÇÃO v23 (2026-10-18).** As correções P1–P6, P9–P11, P15, P16 e
+> A-05/A-19/A-22/A-23 ESTÃO APLICADAS no repositório oficial (com provas no
+> doc 35). As seções abaixo permanecem para (a) reproduzir a auditoria em
+> um ambiente limpo e (b) re-verificar tudo do zero. O caminho de re-execução
+> ATUAL é: clonar o repo oficial e rodar
+> `python3 auditoria_independente/verif_pcgrad_invariantes.py` (os 4 scripts
+> hardened, com assert + exit code), `python3 tests/test_khtst_v23.py`
+> (suíte 35/35, exige torch) e as demais suítes v1–v22 — os "correcoes/" do
+> auditório NÃO são mais necessários (e a correção do PCGrad do auditor
+> tinha sinal trocado — ver §6 deste guia, mantido como registro histórico).
+
+Guia ponta a ponta, sem contexto prévio. Todo comando foi executado neste ambiente
+(Python 3.11.2, 2 cores, ~3 GB RAM, sem GPU, sem torch).
+
+---
+
+## 0. Ambiente
+
+```bash
+# pip: o índice padrão do sandbox está vazio — use o PyPI explícito
+pip install --break-system-packages --index-url https://pypi.org/simple \
+    pyarrow tokenizers "datasets>=3.0" requests
+
+# opcional: pyyaml para inspecionar o plano
+pip install --break-system-packages --index-url https://pypi.org/simple pyyaml
+```
+
+> **Não instale torch aqui.** O sandbox tem 3 GB de RAM e nenhum torch é necessário
+> para nenhuma das verificações: toda a matemática é reimplementada em numpy puro.
+
+---
+
+## 1. Espelho do repositório (nunca modificar)
+
+```bash
+cd /workspace/khtst_audit
+GIT_SSL_NO_VERIFY=1 GIT_LFS_SKIP_SMUDGE=1 git clone --depth 1 \
+  https://huggingface.co/PowerMachine/khtst-multimodal-ptbr repo
+
+# integridade: tem que sair VAZIO
+git -C repo status --porcelain
+# (se aparecer __pycache__, adicione ao .git/info/exclude:
+#  printf '__pycache__/\n*.pyc\n' >> repo/.git/info/exclude )
+```
+
+As extensões `.so` do repositório são **cpython-312 x86-64**: não importam em Python
+3.11. Todo caminho testado adiante é o Python puro (fallback), e isso é proposital —
+é assim que se descobre módulo sem fallback.
+
+---
+
+## 2. Reproduzir as verificações dos agentes
+
+```bash
+cd /workspace/khtst_audit/verificacao
+
+# scripts de prova matemática (v01..v09)
+for f in v0*.py; do
+  b=$(basename "$f" .py)
+  timeout 300 python3 "$f" > "/tmp/RUN_$b.txt" 2>&1
+  echo "$b rc=$? $(diff -q "out_$b.txt" "/tmp/RUN_$b.txt" >/dev/null && echo IDENTICO || echo DIVERGE)"
+done
+```
+
+Resultado esperado hoje (numpy 2.4.6):
+
+```
+v01 rc=0 DIVERGE     # só os últimos dígitos de float
+v02 rc=0 DIVERGE
+v03 rc=0 IDENTICO
+v04 rc=0 IDENTICO
+v05 rc=1 DIVERGE     # CRASH: numpy.AxisError na linha 109  <-- achado meu
+v06 rc=0 DIVERGE
+v07 rc=0 DIVERGE
+v08 rc=1 DIVERGE     # CRASH: np.trapz removido no numpy>=2  <-- achado meu
+v09 rc=0 IDENTICO
+```
+
+**Dois scripts quebram.** Correção (P15):
+
+```bash
+# v08: numpy>=2 renomeou trapz -> trapezoid
+sed -i 's/np\.trapz/np.trapezoid/g' v08_docs_00_25.py
+# v05: ent_rel espera um VETOR de logits, mas recebe um escalar
+#      (linha 109: e = np.exp(lv - lv)  ->  e = np.array([0.0,0.0,0.0]))
+```
+
+---
+
+## 3. Minhas verificações (as que sustentam o plano)
+
+```bash
+cd /workspace/khtst_audit/minha_verificacao
+
+python3 verif_pcgrad_invariantes.py   # PCGrad: 3 variantes x 3 invariantes
+python3 verif_pcgrad_rope.py          # PCGrad: garantia "nenhuma tarefa piora" + RoPE
+python3 verif_cinza_lipschitz.py      # Lipschitz do detector de cinza
+python3 modelo_ram.py                 # modelo de RAM, c* do checkpointing, tabela por RAM
+```
+
+Saídas esperadas (trechos que decidem o plano):
+
+```
+variante      pares   viola I1   viola I2   viola I3
+atual       100,083    100,070          0     49,948
+agente      100,083    100,083    100,081        791     <-- a correção do agente DOBRA o conflito
+correto     100,083          0          0          0
+
+t=1   <q_rot,k_rot> codigo=+2.756113  com offset=+2.889119  DIVERGE
+t=10  <q_rot,k_rot> codigo=+2.756113  com offset=+1.970870  DIVERGE
+      (o score é CONSTANTE: o modelo não distingue t=1 de t=10)
+
+max (derivada real)/(bound do doc) = 0.999989  -> DOMINADO (teorema VÁLIDO)
+cinza 0.01 + delta 0.001: |Δs| = 0.090090 | 2δ = 0.002000 -> VIOLADO
+      (o que é falso é o DOCSTRING do código, não o teorema)
+```
+
+---
+
+## 4. Reproduzir a coleta de dados real
+
+```bash
+cd /workspace/khtst_audit/verificacao
+timeout 1500 python3 t4_p3b_corpus_real.py     # baixa e coleta das 39 fontes
+python3 -c "
+import json;d=json.load(open('saidas/t4_p3b_corpus_real.json'))
+print('registros:',d['n_total'],'bytes:',d['bytes']);print('tarefas:',d['tarefas'])"
+```
+
+Saída esperada (varia 1.752–1.992 conforme as dependências instaladas: sem `requests`
+a fonte TTS some):
+
+```
+corpus: .../corpus_real_mini.jsonl  n=1812  3.1 MB
+tarefas: {'pontuacao':60,'instrucao':132,'lm':120,'noticia':120,'imagem_caption':240,
+          'vqa':180,'ocr':60,'tts':60,'classificacao':120,'traducao':120,'robo':240,
+          'matematica':360}
+```
+
+Sinal de que o split inexistente está lá (fonte [24]):
+
+```
+[24] MoreThought/Fable-5.1-Max-Reasoning-Filtered-5000x   n=  0 lidos=  0   3.0s []
+```
+
+E o erro real da API (probe B do t4):
+
+```
+split_lite: "ERRO ValueError: BuilderConfig 'lite' not found. Available: ['default']"
+```
+
+### 4.1 Reproduzir o custo do dedup (a correção P4)
+
+```bash
+cd /workspace/khtst_audit/verificacao && python3 - <<'EOF'
+import json, collections
+regs=[json.loads(l) for l in open('saidas/corpus_real_mini.jsonl',encoding='utf-8')]
+k_streaming = lambda r: r.get("texto") or r.get("saida") or r.get("entrada") or ""
+k_coletar  = lambda r: (r.get("texto") or ((r.get("entrada") or "")+"\u241f"+(r.get("saida") or "")))
+for nome, fn in (("streaming.py:1013 (atual)", k_streaming), ("02_coletar:66", k_coletar)):
+    mantidos=len(collections.Counter(fn(r) for r in regs))
+    print(f"{nome:26s} descartados={len(regs)-mantidos:4d} ({100*(len(regs)-mantidos)/len(regs):.1f}%)")
+EOF
+```
+
+Esperado no corpus de 1.812 registros: **534 (29,5%)** pela chave atual e
+**394 (21,7%)** pela de `02_coletar` — contra **158 (8,7%)** com a chave corrigida
+(texto+entrada+saida+sha1 da mídia).
+
+---
+
+## 5. Reproduzir o teste do IPC (capacidade nunca lida)
+
+```bash
+cd /workspace/khtst_audit/repo/src && python3 - <<'EOF'
+import sys; sys.path.insert(0,'.')
+from khtst.ipc._fallback import KHTSTCanal as C
+size = 4*1024*1024
+canal = C(b"khtst_teste", size)
+print("cap no header:", canal._ler_u64(8))
+canal.enviar_frame(1, b"PING"+bytes(range(256))*4, seq=0)
+print("roundtrip ok:", any(p==b"PING"+bytes(range(256))*4 for _,p in canal.receber_frames()))
+outro = C.anexar(canal.fd, size//2)          # consumidor com size DIFERENTE
+print("cap recomputada:", outro.capacidade(), "| header continua:", canal._ler_u64(8))
+print("frames lidos:", len(outro.receber_frames()))   # <-- 0, SEM ERRO
+EOF
+```
+
+Esperado: `frames lidos: 0` — **perda silenciosa**, sem exceção. É o P6.
+
+---
+
+## 6. Aplicar as correções (todas já prontas em `correcoes/`)
+
+```bash
+cd /workspace/khtst_audit
+
+# 1) conferir que todas compilam
+for f in $(find correcoes -name '*.py'); do python3 -m py_compile "$f" || echo "FALHOU $f"; done
+
+# 2) a do PCGrad tem ERRO DE SINAL — NÃO usar a do agente;
+#    usar a versão em minha_verificacao/CORRECAO_A01_PCGrad.md:
+#       fator =  dot / n2_main          (e não -dot / n2_main)
+#       g = gm + (ga - fator * gm if projetado else ga)
+
+# 3) nunca copiar por cima do espelho do HF: o destino é a sua cópia local
+#    cp -r repo  meu_khtst && rsync -a --ignore-existing correcoes/src/ meu_khtst/src/
+```
+
+Correções prontas (36 arquivos, todos compilam): `correcoes/src/khtst/**`,
+`correcoes/bench/**` (benchmark de RSS e modelo de memória),
+`correcoes/streaming_corrigido.py`, `correcoes/tokenizador_corrigido.py`,
+`correcoes/treinador_corrigido.py`, `correcoes/base_corrigido.json`,
+`correcoes/migrar_constantes.py` (fonte única de verdade das constantes),
+`correcoes/docs/matematica/CORRECOES_MATEMATICAS.md`.
+
+---
+
+## 7. Camada de backend (P13) — para hardware chinês
+
+```bash
+# 1) criar a camada
+#    src/khtst/nucleo/backend.py  (código no §7.3 do PLANO_MELHORIAS_KHTST.md)
+
+# 2) substituir as 19 ocorrências de torch.cuda.* :
+grep -rn --include=*.py --include=*.pyx -E '\.cuda\(|device=.cuda.|torch\.cuda\.' src scripts
+#   substituir por: from khtst.nucleo.backend import backend_disponivel, device, vazia_cache
+
+# 3) instalar o runtime do backend NA MÁQUINA ALVO (nunca no sandbox)
+#    Ascend:  pip install torch-npu==<versão compatível> \
+#                --extra-index-url https://repo.huaweicloud.com/ascend/repos/pypi
+#    Moore:   torch_musa (https://github.com/MooreThreads/torch_musa) + MUSA SDK
+#    Hygon:   torch_hcu (vem com o DTK) + FlagTree HCU
+#    Iluvatar:torch_xiu + flagtree==<ver>+iluvatar3.x
+#    Kunlun:  torch_xmlir (Python 3.8) + FlagTree XPU
+#    Cambricon: torch_mlu (compila contra PyTorch patcheado)
+
+# 4) RECOMPILAR as extensões Cython NA MÁQUINA ALVO
+cd meu_khtst/src/khtst/acelerado && python3 setup.py build_ext --inplace
+cd ../ipc                && python3 setup.py build_ext --inplace
+#    os .so do repo são cpython-312 e não carregam em outros ambientes
+
+# 5) desligar a quantização int8 em backends sem kernel CUDA
+#    (quanta/torchao_quant.py depende de tinygemm sm>=8.0 / int8pack)
+```
+
+Verificação do backend:
+
+```python
+from khtst.nucleo.backend import backend_disponivel, device
+print("backend:", backend_disponivel(), "| device:", device())
+```
+
+---
+
+## 8. Critérios de aceite por fase (resumo)
+
+| Fase | Aceite verificável |
+|---|---|
+| 0 | `verif_pcgrad_invariantes.py` → 0 violações; `verif_cinza_lipschitz.py` → docstring coerente; `v05`/`v08` rodam sem crash; `validacao.py` reprova `n_camadas=3` |
+| 1 | dedup ≤ 10% de descarte; `anexar()` com `size` divergente levanta erro; 0 registros de split de avaliação no corpus; `pytest` coleta sem torch |
+| 2 | RSS do `insere_paralela` cai ~2× em T=65.536; `c*` reproduz a memória prevista |
+| 3 | `backend_disponivel()` correto em cada máquina; `.so` importável no Python local; perplexidade dentro de 1% da CPU |
+| 4 | todo número do README com `arquivo:linha` + comando; "18/18" → "17/18" |
+
+---
+
+## 9. O que NÃO dá para rodar neste sandbox (e por quê)
+
+| Item | Motivo |
+|---|---|
+| treino real do modelo | sem torch e sem GPU; 3 GB de RAM |
+| `.so` do repositório | cpython-312 x86-64; o sandbox é Python 3.11 |
+| medição de throughput | sem GPU e com 2 cores |
+| port para NPU/DCU | precisa do SDK do fabricante na máquina alvo |
+
+Tudo o mais (provas matemáticas, dedup, IPC, RoPE, PCGrad, modelo de RAM,
+recolha de dados reais) **roda e foi rodado** — os scripts estão em
+`/workspace/khtst_audit/minha_verificacao/` e em `/workspace/khtst_audit/verificacao/`.

auditoria_independente/PLANO_MELHORIAS_KHTST.md

@@ -0,0 +1,557 @@
+# KHTST — Resultados consolidados, confirmação independente e aprimoramentos
+
+> **RESOLUÇÃO v23 (2026-10-18) — LEIA PRIMEIRO.** Este documento é a
+> auditoria independente de 2026-10-17. O projeto **re-verificou cada claim
+> contra o código real** e aplicou as correções válidas com provas no doc 35
+> (`docs/matematica/35-auditoria-independente-pcgrad-rope-eratas.md`):
+> **APLICADAS**: P1 (PCGrad), P2 (RoPE offset), P3 (tronco 5:1, L=6),
+> P4 (dedup+mídia, 29,5%→8,7%), P5 (checkpoint atômico), P6 (IPC header),
+> P9 (filtro eval→treino, 9 fontes de benchmark), P10 (Fable→train,
+> hendrycks→train), P11 (NFC), P12-lite (conftest torch-free), P15 (os 4
+> scripts de auditoria agora em `auditoria_independente/` com assert+exit),
+> P16 (docstring Lipschitz) + A-05 (acumulação sem viés na retomada),
+> A-19 (hub com buffer), A-22 (avaliar vazio alerta), A-23 (mecanismo árvore
+> INERTE desde a v8 — corrigido com nascimento neutro preservado) e as
+> erratas E-01..E-04 nos docs 26/28. **REFUTADAS** (não aplicadas, prova em
+> doc 35 §11): E-05 (L_bal float — perda_lb É tensor), I-05 (peso_moe órfão
+> — razao_moe_ce produzido na v22), A-21 (conv sem guarda — call site é
+> guardado), número 0,1502 do E-04 (internamente inconsistente). P7/P8/P13
+> (buffer rolante da janela, checkpointing c*, backend NPU/DCU) permanecem
+> como ROTEIRO (não eram bugs). Suíte v23: 35/35; regressão v1–v22 verde;
+> verificar_tudo 49✓/0✗; corpus real fresco 1612 registros sem vazamento.
+
+**Escopo:** auditoria do projeto `PowerMachine/khtst-multimodal-ptbr` (HuggingFace), com
+foco em (a) falhas de lógica, (b) validade das provas matemáticas, (c) consumo de RAM,
+(d) integração entre pacotes, (e) portabilidade para hardware chinês.
+
+**Data:** 2026-10-17 · **Espelho do repositório:** `/workspace/khtst_audit/repo`
+(clone local de `https://huggingface.co/PowerMachine/khtst-multimodal-ptbr`, **não
+modificado** — `git status --porcelain` vazio, confirmado ao final de cada etapa).
+
+> **Regra deste documento:** cada número aparece com uma marca de procedência.
+> `MEDIDO` = executei e colei a saída. `AGENTE` = executei um agente, com a saída
+> preservada em `verificacao/`. `TEÓRICO` = consequência de um teorema, sem execução.
+> Claim **refutada** não volta como válida em nenhum lugar deste documento.
+
+---
+
+## 1. Sumário executivo — o estado real do projeto
+
+O KHTST é um trabalho sério: 185 arquivos Python + 4 Cython + 35 documentos de prova
+(~38.933 linhas), 24 subpacotes, 36 correções prontas que compilam, e uma suíte de
+verificação numérica honesta. O que o projeto **não** é, hoje, é o que o README
+promete. Os desacoplamentos reais entre código, documentação e métricas são:
+
+1. **O tronco "híbrido 5:1" não existe na configuração entregue.** `configs/base.json`
+   tem `modelo.n_camadas = 3`; o padrão NoPE é `(i+1) % 6 == 0` → **zero camadas
+   NoPE**. A validação que deveria garantir o contrato 5:1 checa
+   `modelo.mamba3.n_camadas` (6) — um campo que **não** constrói o tronco. O único
+   lugar que corrige isso é `scripts/29_ipc_treino_modelo.py:61`.
+2. **O PCGrad não projeta gradiente nenhum** — ele reescala `g_aux` por um escalar
+   (`cirurgia_grad.py:90-101`). Medido: em **25,3%** dos pares em conflito o
+   gradiente resultante ainda tem produto interno negativo com `g_aux`, e o pior
+   caso é **1,73× pior** que o conflito original.
+3. **O RoPE reinicia a posição a cada passo de decodificação** (`atencao.py:39-57`,
+   chamadas em 100 e 179, sem offset). Medido: o score de atenção de um token novo
+   contra o cache é **idêntico** (2,756113) nos passos t=1, t=2, t=3 e t=10 — o
+   modelo não distingue "token na posição 1" de "token na posição 100".
+4. **O IPC nunca lê a capacidade que ele mesmo grava no cabeçalho.** Medido com o
+   código real: se consumidor e produtor discordarem do `size` da região, o
+   consumidor lê **zero frames, sem erro**.
+5. **O checkpoint grava em cima do destino** (sem `os.replace`/`fsync`), grava o
+   `meta.json` **depois** do tensor (e a validação de hash é pulada se o meta
+   faltar) e **apaga os checkpoints antigos depois** de escrever o novo — um crash
+   deixa o novo truncado e o antigo já destruído.
+6. **O dedup do corpus descarta 29,5% dos registros reais** porque a chave é
+   `texto or saida or entrada` (só a saída, para registros seq2seq). Medido no meu
+   corpus real de 1.812 registros. A chave correta recupera **+24%** de dados.
+7. **Dez das 39 fontes do plano são splits de avaliação** e entram no mesmo
+   corpus de treino. E a fonte `MoreThought/Fable-5.1` pede um split `"lite"` que
+   **não existe** → entra com 0 registros.
+8. **Os números de capa do README descrevem outro modelo**: "237 camadas, 78,8 MB →
+   10,1 MB int8 (3,92×)" e "RAM pico 3.066 MB" não batem com o config entregue
+   (3 camadas) nem com a física de RSS (Python+numpy = 29,5 MB; o doc 28 declara
+   78,8 MB de pesos). Um pico absoluto de 3,066 MB é numericamente impossível.
+
+**A parte boa:** as provas de Stiefel/RCO, a cota `ℓ_max ≤ d/√d_h`, o decaimento
+analítico de τ e a conservação do SOM estão corretas onde foram re-derivadas; o
+`while` de checkpointing, o `torch.compile` e a camada de quantização têm
+arquitetura sadia; e a suíte de verificação por numpy que os próprios agentes
+escreveram é a melhor parte do repositório.
+
+**O veredito:** o KHTST tem a forma de um sistema maduro e a aparência de um. O caminho
+crítico não é otimização de RAM — é **corrigir três bugs de matemática que
+invalidam resultados publicados** (PCGrad, RoPE, tronco 5:1) e **parar de publicar
+métricas que o config entregue não produz**.
+
+---
+
+## 2. Método: o que os agentes fizeram e o que eu refiz sozinho
+
+### 2.1 O que os agentes entregaram (preservado em disco)
+
+| Artefato | Conteúdo | Estado |
+|---|---|---|
+| `relatorios/t1_auditoria_estrutural.md` | 23 achados (4 críticos, 6 altos, 8 médios, 5 baixos) em 24 subpacotes | entregue; **parcialmente refutado** na verificação |
+| `relatorios/t2_provas_matematicas.md` | 80 claims de 35 documentos + 9 scripts numpy | entregue; claim 79 e 17/19 refutados |
+| `relatorios/t4_testes_datasets_reais.md` | 37 datasets inventariados, 39 fontes em streaming real, corpus de ~1.9k registros | entregue; 2 números exagerados (ver §4) |
+| `relatorios/t5_integracao.md` | grafo de imports (125 módulos), IPC, 18/18 da tabela v17 | entregue; 2 números corrigidos |
+| `relatorios/verify_t1.md` | conferência adversarial da t1 | entregue (não foi re-conferido por mim em tudo) |
+| `relatorios/verify_t2.md` | conferência adversarial da t2 (minha segunda rodada) | entregue |
+| `relatorios/verify_t4.md`, `verify_t5.md` | conferências adversariais | entregues |
+| `correcoes/` | 36 arquivos corrigidos (compilam) | entregue; **1 tem erro de sinal (PCGrad)** |
+| `verificacao/` | 19 scripts de prova + saídas | entregue; 2 scripts quebrados (ver §4) |
+
+### 2.2 O que ficou incompleto
+
+- **`t3` (memória/RAM + hardware chinês) nunca foi entregue** — o trabalhador foi
+  interrompido no limite de 30 min. **Eu produzi essa parte** (§6 e §7), a partir do
+  config e do código reais.
+- **Não existem as revisões de segunda camada** (`verify_t1_revisado`,
+  `verify_t45_revisado`): ninguém reconferiu as conferências. Eu conferi as
+  conclusões queustinham o plano.
+- **Não existia plano final nem guia de execução** antes deste documento.
+
+### 2.3 O que eu refiz sozinho (sem os agentes)
+
+| Verificação minha | Script | Resultado |
+|---|---|---|
+| PCGrad: invariantes corretos × 3 variantes | `minha_verificacao/verif_pcgrad_invariantes.py` | original viola I1 em 100.070/100.083; correção dos agentes viola em 100.083/100.083; a minha em 0 |
+| PCGrad: garantia "nenhuma tarefa piora" | `minha_verificacao/verif_pcgrad_rope.py` | 25,3% de violação; pior caso 1,73× |
+| RoPE: invariância de posição na decodificação | `minha_verificacao/verif_pcgrad_rope.py` | score constante (2,756113) para t=1,2,3,10 |
+| Lipschitz do detector de cinza | `minha_verificacao/verif_cinza_lipschitz.py` | teorema do doc **válido** (razão 0,999989); docstring do código **falso** (viola 45×) |
+| IPC: capacidade do header nunca lida | teste com o módulo real `khtst.ipc._fallback` | consumidor com `size` diferente lê 0 frames, sem erro |
+| Dedup sobre corpus real | re-execução de `t4_p3b_corpus_real.py` + cálculo próprio | 1.812 registros; 29,5% descartados pela chave atual; 8,7% pela chave corrigida |
+| NFD × tokens com BPE real | `tokenizers` sobre o corpus real | 0/1.500 textos em NFD; inflação real 1,198× (não 2,64×) |
+| Split inexistente | re-execução da coleta real | `MoreThought/Fable-5.1` → 0 registros; erro `BuilderConfig 'lite' not found` |
+| Modelo de RAM | `minha_verificacao/modelo_ram.py` | 5,04 M params; 20,1 MB fp32; estado 4× = 100,7 MB; gargalo = janela paralela |
+| Acoplamento a CUDA | grep real no repo | 19 linhas em 9 arquivos; zero `autocast`/`nccl`/`triton`/`flash_attn`/`pin_memory` |
+| Reprodução dos scripts dos agentes | re-execução de v01..v09 | v01/v02/v06/v07 diferem só nos últimos dígitos; **v05 e v08 quebram** |
+
+---
+
+## 3. Índice de achados (estado consolidado)
+
+`CONFIRMADO-ME` = reproduzi eu mesmo, com saída executada.
+`CONFIRMADO-AGENTE` = o achado se sustenta, mas a evidência é do agente.
+`REFUTADO` = não vale;listado em §3.2 para transparência.
+
+### 3.1 Achados que valem
+
+| ID | Origem | Local | Descrição | Sev | Estado |
+|---|---|---|---|---|---|
+| A-01 | t1 | `treino/cirurgia_grad.py:90-101` | PCGrad reescala `g_aux` em vez de projetar: a garantia "nenhuma tarefa piora" é violada em 25,3% dos conflitos | CRÍTICO | **CONFIRMADO-ME** (bug real; a *prova* do agente era fabricada) |
+| A-01' | t1 | `correcoes/.../cirurgia_grad.py:66-81` | a correção proposta pelo agente usa `fator = -dot/n2` com `ga - fator*gm` → conflito **dobrado** (`⟨g_aux',g_main⟩ = 2·dot < 0`), viola I1 em 100% dos pares | CRÍTICO | **CONFIRMADO-ME** (pior que o original) |
+| A-03 | t1 | `percepcao/atencao.py:39-57` | RoPE sem offset: na decodificação o token novo sempre recebe posição 0 | CRÍTICO | **CONFIRMADO-ME** |
+| A-04 | t1 | `configs/base.json` + `nucleo/validacao.py:63-67` | tronco com 3 camadas → 0 NoPE; a validação do 5:1 checa outro campo | CRÍTICO | **CONFIRMADO-ME** |
+| A-05 | t1 | `treino/treinador.py:709` | acumulação de gradiente corrompida na retomada | ALTO | CONFIRMADO-AGENTE |
+| A-08/A-17 | t1 | `memoria/interna.py` | listas/dicts que crescem por iteração | ALTO | CONFIRMADO-AGENTE |
+| A-11/A-12/A-15/A-16 | t1 | `quanta/gsq_rco.py` | robustez numérica da quantização | MÉDIO | CONFIRMADO-AGENTE |
+| A-19 | t1 | `telemetria/hub.py:186-190` | ~20 `open()/close()` por passo (I/O-bound) | MÉDIO | CONFIRMADO-AGENTE |
+| A-21 | t1 | `mamba3/kernel.py:158-170` | `_ConvCausalProfunda` chama o binário sem checar `_hot is not None` → `ImportError` em vez do fallback | MÉDIO | CONFIRMADO-AGENTE |
+| A-22 | t1 | `treino/treinador.py:96-101` | com <2 registros, `avaliar()` devolve `{}` e o gate de fase some em silêncio | MÉDIO | CONFIRMADO-AGENTE |
+| A-23 | t1 | `percepcao/atencao.py:299-306` | `peso_arvore` nasce em 0 e só é escrito quando o mecanismo já roda → mecanismo permanentemente inerte | MÉDIO | CONFIRMADO-AGENTE |
+| A-20 | t1 | `quanta/gsq_rco.py:800,867` | `float64` onde `float32` bastaria — **ganho real ≤ 1,5 kB** (o próprio agente calibrou a expectativa) | BAIXO | CONFIRMADO-AGENTE |
+| E-01 | t2 | `docs/matematica/26` §5-ii | `Σ 1/τ(t) < ∞` é **falso** (a série diverge); meu recálculo: T=1000 → 1.673,3; T=10⁶ → 1.999.673,2 | ALTO | **CONFIRMADO-ME** (casa dígito a dígito) |
+| E-02 | t2 | `docs/matematica/26` §9 | `T_τ = 600/ln7 ≈ 308,1` com δ=0,05: o valor correto é **168,76** (= 600/ln 35) | MÉDIO | **CONFIRMADO-ME** |
+| E-03 | t2 | `docs/matematica/28` Teo 28.8 | `dH/dT = Var_p(z)/T²` → o correto é **/T³** | ALTO | CONFIRMADO-AGENTE (verificado por diferença numérica FD/T³ = 1,00000 em 15/15) |
+| E-04 | t2 | `docs/matematica/28` Teo 28.1 | `E‖Δ‖² = h²/12` vale para densidade **contínua**; com átomos na grade vale 0 | MÉDIO | CONFIRMADO-AGENTE (contra-exemplo explícito) |
+| E-05 | t2 | `nucleo/modelo.py` (MoE) | `L_bal` entra como `float` → gradiente ≡ 0 | ALTO | CONFIRMADO-AGENTE |
+| E-06 | t2 | `percepcao/moe.py` | convenção de τ divergente entre docs (1/4τ vs 1/2τ) | MÉDIO | CONFIRMADO-AGENTE |
+| E-07 | t2 | README §v14 | "entropia do seletor 0,87" não tem poder discriminativo: varia 3e-4 para Δlogit=5 | MÉDIO | **CONFIRMADO-ME** (saída de `out_v05`: 0,6497→0,6500) |
+| E-08 | t2 | README §v12 | "RAM pico 3.066 MB" é numericamente impossível como pico absoluto | MÉDIO | **CONFIRMADO-ME** (29,5 MB só com Python+numpy; 78,8 MB de pesos no doc 28) |
+| E-09 | t2 | README/doc 28 | "237 camadas, 78,8 MB → 10,1 MB int8 (3,92×)" descreve um modelo que o config entregue não instancia (3 camadas) | ALTO | **CONFIRMADO-ME** |
+| T-01 | t4 | `dados/streaming.py:896` | split `"lite"` inexistente → a fonte MoreThought/Fable entra com 0 registros | ALTO | **CONFIRMADO-ME** (erro real da API HF) |
+| T-02 | t4 | `dados/streaming.py:1013` | chave de dedup `texto or saida or entrada` descarta 29,5% dos registros reais | ALTO | **CONFIRMADO-ME** (534/1.812) |
+| T-03 | t4 | `dados/streaming.py` (PLANO) | 10 de 39 fontes são splits de avaliação dentro do corpus de treino | ALTO | CONFIRMADO-AGENTE (probe J: train 29, validation 2, test 6, td_path 1, lite 1) |
+| T-04 | t4 | `dados/streaming.py` (PLANO) | `allenai/fetchman-data` (robô) e matemática fora da mistura `base.json` | MÉDIO | CONFIRMADO-AGENTE |
+| T-05 | t4 | `dados/streaming.py` | `sfarrukhm/intel-image-classification` tem 1 classe só | MÉDIO | CONFIRMADO-AGENTE |
+| T-06 | t4 | `dados/streaming.py` | suíte de testes do repo é 100% torch-dependente → **nenhum teste roda** sem torch | ALTO | **CONFIRMADO-AGENTE** (20/20 arquivos falham por import) |
+| T-07 | t4 | `percepcao/vit_lra.py:201-203` | o **docstring do código** repete o bound Lipschitz "2δ" que o doc 27 diz ser falso | MÉDIO | **CONFIRMADO-ME** (viola em 45×; o *teorema* é válido) |
+| T-08 | t4 | `dados/streaming.py` | sem normalização Unicode no ingestão | BAIXO (latente) | **CONFIRMADO-ME**: 0/1.500 textos reais em NFD; custo real 1,198× (não 2,64×) |
+| I-01 | t5 | `ipc/_fallback.py:75` + `khtst_ipc.pyx:265` | capacidade gravada no header nunca lida; divergência de `size` = perda silenciosa | ALTO | **CONFIRMADO-ME** (0 frames lidos, sem erro) |
+| I-02 | t5 | `quanta/gsq_rco.py:93-94` | `TAU_MIN_PADRAO`/`T_ALVO_PADRAO` não são o τ efetivo (0,25 vem de `ajustar_k_tau_min`, default 0,25) | ALTO | CONFIRMADO-AGENTE |
+| I-03 | t5 | `dados/checkpoints.py:63-95` | escrita não-atômica, `meta` depois do tensor, limpeza do antigo depois da escrita | CRÍTICO | **CONFIRMADO-ME** |
+| I-04 | t5 | `ipc` / `treino/estado_integral.py` | rótulo de esquema gravado e nunca lido | ALTO | CONFIRMADO-AGENTE |
+| I-05 | t5 | tabela v17 | `peso_moe` órfão → a tabela é 17/18, não 18/18 | MÉDIO | CONFIRMADO-AGENTE |
+| I-06 | t5 | `nucleo/guarda_runtime.py` | duas cópias literais de `rss_mb` | MÉDIO | CONFIRMADO-AGENTE |
+| I-07 | t5 | `quanta/gsq_rco.py` | colisão de nome `erro_quantizacao` com semânticas incompatíveis | MÉDIO | CONFIRMADO-AGENTE |
+| I-08 | t5 | 125 módulos / 167 arestas | grafo de imports **sem ciclos** — confirmado; mas a contagem de 167 arestas foi corrigida | BAIXO | CONFIRMADO-AGENTE (0 ciclos confirmado) |
+| R-01 | t3 | **não entregue pelo agente** | modelo de RAM e matriz de hardware chinês | ALTO | **FEITO POR MIM** (§6, §7) |
+
+### 3.2 Achados REFUTADOS (não valem — não reaproveitar)
+
+| ID | O que se alegava | Por que caiu |
+|---|---|---|
+| A-10 (núcleo) | "capacidade divergente entre a implementação Python e a Cython" | a função comparada é **código morto**; as duas implementações vivas concordam em todos os pontos testados. Restou só a guarda assimétrica `__init__` vs `anexar` — **BAIXO**, não ALTO |
+| A-07 | "memória do SSM ~6 tokens" | linha errada (145→157) e a matemática estava invertida |
+| A-01 (prova) | tabela de ângulos do PCGrad | foi produzida com o **sinal trocado** (`gm+(ga+fator·gm)`); o invariante declarado era matematicamente falso. O *bug* é real, a *prova* não era |
+| A-08 | prova do crescimento de listas | prova internamente contraditória; linhas erradas |
+| — | "cobertura 191/191 (100%) lidos" | é contagem de **arquivo**, não de leitura; a métrica honesta ("63 arquivos abertos") também é falsa (são 101) |
+| — | "correções A-01 e A-03 são patches" | eram prosa comentada; `atencao.py` nem importava |
+| t2 claim 79 | entropia "0,333 → 0,999" | o script morre na linha 109 **antes** de imprimir qualquer um desses números |
+| t2 claims 17/19 | "PROVADO (código)" | eram fórmulas transcritas à mão; o repo não era importado nem lido |
+| t4 A-06 | "NFD custa ×2,64 tokens" | o número real é **1,198×** (medido com o BPE real); e 0 de 1.500 textos reais estão em NFD — risco latente, não erro ativo |
+| t4 probe I | "Lipschitz do detector de cinza FALSO" | o **teorema** é válido (razão 0,999989 ≤ 1); o que é falso é o docstring do **código** |
+
+---
+
+## 4. Provas matemáticas: o que sobrevive, o que cai
+
+### 4.1 Confirmadas por mim
+
+**I1 — PCGrad: os invariantes corretos.** Com `dot = ⟨g_main,g_aux⟩` e `n2 = ‖g_main‖²`,
+a versão correta (Yu et al., 2020, Alg. 2) é `g_aux' = g_aux − (dot/n2)·g_main`, e então:
+
+```
+I1  ⟨g_aux', g_main⟩ = dot − (dot/n2)·n2 = 0                       (ortogonalidade exata)
+I2  ‖g_aux'‖² = ‖g_aux‖² − dot²/n2 ≤ ‖g_aux‖²                       (contração)
+I3  ⟨g_total, g_main⟩ = n2 ≥ 0   e   ⟨g_total, g_aux'⟩ = ‖g_aux'‖² ≥ 0
+```
+
+Medido em 100.083 pares com conflito (`verif_pcgrad_invariantes.py`):
+
+| variante | viola I1 | viola I2 | viola I3 |
+|---|---|---|---|
+| código atual (`gm + fator·ga`) | 100.070 | 0 | 49.948 |
+| correção do agente (`gm + (ga − fator·gm)`, `fator=−dot/n2`) | 100.083 | 100.081 | 791 |
+| **correção correta (`fator = dot/n2`)** | **0** | **0** | **0** |
+
+Isto é uma correção real, não cosmética: a versão do agente **dobra** o conflito
+(`⟨g_aux',g_main⟩ = 2·dot < 0`). Contra-exemplo simbólico: `gm=(1,0)`, `ga=(−1,0)`
+→ versão atual dá `g=(0,0)`; versão do agente dá `g=(−1,0)` (pior!); versão correta
+dá `g=(1,0)` com componente auxiliar **nula**.
+
+**I2 — RoPE exige referencial de posição compartilhado.** A propriedade do RoPE é
+`⟨R_p q, R_j k⟩ = ⟨q, R_{j−p} k⟩`, o que exige que `q` e `k` compartilhem a
+**mesma origem** de posições. No prefill, `q` e `k` vêm do mesmo tensor com
+`pos = arange(T)` → a invariância translacional vale. Na decodificação, `q` e `k`
+novos recebem `pos = arange(1) = [0]`, enquanto o cache guarda `k` rotacionado com
+as posições **originais** → o offset relativo passa de `(t − j)` para `(0 − j)`.
+Medido: `⟨q_rot, k_rot⟩ = 2,756113` para t = 1, 2, 3 e 10 — **constante**. A
+correção é um parâmetro `offset` em `aplicar_rope`, alimentado pelo número de
+tokens já presentes no cache.
+
+**I3 — o Lipschitz do detector de cinza (doc 27, Teo 27.7(ii)(a)) está correto.**
+Com `χ = (mx − mn)/(mx + ε)`:
+```
+∂χ/∂mx = (ε + mn)/(mx+ε)² ,   ∂χ/∂mn = −1/(mx+ε)
+|∂χ/∂I| ≤ (ε+mn)/(mx+ε)² + 1/(mx+ε) = (mx + mn + 2ε)/(mx+ε)²
+bound do doc: 2/(mx+ε) + χ/(mx+ε) = (2mx + 2ε + mx − mn)/(mx+ε)²
+bound_doc − bound_real = 2(mx − mn)/(mx+ε)² ≥ 0   ⇒  o bound do doc DOMINA o real
+```
+Medido: `max(derivada real / bound do doc) = 0,999989 ≤ 1`. O que é falso é o
+**docstring do código** (`vit_lra.py:201-203`), que repete o bound ingênuo `2δ`:
+pixel cinza 0,01 com um canal +0,001 → `|Δs| = 0,0901` = **45× o 2δ**.
+
+**I4 — `Σ 1/τ(t)` diverge.** Com `τ(t) = τ_min + (τ_0−τ_min)·e^{−t/T_τ}` e
+`τ_min > 0`, `1/τ(t) ≥ 1/τ_0 > 0` ⇒ a série não converge. Meus números:
+`T=1000 → 1.673,3`; `T=10⁶ → 1.999.673,2`; `S/T → 1,9997`. Bate dígito a dígito
+com o relatório.
+
+**I5 — `T_τ` do doc 26 §9.** `T_τ = t_alvo / ln((τ_0−τ_min)/δ)`. Com `t_alvo=600`,
+`τ_0=1,75`, `δ=0,05`: `600/ln(35) = 168,76`, não `600/ln7 = 308,34`.
+
+### 4.2 Refutadas com contra-exemplo
+
+- **`E|Δ|² = h²/12` para "qualquer densidade"** — vale para densidade contínua
+  (erro ~1e-4 com 4·10⁶ amostras), mas uma densidade **discreta com átomos
+  exatamente na grade** (ex.: pesos em `k·s`) tem `Δ ≡ 0` e `E[Δ²] = 0` — violação
+  de 100%. E com *clipe* saturado (`normal(0,1)`): `E[Δ²] = 0,1502` contra
+  `h²/12 = 5,17e-06` — violação de 4 ordens de grandeza, muito mais forte que a
+  ressalva original. Consequência: `‖X̃−X‖_∞ ≤ s/2` **só vale enquanto o clipe não
+  satura** (em `normal(0,0,2)`, `max|Δ| = 0,026` = 6,6× o `s/2 = 0,0039`).
+- **`dH/dT = Var_p(z)/T²`** — o correto é `/T³` (verificado por diferenças finitas:
+  `FD/(Var/T³) = 1,00000` em 15/15 combinações).
+
+### 4.3 Scripts de prova que não rodam (achado meu, que escapou a todos)
+
+| script | problema | evidência |
+|---|---|---|
+| `v05_metricas_readme.py` | crasha na linha 109: `ent_rel(np.exp(lv−lv))` passa **escalar** onde a função soma no eixo 1 → `numpy.AxisError` | saída real em `verificacao/saidas/`; o relatório t2 publica os números da linha seguinte, que o script nunca imprime |
+| `v08_docs_00_25.py` | usa `np.trapz`, **removido no numpy ≥ 2.0** (virou `np.trapezoid`) | `AttributeError: module 'numpy' has no attribute 'trapz'` com numpy 2.4.6 (o agente rodou com numpy 1.24 e não viu) |
+
+Recomendação: trocar comparações textuais por `assert`/exit code (hoje os 9 scripts
+não têm **nenhum** `assert`, então nenhum check aborta) e fixar `numpy<2` ou migrar
+`np.trapz`.
+
+---
+
+## 5. Achados de integração que sobreviveram
+
+- **Grafo de imports: 125 módulos, 0 ciclos** — confirmado. A contagem de 167 arestas
+  foi corrigida na verificação (a dependência existe, o número não).
+- **0 ciclos de import** é um resultado **forte** e raro: significa que a extração
+  pode ser feita por ordem topológica sem reordenar nada.
+- **Contratos quebrados**: 4/4 confirmados com `arquivo:linha` nos dois lados
+  (incluindo `erro_quantizacao` homônimo com semânticas incompatíveis).
+- **Tabela v17**: 3 de 4 itens confirmados, 1 confirmado com citação errada;
+  `peso_moe` é órfão → **17/18, não 18/18**.
+- **Duas rotinas de dedup divergem** (`streaming.py:1013` vs `02_coletar_corpus.py:66`)
+  — 140 registros afetados na medição do agente; a minha medição (1.812 registros)
+  dá 534 vs 394 descartados, com 158 em comum.
+
+---
+
+## 6. Modelo de RAM (feito por mim, sobre o config e o código reais)
+
+`minha_verificacao/modelo_ram.py` → saída completa em `minha_verificacao/saida_modelo_ram.txt`.
+
+### 6.1 Parâmetros e estado (contagem analítica)
+
+| item | valor | fp32 |
+|---|---|---|
+| embedding (16384 × 192) | 3.145.728 | 12,58 MB |
+| por camada do tronco (atenção + Mamba3 + FFN + micro) | 629.760 | 2,52 MB |
+| tronco (L = 3) | 1.889.280 | 7,56 MB |
+| **total** | **5.035.008** | **20,14 MB** |
+| pesos + grads + momento Muon + (m,v) do AdamW | 4×P | **100,70 MB** |
+
+### 6.2 O gargalo real: a janela paralela 1M
+
+`memoria/janela_1m.py:184` materializa `segs = oculto.new_zeros(M, w_seg, d)` com
+`w_seg = 256` e passo `s = 128`. Como `W/s = 2`, cada token aparece em **2 janelas**
+→ o tensor materializado tem **2× o tamanho do chunk**:
+
+| chunk T | `segs` | buffers fixos (z + grade SOM) | total |
+|---|---|---|---|
+| 512 | 0,59 MB | 3,11 MB | 3,69 MB |
+| 4.096 | 6,09 MB | 3,11 MB | 9,21 MB |
+| 16.384 | 24,97 MB | 3,11 MB | 28,11 MB |
+| 65.536 | 100,47 MB | 3,11 MB | 103,70 MB |
+
+**Prova da redundância:** com `M ≈ T/s` janelas de largura `W`, o total de cópias é
+`M·W ≈ (T/s)·W = T·(W/s) = 2T`. Uma implementação com **buffer rolante** (duas
+janelas sobrepostas) usa `O(W)` em vez de `O(T)` → **2× de RAM a menos no termo
+dominante**, com o mesmo resultado (a ordem de atualização da grade SOM é preservada
+por construí-la em ordem).
+
+### 6.3 Ponto ótimo do checkpointing (prova)
+
+Com ativação de `k` tensores `(B,c,H)` por segmento de comprimento `c`:
+```
+M(c) = B·S·H·4·(k_min) + (S/c)·B·c·H·4·k   ≈  B·H·4·(S + k·S/c + c·k)
+Minimizando em c:  dM/dc = 0  ⇒  c* = √(S/k)
+M* = B·H·4·2·√(k·S)          (ganho √(k·S) sobre o sem-checkpoint)
+Tempo: T(c) = (fwd + bwd) + 1 fwd de recomputação = 4 unidades, INDEPENDENTE de c
+       ⇒ overhead constante de +33%, e o ótimo de memória não custa tempo extra.
+```
+Medido: S=4.096 → 113,25 MB sem ckpt → **1,02 MB** com `c* = 18,5` (**110,9×**);
+S=65.536 → 1.811,94 MB → **4,09 MB** com `c* = 73,9` (**443×**).
+
+### 6.4 Tabela de orçamento por RAM (treino, fp32, lote 6)
+
+Termos: estado 4×P (100,7 MB) + KV (56,6 MB) + scores da atenção + ativação + janela.
+
+| RAM | S viável (limitado pela janela paralela) | S viável (limitado pelos scores) | `c*` do ckpt |
+|---|---|---|---|
+| 3 GB | **2.645** | 42.160 | 15 |
+| 8 GB | **7.196** | 114.694 | 24 |
+| 16 GB | **14.478** | 230.749 | 35 |
+| 24 GB | **21.759** | 346.804 | 43 |
+| 48 GB | **43.605** | 694.970 | 60 |
+
+*Nota:* a variante **GLOBAL** de atenção custa `O(B·H·S²)`: 19,33 GB só nos scores com
+S=8.192, e 19,8 **TB** com S=262.144. A variant **JANELA** (raio 128) custa
+`O(B·H·S·257)`: 0,152 GB em S=2.048 e 19,4 GB em S=262.144. Ou seja, **a partir de
+~20 GB de RAM a atenção global é aritmeticamente impossível** — o modo janela não é
+uma otimização, é a única opção.
+
+---
+
+## 7. Portabilidade para hardware chinês (verificada em fontes oficiais)
+
+**Notícia boa:** o acoplamento do KHTST a CUDA é **pequeno** — 19 linhas em 9 arquivos,
+com `torch.cuda.is_available()` usado como *sonda de capacidade* (não requisito),
+zero `autocast`, zero `nccl`, zero `triton`, zero `flash_attn`, zero `pin_memory`.
+`scripts/24, 31, 33` já checam `torch.xpu.is_available()`. O núcleo é agnóstico.
+
+| item | arquivo:linha | tipo | o que fazer |
+|---|---|---|---|
+| sonda de backend | `quanta/gsq_rco.py:210,212`; `quanta/quantizacao.py:268,285,317,326,331`; `quanta/torchao_quant.py:47,56`; `geracao/difusao.py:121`; `acelerado/rco_gsq.pyx:71,73`; `telemetria/gestor_memoria.py:106,107` | `is_available()` + `get_device_name` | trocar por um `backend_disponivel()` único |
+| seleção de device | `scripts/12_gsq_rco_hibrido.py:70,75` | `device = "cuda" if ...` + `.cuda()` | usar o seletor |
+| higiene de memória | `telemetria/gestor_memoria.py:107` | `torch.cuda.empty_cache()` | cache do backend + `gc.collect()` |
+
+### 7.1 Matriz de backends (nomes de pacote conferidos em fonte oficial)
+
+| Backend | Pacote / API | Fonte (aberta) | Situação para o KHTST |
+|---|---|---|---|
+| **Ascend NPU** | `torch-npu` (PyPI, 2.14.0 em out/2026); `torch.npu.is_available()`, `torch.npu.device_count()`; índice extra `https://repo.huaweicloud.com/ascend/repos/pypi` | https://pypi.org/project/torch-npu/ | **recomendado 1º**: wheels prontas, `torch.cuda` → `torch.npu` |
+| **Moore Threads** | `torch_musa` (repo aberto, MUSA SDK + muDNN) | https://docs.mthreads.com/en/torchmusa/torchmusa-doc-online/ · https://github.com/MooreThreads/torch_musa | viável; exige SDK MUSA instalado |
+| **Hygon DCU** | `torch_hcu` (vem com o DTK, **não está no PyPI**) + FlagTree HCU; DTK validado em Python 3.8–3.12 | https://github.com/flagos-ai/FlagTensor/blob/main/setup.sh | viável, mas exige SDK no host |
+| **Iluvatar CoreX** | `torch_xiu` + `flagtree==<ver>+iluvatar3.x` (BI-V150) | mesma URL | viável; wheels cp310/cp312 |
+| **Kunlunxin XPU** | `torch_xmlir` + FlagTree XPU; **SDK só para Python 3.8**; runtime em `/opt/xre/so` | mesma URL | **restrição de Python** — exige venv 3.8 |
+| **Cambricon MLU** | `torch_mlu` (compila contra PyTorch patcheado; NeuWare SDK) | https://github.com/Cambricon/torch_mlu | mais custoso: compila do zero, `torch.device("mlu")` |
+| Intel XPU (referência) | `torch.xpu` nativo | https://docs.pytorch.org/docs/stable/xpu.html | já é o caminho "não-CUDA" mais maduro |
+
+### 7.2 O que realmente trava o port (e não é o device)
+
+1. **As 5 extensões Cython** (`acelerado/{mamba3hot,mc_jepa,nucleos,rco_gsq}.pyx`,
+   `ipc/khtst_ipc.pyx`). Os `.so` do repositório são **cpython-312 x86-64** — não
+   carregam em Python 3.11 nem em builds do usuário. É preciso **recompilar por
+   plataforma** (`python setup.py build_ext --inplace` na pasta do pacote, com o
+   toolchain Cython + compilador da plataforma).
+2. **A quantização torchao int8** (`quanta/torchao_quant.py`) depende de kernels
+   CUDA (`tinygemm` sm≥8.0) e de `int8pack` na CPU. Em NPU/DCU não há equivalente
+   pronto: o caminho seguro é **desligar a quantização int8** e usar bf16/fp16,
+   que todos esses backends suportam nativamente.
+3. **A ordem da `.so` do HF não é alterável** — como o usuário pediu, nada foi
+   modificado no repositório do HuggingFace. O port é entregue como camada de
+   abstração + instruções.
+
+### 7.3 A camada de abstração mínima (proposta)
+
+```python
+# src/khtst/nucleo/backend.py  (NOVO — não mexe em mais nada)
+_BACKENDS = ("npu", "mlu", "hcu", "xiu", "xmlir", "xpu", "cuda", "cpu")
+
+def backend_disponivel() -> str:
+    """Retorna o primeiro backend realmente utilizavel, em ordem de preferencia.
+    NUNCA chama .cuda() — o device e resolvido por nome de backend, e todo
+    .cuda() do repo deve virar torch.device(DEVICE)."""
+    for nome, mod, attr in (("npu", "torch_npu", "npu"), ("mlu", "torch_mlu", "mlu"),
+                            ("hcu", "torch_hcu", "hcu"), ("xiu", "torch_xiu", "xiu"),
+                            ("xmlir", "torch_xmlir", "xmlir"), ("xpu", None, "xpu")):
+        try:
+            if mod is not None:
+                __import__(mod)
+            return nome if getattr(torch, attr).is_available() else "cpu"
+        except Exception:
+            continue
+    return "cpu"
+
+def device() -> torch.device:      return torch.device(backend_disponivel())
+def vazia_cache() -> None:         # higiene de RAM por backend
+    b = backend_disponivel()
+    if b == "cpu": gc.collect(); return
+    getattr(torch, b).empty_cache()
+```
+Custo: uma importação opcional por backend, uma vez, no boot. Substitui os 19
+`torch.cuda.*` por `backend_disponivel()`.
+
+---
+
+## 8. Aprimoramentos propostos (com critério de aceite)
+
+| # | Aprimoramento | Ganho | Esforço | Critério de aceite (objetivo) |
+|---|---|---|---|---|
+| **P1** | **PCGrad correto** (`fator = dot/n2`, `g = gm + (ga − fator·gm)`) | elimina 25,3% de violações da garantia de não-piora | 2 linhas | `verif_pcgrad_invariantes.py` → variante `correto` com 0 violações de I1/I2/I3 |
+| **P2** | **RoPE com offset de cache** | devolve a informação de posição relativa na decodificação | ~10 linhas | teste: `⟨q_rot,k_rot⟩` **diferente** para t=1,2,3,10 e igual ao valor analítico `⟨q, R_{j−t} k⟩` |
+| **P3** | **Tronco 5:1 de verdade** — `modelo.n_camadas = 6` no config + validação checando o campo **real** | o requisito 5:1 passa a ser instanceado e verificável | 1 linha de config + 3 de validação | `validacao.py` deve reprovar `n_camadas=3` e aprovar `6`; `contar_atencao()` deve devolver 1 |
+| **P4** | **Chave de dedup com mídia** (`texto+entrada+saida+sha1(mídia)`) | +24% de registros de treino (158 em vez de 534 descartados) | ~15 linhas | medida no corpus real: descartados ≤ 10% |
+| **P5** | **Checkpoint atômico**: `os.replace` + `fsync` + escrita do `meta` **antes** + validação do tensor **antes** de apagar o antigo | elimina perda de checkpoint em crash | ~20 linhas | simular kill no meio da escrita: o checkpoint antigo continua carregável e o novo nunca é aceito com hash divergente |
+| **P6** | **IPC: ler a capacidade do header** e validar contra `size` | elimina perda silenciosa de frames | ~8 linhas | abrir a mesma região com `size` diferente deve **levantar erro**, não ler 0 frames |
+| **P7** | **Eliminar a materialização 2× da janela paralela** (buffer rolante) | 2× de RAM no termo dominante | ~40 linhas | `segs` deixa de existir; o pico de RSS do `insere_paralela` cai pela metade em T=65.536 (100,47 → ~50 MB) |
+| **P8** | **Checkpointing no `c* = √(S/k)`** | 27×–443× de RAM nasativações, a **+33%** de tempo | 1 flag | `modelo_ram.py` com `c*` produz M* como previsto (0,26 MB em S=256) |
+| **P9** | **Filtro de split de avaliação** no `StreamingCorpus` | elimina o vazamento eval→treino (10/39 fontes) | ~15 linhas | nenhum registro de split `validation`/`test` chega ao corpus de treino |
+| **P10** | **Corrigir o split `"lite"`** (usar `train` ou o split real) | recupera a fonte Fable | 1 linha | a fonte passa de 0 para N>0 registros no corpus real |
+| **P11** | **Normalização Unicode no ponto de entrada** (`unicodedata.normalize("NFC", ...)`) | elimina o risco latente de custo de tokens e de dedup errado | 3 linhas | 100% dos textos canônicos; dedup estável entre NFC/NFD |
+| **P12** | **Tornar a suíte do repo executável sem torch** (20/20 arquivos falham por import) | 20 arquivos de teste voltam a ser uma rede de segurança | ~2 h | `pytest` coleta e roda sem torch, ou falha com mensagem clara |
+| **P13** | **Camada de backend** (§7.3) | portabilidade para NPU/DCU | ~1 h + 19 call sites | `backend_disponivel()` funciona em CPU e não referencia `torch.cuda` |
+| **P14** | **Recalcular as métricas de capa** com o config entregue | o README deixa de descrever um modelo de 237 camadas que não existe | ~1 h | todo número do README tem `arquivo:linha` + comando de reprodução |
+| **P15** | **Corrigir os scripts de prova**: `np.trapz` → `np.trapezoid`; `ent_rel` recebendo vetor; `assert` em vez de print | a suíte de verificação volta a ser confiável | ~1 h | os 9 scripts rodam com numpy ≥ 2 e falham com exit ≠ 0 quando um invariante quebra |
+| **P16** | **Corrigir o docstring do Lipschitz** (`vit_lra.py:201-203`) | documentação coerente com o teorema | 3 linhas | o docstring cita o bound `(mx+mn+2ε)/(mx+ε)²` e o caso do clipe saturado |
+
+### 8.1 Aprimoramento matemático adicional (novo, não estava em nenhum relatório)
+
+**Escolha ótima de `τ_min` pelo critério de taxa–distorção.** O projeto usa
+`ajustar_k_tau_min` com `tau_min_barreira = 0,25` fixo. Num modelo
+`y = softmax(l + τu)` com `u ~ Gumbel(0,1)`, o ruído equivale a ruído
+multiplicativo de escala `τ` sobre os logits. Para um alvo `y*` com entropia `H(y*)`,
+o erro esperado da distorção é
+```
+D(τ) = E_{u}‖softmax(l + τu) − y*‖²
+     ≈ τ²·‖∇(KL(y*‖softmax(l)))‖² + O(τ⁴)      (Taylor de segunda ordem)
+```
+e o ruído de amostragem do Gumbel é `O(τ²)`. O ponto ótimo equilibra
+**viés** (a passagem para τ grande satura e o viés cresce) e **variância**
+(o ruído `O(τ²)`), o que dá `τ_min* = Θ(1/‖∇KL‖)` — isto é, **o `τ_min` ótimo
+cresce com a sharpness do alvo**, exatamente o oposto de um piso fixo.
+O valor fixo 0,25 é arbitrário do ponto de vista da taxa–distorção e deveria ser
+substituído por `τ_min*(K, H(y*))` calibrado nas métricas reais de perplexidade —
+ou, no mínimo, por um sweep de `τ_min ∈ {0,05 … 0,5}` medindo perplexidade e
+`δ_ort` (o doc 27 já tem o ferramental: `ajustar_k_tau_min` + `δ_ort`).
+
+**Cuidado:** isto é uma proposta com hipótese explícita (a expansão de 2ª ordem
+assume `‖τu‖` pequeno em relação à folga dos logits). O critério de aceite é
+empírico, não teórico: `τ_min` escolhido por sweep deve melhorar a perplexidade
+**sem** degradar `δ_ort` além de `1e-5` — se não melhorar, a proposta é
+refutada e o piso fixo permanece.
+
+---
+
+## 9. Plano em fases
+
+### Fase 0 — Corrigir o que invalida resultados publicados (1 dia)
+P1, P2, P3, P15, P16. Sem depender de hardware, sem mudar API pública.
+**Aceite:** `verif_pcgrad_invariantes.py` e `verif_cinza_lipschitz.py` com 0
+violações; `validacao.py` reprova `n_camadas=3`; `v05`/`v08` rodam sem crash;
+`git diff` só toca os arquivos listados.
+**Rollback:** `git checkout` dos arquivos (o espelho do HF nunca foi tocado).
+
+### Fase 1 — Corrigir a tubulação de dados e a persistência (2 dias)
+P4, P5, P6, P9, P10, P11, P12.
+**Aceite:** corpus real de ≥ 2.100 registros com ≤ 10% de dedup; `n_camadas=3`
+reprovado na validação; `anexar()` com `size` divergente levanta erro; nenhum
+registro de split de avaliação no corpus de treino; `pytest` coleta sem torch.
+**Rollback:** as correções são cópias em `correcoes/`; basta não copiá-las.
+
+### Fase 2 — RAM e throughput (2 dias)
+P7, P8 + medir.
+**Aceite:** pico de RSS do `insere_paralela` cai ~2× em T=65.536 (medido com
+`resource.getrusage`); `c*` produz a memória prevista em `modelo_ram.py`;
+tabela de §6.4 reproduzida com o mesmo script.
+
+### Fase 3 — Portabilidade (3–5 dias)
+P13 + recompilar as 5 extensões Cython por plataforma + desligar int8 em
+backends sem kernel.
+**Aceite:** `backend_disponivel()` retorna o backend correto em cada máquina de
+teste; `python setup.py build_ext --inplace` produz `.so` importável no Python
+da máquina; o mesmo corpus roda em CPU, Ascend e (se houver) DCU com perplexidade
+dentro de 1% da CPU.
+
+### Fase 4 — Blindar o que é publicado (1 dia)
+P14 + reescrever os números de capa do README com `arquivo:linha` e comando de
+reprodução; corrigir "18/18" para "17/18" até `peso_moe` existir.
+**Aceite:** cada número do README tem um comando que o reproduz; `README` e
+`RELATORIO_KHTST` não citam mais 237 camadas com 3 camadas no config.
+
+---
+
+## 10. O que **não** fazer (anti-goals)
+
+| Anti-goal | Por quê |
+|---|---|
+| **Não** trocar `float64` por `float32` esperando ganho de RAM | o próprio agente mediu: o ganho real é ≤ 1,5 kB (arrays de 48 B a 4 kB). O custo de RAM está em A-08/A-17 e na janela paralela |
+| **Não** "consertar" a divergência de capacidade do IPC (A-10) | foi refutado: a função comparada é código morto. O bug real é outro (capacidade do header nunca lida) |
+| **Não** reativar a atenção GLOBAL para contexto longo | `O(B·H·S²)`: 19,8 TB de scores com S=262.144. A janela não é opcional |
+| **Não** usar `np.trapz` em scripts novos | removido no numpy ≥ 2 (achado meu) |
+| **Não** reportar "18/18" | `peso_moe` é órfão; é 17/18 |
+| **Não** publicar `RAM pico 3.066 MB` | é impossível como pico absoluto e coincide com o tamanho do corpus em bytes |
+| **Não** confiar em `assert` inexistente como "check verde" | os 9 scripts de verificação não têm um único `assert`: nada aborta quando um invariante quebra |
+| **Não** recompilar as extensões e commitar `.so` no HF | ABI por plataforma; o repo já carrega `.so` de cpython-312 que não rodam fora do build original |
+
+---
+
+## 11. Índice de evidências (tudo executável)
+
+| Evidência | Caminho |
+|---|---|
+| Meus scripts de verificação | `minha_verificacao/verif_pcgrad_invariantes.py`, `verif_pcgrad_rope.py`, `verif_cinza_lipschitz.py`, `modelo_ram.py` |
+| Saídas dos meus scripts | `minha_verificacao/saida_*.txt` |
+| Relatórios dos agentes | `relatorios/t1…t5*.md`, `relatorios/verify_t*.md` |
+| Scripts + saídas dos agentes | `verificacao/v0*.py`, `verificacao/out_v0*.txt`, `verificacao/t4_p*.py`, `verificacao/saidas/` |
+| Correções prontas (36, compilam) | `correcoes/` |
+| Correção do PCGrad com sinal certo | `minha_verificacao/CORRECAO_A01_PCGrad.md` |
+| Espelho intacto do HF | `repo/` (git status vazio) |
+| Corpus real que eu coletei | `verificacao/saidas/corpus_real_mini.jsonl` (1.812 registros, 3,08 MB) |
+
+---
+
+## 12. Como executar
+
+Ver `EXECUTAVEL.md` (guia passo a passo). Resumo do ambiente que usei:
+Python 3.11.2, 2 cores, ~3 GB RAM, sem GPU, sem torch; `pip` precisa de
+`--index-url https://pypi.org/simple` (o mirror padrão do sandbox está vazio);
+as extensões `.so` do repo são cpython-312 e **não importam** neste ambiente —
+todo caminho testado é o Python puro.

auditoria_independente/README.md

@@ -0,0 +1,30 @@
+# Auditoria independente — provas numpy-puras (hardened v23)
+
+Scripts de verificação produzidos pela **auditoria independente** de 2026-10-17
+(agentes externos; originais em `minha_verificacao/` do auditório), integrados
+e **HARDENED no v23**: cada verificação termina em `assert` (P15 — os
+originais só imprimiam; um invariante quebrado não abortava nada) e o exit
+code reflete o resultado (`0` verde, `1` violação).
+
+Executáveis em ambiente SEM torch (numpy puro) — o mesmo caminho que a
+auditoria usou para auditar o projeto sem instalar dependências.
+
+| Script | O que prova | v23 |
+|---|---|---|
+| `verif_pcgrad_invariantes.py` | PCGrad: 3 variantes × invariantes I1/I2/I3 de Yu et al. (2020); só `fator = dot/n2` com `ga − fator·gm` satisfaz os três | correção **APLICADA** em `treino/cirurgia_grad.py` (Teo 35.1) |
+| `verif_pcgrad_rope.py` | A) o código antigo violava "nenhuma tarefa piora" em 25,3% dos conflitos; B) RoPE sem offset ⟹ score CONSTANTE em t | correções **APLICADAS** (Teos 35.1/35.8); prova torch ao vivo: `tests/test_khtst_v23.py` §1–§2 |
+| `verif_cinza_lipschitz.py` | Teo 27.7(ii-a) VÁLIDO (razão ≤ 1); docstring antigo "2δ" FALSO (45×) | docstring **CORRIGIDO** em `percepcao/vit_lra.py` (P16) |
+| `modelo_ram.py` | Modelo de RAM analítico; ponto ótimo de checkpointing `c* = √(S/k)`; orçamento por RAM | seção de incoerências agora DINÂMICA vs `configs/base.json` (L=6 no v23) |
+
+Executar:
+
+```bash
+python3 verif_pcgrad_invariantes.py && \
+python3 verif_pcgrad_rope.py && \
+python3 verif_cinza_lipschitz.py && \
+python3 modelo_ram.py && echo "AUDITORIA 4/4 VERDE"
+```
+
+Regra da casa (do PLANO_MELHORIAS_KHTST.md §11, mantida): cada número impresso
+é `MEDIDO` (saída executada) ou `TEÓRICO` (consequência de teorema) — claims
+refutadas não voltam como válidas.

auditoria_independente/modelo_ram.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""MODELO DE MEMÓRIA (RAM) DO KHTST — a partir do config REAL e do código
+real. numpy puro, sem torch. HARDENED v23 (P15): asserts + exit code.
+
+Objetivo: dar um número honesto de RAM para treino e inferência, e provar o
+ponto ótimo de checkpointing (c* = √(S/k), M* = 2H√(kS) — prova no doc 35 §6).
+
+Fontes de verdade lidas:
+  configs/base.json                    (config shipped)
+  src/khtst/mamba3/tronco.py           (CamadaTroncoM3, NoPE em (i+1)%6==0)
+  src/khtst/memoria/janela_1m.py       (janela paralela: m_max, segs, buffers)
+  src/khtst/percepcao/atencao.py       (aplicar_rope, KV-cache kv_max)
+
+v23: o caminho do repo é derivado do PRÓPRIO script (não mais do espelho do
+auditório) e a seção de incoerências virou VERIFICAÇÃO DINÂMICA contra o
+config entregue — com n_camadas=6 (v23) o contrato 5:1 EXISTE (1 NoPE).
+"""
+import json
+import math
+import os
+import sys
+
+REPO = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+CFG = json.load(open(os.path.join(REPO, "configs", "base.json"),
+                     encoding="utf-8"))
+
+M = CFG["modelo"]
+D = int(M["d_modelo"])
+L = int(M["n_camadas"])
+DFF = int(M["d_ff"])
+VOCAB = int(M["vocab"])
+NCAB = int(M["n_cabecas"])
+DK = D // NCAB
+KV_MAX = int(M["kv_cache_max"])
+J = CFG["janela_1m"]
+LOTE = int(CFG["treino"]["lote"])
+W_SEG = int(J["w_segmento"])
+S_PASSO = int(J["s_passo"])
+L_FINO = int(J["l_fino"])
+N_MAX = int(J["n_max_tokens"])
+COMP_SAIDA = int(J["comprimento_saida"])
+JANELA_W = int(J["janela_w"])
+JANELA_E = int(J["janela_e"])
+B4 = 4  # bytes por float32
+
+
+def linha(t=""):
+    print(t)
+
+
+# --------------------------------------------------------------------------
+# 1) PARÂMETROS (contagem analítica a partir do código)
+# --------------------------------------------------------------------------
+def params_analiticos():
+    p = {}
+    p["embedding"] = VOCAB * D                      # dicionário de tokens
+    p["embedding_saida"] = 0                        # lm_head amarrado (compartilha)
+    # por camada do tronco (CamadaTroncoM3):
+    #   atenção NoPE: Wq,Wk,Wv,Wo -> 4*d^2
+    #   Mamba3: proj in/out + SSM (d_estado*rank) — ver doc 22
+    d_estado = int(M["mamba3"]["d_estado"])
+    rank = int(M["mamba3"]["rank_mimo"])
+    attn = 4 * D * D
+    mamba = 2 * D * D + d_estado * rank * D + D * d_estado
+    ffn = 2 * D * DFF
+    # micro-FFN por camada (camadas micro)
+    micro = 2 * D * DFF if L >= 1 else 0
+    p["camada_atencao"] = attn
+    p["camada_mamba3"] = mamba
+    p["camada_ffn"] = ffn
+    p["camada_micro"] = micro
+    p["por_camada_total"] = attn + mamba + ffn + micro
+    # NoPE: (i+1)%6==0 -> com L=6 => 1 NoPE (contrato 5:1 existente no v23)
+    n_nope = sum(1 for i in range(L) if (i + 1) % 6 == 0)
+    p["n_nope"] = n_nope
+    p["n_mamba"] = L - n_nope
+    p["total_tronco"] = L * p["por_camada_total"]
+    p["total"] = p["embedding"] + p["total_tronco"]
+    return p
+
+
+P = params_analiticos()
+
+# --------------------------------------------------------------------------
+# 2) MODELO DE MEMÓRIA
+# --------------------------------------------------------------------------
+def estado_do_otimizador(n_param):
+    """Pesos fp32 + grads fp32 + momento Muon (1x) + AdamW (m,v = 2x).
+    Muon e AdamW sao aplicados em subconjuntos disjuntos na prática; aqui
+    mostramos os dois cenários."""
+    return {
+        "pesos": 4 * n_param,
+        "grads": 4 * n_param,
+        "muon_mom": 4 * n_param,
+        "adamw_mv": 8 * n_param,
+    }
+
+
+def ativacoes(B, S, k_salvos=12, c=None):
+    """Ativações do tronco.
+    Sem checkpointing: k_salvos tensores (B,S,H) por camada.
+    Com checkpointing de segmento c: guarda-se 1 tensor por segmento
+    (B,c,H) + o buffer de recomputação (B,c,H)*k_salvos."""
+    if c is None:
+        return k_salvos * B * S * D * B4 * L
+    segs = max(1, math.ceil(S / c))
+    guardado = segs * B * c * D * B4 * L          # 1 tensor por segmento
+    recompute = B * c * D * B4 * k_salvos * L      # buffer de recomputação
+    return guardado + recompute
+
+
+def kv_cache(B, S_kv):
+    return 2 * B * NCAB * S_kv * DK * B4 * L      # K e V, por camada
+
+
+def janela_paralela_buffers(T_chunk, B=1):
+    """Janela paralela 1M: 'segs' do MAP paralelo + buffers z/utilidade +
+    grade SOM.  medido do código (insere_paralela / __init__)."""
+    m_max = max(1, (N_MAX - L_FINO) // max(1, S_PASSO)) + 1
+    lado = max(16, min(128, int(math.sqrt(m_max)) + 1))
+    M_win = 1 if T_chunk <= W_SEG else (T_chunk - W_SEG) // S_PASSO + 1
+    segs = M_win * W_SEG * D * B4 * B            # (M, w_seg, d) materializado
+    mascara = M_win * W_SEG * B                  # bool (1 B)
+    z = m_max * D * B4                           # buffer de resumo
+    util = m_max * B4
+    grade = lado * lado * D * B4                 # grade SOM
+    return {"segs": segs, "mascara": mascara, "z": z, "grade": grade,
+            "m_max": m_max, "lado": lado, "M_win": M_win}
+
+
+def pesos_fusao(n):
+    K = 1 if n <= JANELA_W else int(math.ceil((n - JANELA_W) / JANELA_E)) + 1
+    return K * n * B4, K
+
+
+# --------------------------------------------------------------------------
+# 3) PROVA DO PONTO ÓTIMO DE CHECKPOINTING (doc 35 §6)
+# --------------------------------------------------------------------------
+def ponto_otimo_checkpointing(S, k_salvos=12, k_min=1):
+    """Minimiza M(c) = H*(S/c + k*c) -> c* = sqrt(S/k), M* = 2H*sqrt(k*S).
+    Tempo: T(c) = 3 (fwd+bwd) + 1 (recompute do último segmento) = 4 unidades,
+    INDEPENDENTE de c -> overhead constante de +33%."""
+    c_star = math.sqrt(S / max(1, k_salvos * k_min))
+    M_star = 2 * D * B4 * math.sqrt(k_salvos * k_min * S) * L
+    M_0 = k_salvos * D * B4 * S * L
+    return c_star, M_star, M_0
+
+
+def main():
+    linha("=" * 92)
+    linha("MODELO DE RAM DO KHTST — derivado do config e do código REAIS")
+    linha("=" * 92)
+    linha(f"repo: {REPO}")
+    linha(f"config: d={D} L={L} d_ff={DFF} vocab={VOCAB} n_cabecas={NCAB} dk={DK}")
+    linha(f"        kv_max={KV_MAX}  lote={LOTE}  janela: n_max={N_MAX} "
+          f"saida={COMP_SAIDA}")
+    linha(f"        w_segmento={W_SEG} s_passo={S_PASSO} l_fino={L_FINO} "
+          f"janela_w={JANELA_W} janela_e={JANELA_E}")
+    linha()
+    linha("--- 1) PARAMETROS (contagem analitica) ---")
+    for k, v in P.items():
+        if isinstance(v, int):
+            linha(f"  {k:22s} = {v:>12,}  ({v*4/1e6:8.3f} MB fp32)")
+    linha(f"  >> NoPE no tronco: {P['n_nope']}  (padrão (i+1)%6==0, L={L})")
+    linha(f"  >> Camadas Mamba: {P['n_mamba']}")
+    linha()
+
+    # ---- HARDENED: o contrato 5:1 é verificável analiticamente aqui ----
+    assert L % 6 == 0, \
+        f"n_camadas={L} deve ser múltiplo de 6 (contrato 5:1 — Teo 35.5)"
+    assert P["n_nope"] == L // 6, \
+        f"NoPE esperado {L//6}, obtido {P['n_nope']}"
+
+    linha("--- 2) ESTADO DO MODELO + OTIMIZADOR ---")
+    est = estado_do_otimizador(P["total"])
+    tot = sum(est.values())
+    for k, v in est.items():
+        linha(f"  {k:22s} = {v/1e6:8.3f} MB")
+    linha(f"  {'TOTAL (4x)':22s} = {tot/1e6:8.3f} MB")
+    linha()
+
+    linha("--- 3) ATIVACOES e PONTO OTIMO DO CHECKPOINTING ---")
+    for S in (256, 1024, 4096, 16384, 65536):
+        c_star, M_star, M_0 = ponto_otimo_checkpointing(S)
+        linha(f"  S={S:>6}  sem ckpt={M_0/1e6:9.2f} MB | c*={c_star:7.1f} "
+              f"-> M*={M_star/1e6:8.2f} MB | ganho={M_0/M_star:5.1f}x "
+              f"| overhead de tempo = +33% (independente de c)")
+        # HARDENED: M(c) tem mínimo em c* — verifica a forma da prova
+        def M_c(c, S=S):
+            return D * B4 * L * (S / max(1.0, c) + 12.0 * c)
+        m_ot = M_c(c_star)
+        m_menos = M_c(max(1.0, c_star / 2.0))
+        m_mais = M_c(c_star * 2.0)
+        assert m_ot <= m_menos + 1e-6 and m_ot <= m_mais + 1e-6, \
+            f"c*={c_star} não é mínimo: M(c*)={m_ot} M(c*/2)={m_menos} " \
+            f"M(2c*)={m_mais}"
+        assert M_star <= M_0, "checkpointing deve reduzir a memória"
+    linha("  [assert] c* = √(S/k) é mínimo de M(c) em todos os S ✓")
+
+    linha()
+    linha("--- 4) JANELA PARALELA 1M (o termo dominante em inferência longa) ---")
+    for T in (512, 4096, 16384, 65536):
+        j = janela_paralela_buffers(T, B=1)
+        tot_j = j["segs"] + j["mascara"] + j["z"] + j["grade"]
+        linha(f"  chunk T={T:>6}: segs={j['segs']/1e6:8.2f} MB  "
+              f"(M={j['M_win']} janelas de {W_SEG} com passo {S_PASSO} -> "
+              f"redundância W/s={W_SEG/S_PASSO:.0f}x)")
+        linha(f"              z(m_max={j['m_max']})={j['z']/1e6:6.2f} MB  "
+              f"grade SOM({j['lado']}^2)={j['grade']/1e6:6.2f} MB  "
+              f"TOTAL fixo={tot_j/1e6:6.2f} MB")
+        # HARDENED: nº de cópias de tokens = M_win·W ≈ T·(W/s) com erro ≤ W
+        # (prova da redundância 2× — doc 35 §6: M·W = (T/s)·W = T·(W/s))
+        copias = j["M_win"] * W_SEG
+        alvo = T * (W_SEG / S_PASSO)
+        assert abs(copias - alvo) <= W_SEG + 1e-9, \
+            f"cópias={copias} difere de T·(W/s)={alvo} além da folga W={W_SEG}"
+    linha("  [assert] segs = T·(W/s)·d·4 confirmado (redundância 2× da janela)")
+    pf, K = pesos_fusao(N_MAX)
+    linha(f"  pesos_fusao(n={N_MAX}): K={K} janelas -> {pf/1e6:.2f} MB "
+          f"(tensor denso (K,n))")
+    pf2, K2 = pesos_fusao(N_MAX + COMP_SAIDA)
+    linha(f"  pesos_fusao(n={N_MAX+COMP_SAIDA}): K={K2} -> {pf2/1e6:.2f} MB")
+    linha()
+
+    linha("--- 5) TABELA DE ORÇAMENTO POR RAM DISPONÍVEL (treino, fp32) ---")
+    linha("  modelo: estado 4xP + ativações(c) + scores da atenção + KV + janela")
+    linha("  atenção: JANELA (raio r=128) -> scores O(B*H*S*(2r+1)); a variante")
+    linha("  GLOBAL é O(B*H*S²) e INVIÁVEL a partir de ~2k tokens:")
+    for S in (2048, 8192, 32768, 262144):
+        sg = LOTE * NCAB * S * S * B4 * L
+        linha(f"    S={S:>7}: scores GLOBAL = {sg/1e9:12.2f} GB   "
+              f"JANELA(r=128) = {LOTE*NCAB*S*257*B4*L/1e9:8.3f} GB")
+    est_total = sum(estado_do_otimizador(P["total"]).values())
+    R = 128
+    for orc in (3, 8, 16, 24, 48, 96):
+        orc_b = orc * 1024 ** 3
+        disp = orc_b - est_total
+        # termo 1: scores da janela (linear em S)
+        por_token = LOTE * NCAB * (2 * R + 1) * B4 * L
+        s_scores = int(disp / por_token)
+        # termo 2: ativações sem checkpointing
+        s_ativ = int(disp / (LOTE * D * B4 * 12 * L)) if disp > 0 else 0
+        # termo 3: KV (trunca em kv_max) — constante
+        kv = kv_cache(LOTE, KV_MAX)
+        # termo 4: janela paralela (MAP paralelo) — linear em T
+        jw = janela_paralela_buffers(1, LOTE)["segs"]
+        s_janela = int(disp / max(1, jw)) if jw else 10 ** 9
+        S_ok = min(s_scores, s_ativ, s_janela)
+        c_star, M_star, _ = ponto_otimo_checkpointing(max(1, S_ok))
+        linha(f"  {orc:>3} GB | estado={est_total/1e9:6.3f} GB | "
+              f"KV={kv/1e6:6.1f} MB | "
+              f"S_max (scores)={s_scores:>9,} | (ativ.)={s_ativ:>9,} | "
+              f"(janela)={s_janela:>9,} | S viável={S_ok:>9,} | "
+              f"c*={c_star:5.0f}")
+    linha()
+
+    linha("--- 6) VERIFICAÇÃO DINÂMICA config-vs-README (v23) ---")
+    linha(f"  config/base.json AGORA: modelo.n_camadas = {L} (múltiplo de 6 "
+          f"— {'OK' if L % 6 == 0 else 'VIOLA Teo 35.5'})")
+    linha(f"  tronco instancia {P['n_mamba']} Mamba + {P['n_nope']} NoPE = "
+          f"proporção {P['n_mamba']}:{P['n_nope']} — o contrato 5:1 do README")
+    linha("  EXISTE no config entregue desde o v23 (antes: L=3 ⟹ 0 NoPE —")
+    linha("  achado A-04 da auditoria; corrigido com validação no campo REAL).")
+    linha(f"  NOTA histórica: os números '237 camadas / 78,8 MB / 3,92×' do")
+    linha(f"  README antigo descreviam outro modelo — corrigidos no card v23")
+    linha(f"  (P14: números de capa com proveniência arquivo:linha).")
+    assert L % 6 == 0
+
+    linha()
+    linha("--- 7) 'RAM pico 3.066 MB' do README antigo (achado E-08) ---")
+    linha("  python3 + numpy já usa ~29,5 MB de RSS; o doc 28 declarava")
+    linha("  78,8 MB de pesos: um pico ABSOLUTO de 3,066 MB é impossível —")
+    linha("  o número coincidia com o tamanho do CORPUS em bytes. O README")
+    linha("  v23 não repete esse número (P14 — números com reprodução).")
+    linha()
+    linha("VERIFICAÇÃO MODELO DE RAM: VERDE — asserts passaram")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

auditoria_independente/verif_cinza_lipschitz.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Teorema 27.7(ii) — Lipschitz do detector de cinza. numpy puro, sem torch.
+HARDENED v23 (P15): asserts + exit code.
+
+Claim do doc 27 §4 Teo 27.7(ii):
+  (a) ∂χ/∂I tem norma ≤ 2/(max_c+ε) + χ/(max_c+ε)
+  (b) para imagens bem-expostas (max ≥ m̄): |Δs| ≤ 2δ/m̄
+  (c) (docstring ANTIGO do código, v≤22) "χ é Lipschitz com constante
+      2/(max_c+ε) — perturbação δ muda s por ≤ 2δ"  ← FALSO (45× no pixel
+      quase-preto); o v23 CORRIGIU o docstring de percepcao/vit_lra.py
+      para o bound do TEOREMA (P16).
+
+χ(p) = (mx − mn)/(mx + ε),  s = 1 − mean(χ),  mx = max_c I_c, mn = min_c I_c
+
+Prova fechada (doc 35 §4): bound_doc − bound_real = 2(mx − mn)/(mx+ε)² ≥ 0
+"""
+import sys
+import numpy as np
+
+EPS = 1e-4
+
+
+def chi(img):
+    mx = img.max(axis=-1)
+    mn = img.min(axis=-1)
+    return (mx - mn) / (mx + EPS)
+
+
+def s_score(img):
+    return 1.0 - chi(img).mean()
+
+
+def deriva_analitica(mx, mn):
+    """∂χ/∂mx = (ε+mn)/(mx+ε)² ;  ∂χ/∂mn = −1/(mx+ε)."""
+    dmx = (EPS + mn) / (mx + EPS) ** 2
+    dmn = -1.0 / (mx + EPS)
+    return np.abs(dmx), np.abs(dmn)
+
+
+def main():
+    rng = np.random.default_rng(20261016)
+    print("=" * 78)
+    print("TESTE 1 — o bound (a) do doc 27 domina a derivada analítica real?")
+    print("=" * 78)
+    pior = 0.0
+    for _ in range(4000):
+        mx = rng.uniform(1e-4, 1.0)
+        mn = rng.uniform(0.0, mx)
+        c = (mx - mn) / (mx + EPS)
+        dmx, dmn = deriva_analitica(mx, mn)
+        real = dmx + dmn                      # norma do gradiente (L1 por canal)
+        doc = 2.0 / (mx + EPS) + c / (mx + EPS)
+        pior = max(pior, real / doc)
+    print(f"  max (derivada real)/(bound do doc) = {pior:.6f}  -> "
+          f"{'DOMINADO (bound válido)' if pior <= 1 else 'VIOLADO'}")
+    assert pior <= 1.0, "TEOREMA do doc 27 violado — o bound (a) não domina"
+
+    # forma fechada da prova: bound_doc − bound_real = 2(mx−mn)/(mx+ε)² ≥ 0
+    mx = rng.uniform(1e-3, 1.0, size=100_000)
+    mn = rng.uniform(0.0, 1.0, size=100_000) * mx
+    folga = 2.0 * (mx - mn) / (mx + EPS) ** 2
+    assert (folga >= 0).all(), "prova fechada: folga do bound deve ser ≥ 0"
+    print("  forma fechada: bound_doc − bound_real = 2(mx−mn)/(mx+ε)² ≥ 0 ✓")
+
+    print()
+    print("=" * 78)
+    print("TESTE 2 — (b) |Δs| ≤ 2δ/m̄  e  (c) |Δs| ≤ 2δ, por execução real")
+    print("=" * 78)
+    casos = [
+        ("brilho medio (0.5)", 0.5, 0.12),
+        ("brilho baixo  (0.05)", 0.05, 0.12),
+        ("brilho MUITO baixo (0.005)", 0.005, 0.12),
+        ("pixel quase preto (0.001)", 0.001, 0.12),
+    ]
+    viol_2delta = 0
+    for nome, base, amp in casos:
+        img = rng.uniform(base - amp / 2, base + amp / 2, size=(1, 1, 3))
+        img = np.clip(img, 0.0, 1.0)
+        mbar = max(float(img.mean()), 1e-12)   # pixels podem clipar a 0 —
+        # o bound (b) pressupõe imagem bem-exposta; no escuro ele é vazio
+        mx = float(img.max())
+        for delta in (1e-3, 1e-2, 5e-2):
+            pert = np.clip(img + rng.uniform(-delta, delta, size=img.shape),
+                           0, 1)
+            ds = abs(s_score(pert) - s_score(img))
+            b_doc = 2 * delta / (mx + EPS)     # bound (a) por pixel, agregado
+            b_mbar = 2 * delta / mbar          # bound (b) do doc
+            b_ingenuo = 2 * delta              # bound (c) do docstring ANTIGO
+            viol_2delta += int(ds > b_ingenuo)
+            print(f"  {nome:26s} delta={delta:<6} |Δs|={ds:.6f}  "
+                  f"bound(a)={b_doc:.6f} {'OK ' if ds <= b_doc else 'VIOL'} | "
+                  f"bound(b)={b_mbar:.6f} {'OK ' if ds <= b_mbar else 'VIOL'} | "
+                  f"2δ={b_ingenuo:.6f} {'OK ' if ds <= b_ingenuo else 'VIOL'}")
+    # o bound ingênuo 2δ DEVE ser violado em pixels escuros — é a razão da
+    # correção do docstring (P16). O TEOREMA (a) nunca é violado.
+    assert viol_2delta > 0, \
+        "esperado: bound ingênuo 2δ violado em pixels quase-pretos (docstring falso)"
+
+    print()
+    print("=" * 78)
+    print("TESTE 3 — pior caso construído: 1 canal sobe, pixel escuro")
+    print("=" * 78)
+    achou_violacao_2delta = False
+    for eps_i in (1e-3, 1e-2):
+        img = np.array([[[0.01, 0.01, 0.01]]])   # cinza exato -> s = 1
+        pert = img.copy()
+        pert[0, 0, 2] += eps_i                   # um canal sobe
+        ds = abs(s_score(pert) - s_score(img))
+        v1 = ds <= 2 * eps_i
+        v2 = ds <= 2 * eps_i / 0.01
+        achou_violacao_2delta |= (not v1)
+        print(f"  cinza 0.01 + delta {eps_i}: |Δs| = {ds:.6f} | "
+              f"2δ = {2*eps_i:.6f} -> {'OK' if v1 else 'VIOLADO (docstring antigo)'}"
+              f" | 2δ/m̄ = {2*eps_i/0.01:.6f} -> "
+              f"{'OK' if v2 else 'VIOLADO (bound (b))'}")
+    assert achou_violacao_2delta, \
+        "contra-exemplo 0,01+0,001 deve violar o 2δ do docstring antigo (45×)"
+
+    print()
+    print("=" * 78)
+    print("TESTE 4 — o bound (a) com max_c = max GLOBAL da imagem (outra leitura)")
+    print("=" * 78)
+    for _ in range(200):
+        img = rng.uniform(0, 1, size=(1, 8, 8, 3))
+        mx_global = img.max()
+        for delta in (1e-2, 5e-2):
+            pert = np.clip(img + rng.uniform(-delta, delta, size=img.shape),
+                           0, 1)
+            ds = abs(s_score(pert) - s_score(img))
+            b = 2 * delta / (mx_global + EPS)
+            assert ds <= b or b > 1.0, \
+                f"leitura global violada sem folga: ds={ds} b={b}"
+    print("  200 imagens × 2 deltas: |Δs| ≤ 2δ/(mx_global+ε) (ou trivialmente")
+    print("  satisfeito quando o bound > 1 — registrado como folga honesta)")
+
+    print()
+    print("VERIFICAÇÃO LIPSCHITZ (doc 27 Teo 27.7): VERDE — teorema válido;")
+    print("docstring do código CORRIGIDO no v23 (P16) para citar o bound real.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

auditoria_independente/verif_pcgrad_invariantes.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""PCGrad: três candidatos comparados contra os invariantes CORRETOS do
+Yu et al. (2020). numpy puro, sem torch. HARDENED v23 (P15): asserts + exit.
+
+Candidatos:
+  (1) CÓDIGO ANTIGO   (treino/cirurgia_grad.py v≤22, linhas 90-101)
+        fator = -dot/n2 ;  g = gm + fator*ga
+  (2) CORREÇÃO DO AGENTE AUDITOR (correcoes/.../cirurgia_grad.py:66-81)
+        fator = -dot/n2 ;  g = gm + (ga - fator*gm)
+  (3) CORREÇÃO CORRETA — APLICADA no v23 (Teo 35.1)
+        fator =  dot/n2 ;  g = gm + (ga - fator*gm)
+
+INVARIANTES DO PCGrad (2 tarefas, 1 par com conflito):
+  I1  <g_aux', g_main> = 0                      (ortogonalidade exata)
+  I2  ||g_aux'||^2 = ||g_aux||^2 - dot^2/||g_main||^2 <= ||g_aux||^2  (contração)
+  I3  <g_total, g_main> = ||g_main||^2 >= 0  e  <g_total, g_aux'> = ||g_aux'||^2 >= 0
+
+v23: a variante (3) É o código de produção desde o v23 — este script é a
+prova de regressão NUMÉRICA independente (a prova torch ao vivo está em
+tests/test_khtst_v23.py §1).
+"""
+import sys
+import numpy as np
+
+EPS = 1e-8
+
+
+def variante_1(gm, ga):
+    dot = float(gm @ ga)
+    n2 = float(gm @ gm)
+    p = dot < 0.0 and n2 > EPS
+    f = -dot / n2 if p else 0.0
+    return gm + (f * ga if p else ga), p
+
+
+def variante_2(gm, ga):
+    dot = float(gm @ ga)
+    n2 = float(gm @ gm)
+    p = dot < 0.0 and n2 > EPS
+    f = -dot / n2 if p else 0.0
+    return gm + (ga - f * gm if p else ga), p
+
+
+def variante_3(gm, ga):
+    dot = float(gm @ ga)
+    n2 = float(gm @ gm)
+    p = dot < 0.0 and n2 > EPS
+    f = dot / n2 if p else 0.0        # <== SINAL CORRETO (v23, Teo 35.1)
+    return gm + (ga - f * gm if p else ga), p
+
+
+def testa(n=200000, seed=20261016):
+    rng = np.random.default_rng(seed)
+    st = {k: {"I1": 0, "I2": 0, "I3": 0, "n": 0}
+          for k in ("atual", "agente", "correto")}
+    for _ in range(n):
+        gm = rng.normal(size=32)
+        ga = rng.normal(size=32)
+        dot = float(gm @ ga)
+        n2 = float(gm @ gm)
+        if dot >= 0 or n2 <= EPS:
+            continue
+        for nome, fn in (("atual", variante_1),
+                         ("agente", variante_2), ("correto", variante_3)):
+            g, p = fn(gm, ga)
+            aux_p = g - gm                       # componente auxiliar resultante
+            I1 = abs(float(aux_p @ gm)) <= 1e-9 * max(1.0, n2)
+            I2 = float(aux_p @ aux_p) <= float(ga @ ga) + 1e-9
+            I3 = (float(g @ gm) >= -1e-9) and (float(g @ aux_p) >= -1e-9)
+            st[nome]["n"] += 1
+            st[nome]["I1"] += not I1
+            st[nome]["I2"] += not I2
+            st[nome]["I3"] += not I3
+    return st
+
+
+def main():
+    print("=" * 78)
+    print("PCGrad — quem respeita os invariantes?")
+    print("=" * 78)
+    st = testa()
+    print(f"{'variante':10s} {'pares':>8s} {'viola I1':>10s} "
+          f"{'viola I2':>10s} {'viola I3':>10s}")
+    for k, v in st.items():
+        print(f"{k:10s} {v['n']:>8,} {v['I1']:>10,} {v['I2']:>10,} "
+              f"{v['I3']:>10,}")
+
+    # ---- HARDENED (P15): asserts + exit code ------------------------------
+    n_pares = st["correto"]["n"]
+    assert n_pares > 1000, f"amostra insuficiente de conflitos: {n_pares}"
+    assert st["correto"]["I1"] == 0 and st["correto"]["I2"] == 0 \
+        and st["correto"]["I3"] == 0, "variante CORRETA (v23) violou invariante"
+    assert st["agente"]["I1"] == st["agente"]["n"], \
+        "a correção do agente deveria violar I1 em 100% (conflito dobrado)"
+    assert st["atual"]["I1"] > 0.99 * st["atual"]["n"], \
+        "o código antigo deveria violar I1 em ~100% dos pares"
+
+    print()
+    print("  I1 = ortogonalidade exata <g_aux', g_main> = 0")
+    print("  I2 = contração ||g_aux'|| <= ||g_aux||")
+    print("  I3 = <g_total, g_main> >= 0 e <g_total, g_aux'> >= 0")
+    print()
+    print("  -> só a variante CORRETA (APLICADA no v23) satisfaz os três.")
+    print("  -> a 'correção do agente' (-dot/n2 com ga - fator*gm) produz")
+    print("     g_aux' = ga + (dot/n2)*gm => <g_aux',g_main> = 2*dot < 0:")
+    print("     o CONFLITO É DOBRADO, não removido.")
+    print()
+    print("=" * 78)
+    print("Contra-exemplo simbólico (gm=(1,0), ga=(-1,0)): conflito total")
+    print("=" * 78)
+    gm = np.array([1.0, 0.0])
+    ga = np.array([-1.0, 0.0])          # conflito total: dot = -1, ||gm||² = 1
+    ref = {}
+    for nome, fn in (("atual", variante_1), ("agente", variante_2),
+                     ("correto", variante_3)):
+        g, p = fn(gm, ga)
+        aux = g - gm
+        ref[nome] = g
+        print(f"  {nome:8s} g={g}  <aux,gm>={float(aux @ gm):+.3f}  "
+              f"||aux||={np.linalg.norm(aux):.3f}  (||ga||=1.000)")
+    # correta: g=(1,0), aux'=0 (componente conflitante REMOVIDA)
+    assert np.allclose(ref["correto"], [1.0, 0.0])
+    assert np.linalg.norm(ref["correto"] - gm) == 0.0
+    # agente: pior que o original — mantém o gradiente APONTANDO CONTRA gm
+    assert float((ref["agente"] - gm) @ gm) < 0.0
+    print("  PCGrad correto: g_aux' = ga − (dot/n2)·gm = (0,0) — ortogonal")
+    print("  a g_main e de norma 0 (a componente conflitante é removida).")
+    print()
+    print("VERIFICAÇÃO PCGrad (invariantes): VERDE — asserts passaram")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

auditoria_independente/verif_pcgrad_rope.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""dois achados críticos da auditoria independente (HARDENED v23, P15):
+   A) PCGrad em src/khtst/treino/cirurgia_grad.py — o que o código ANTIGO
+      (v≤22) fazia vs. o que o método promete  → CORRIGIDO no v23 (Teo 35.1)
+   B) RoPE em src/khtst/percepcao/atencao.py — posições reiniciavam a cada
+      passo de decodificação                    → CORRIGIDO no v23 (Teo 35.8)
+   numpy puro, sem torch. Provas torch ao vivo: tests/test_khtst_v23.py §1-§2.
+"""
+import sys
+import numpy as np
+
+print("=" * 78)
+print("A) PCGrad — treino/cirurgia_grad.py (v≤22, corrigido no v23)")
+print("=" * 78)
+print("""
+O código ANTIGO (v≤22):
+    dot   = <g_main, g_aux>                      (global, sobre todos os params)
+    fator = -dot / ||g_main||^2
+    g     = g_main + fator * g_aux                <-- ESCALA, nao projeta
+
+O PCGrad de verdade (Yu et al., 2020) para 2 tarefas — APLICADO no v23:
+    se <g_main, g_aux> < 0:
+        g_aux' = g_aux - (<g_aux, g_main>/||g_main||^2) * g_main
+        total  = g_main + g_aux'
+""")
+
+rng = np.random.default_rng(4242)
+violacoes_codigo = 0
+violacoes_pcgrad = 0
+N = 20000
+max_ratio = 0.0
+pares = 0
+for _ in range(N):
+    gm = rng.normal(size=64)
+    ga = rng.normal(size=64)
+    if float(gm @ ga) >= 0:
+        continue
+    pares += 1
+    dot = float(gm @ ga)
+    n2 = float(gm @ gm)
+    fator = -dot / n2
+    g_codigo = gm + fator * ga                       # o que o código ANTIGO fazia
+    g_pcgrad = gm + (ga - (dot / n2) * gm)           # PCGrad correto (v23)
+    # garantia do método: <g_total, g_main> >= 0  e  <g_total, g_aux'> >= 0
+    violacoes_codigo += int(float(g_codigo @ ga) < 0)
+    violacoes_pcgrad += int(float(g_pcgrad @ ga) < 0)
+    if n2 > 0:
+        max_ratio = max(max_ratio, abs(float(g_codigo @ ga)) / max(abs(dot), 1e-12))
+print(f"  pares com conflito (dot<0) testados   : {pares}")
+print(f"  violações da garantia por g_codigo    : {violacoes_codigo}  "
+      f"({100*violacoes_codigo/pares:.1f}%)")
+print(f"  violações da garantia por g_pcgrad    : {violacoes_pcgrad}")
+print(f"  max |<g_codigo,g_aux>| / |<gm,ga>|    : {max_ratio:.3f}")
+print()
+print("  INTERPRETAÇÃO: o código antigo não PROJETAVA nada — reescalava g_aux")
+print("  por um escalar. A garantia 'nenhuma tarefa piora' era violada em")
+print("  ~25% dos conflitos e o pior caso AMPLIAVA a direção conflitante.")
+assert violacoes_codigo > 0.15 * pares, \
+    "esperado ~25% de violações do código antigo — número mudou?"
+assert violacoes_pcgrad == 0, \
+    "o PCGrad correto NÃO deve violar a garantia em nenhum par"
+
+print()
+print("=" * 78)
+print("B) RoPE — percepcao/atencao.py (v≤22, corrigido no v23 com `desloc`)")
+print("=" * 78)
+print("""
+    pos = torch.arange(T)          # <-- SEM offset de posição (v≤22)
+    ang = torch.outer(pos, freqs)
+Em decodificação com KV-cache, T=1 por passo => pos=[0] SEMPRE.
+""")
+
+
+def rope(pos, dim=8, base=10000.0):
+    freqs = base ** (-np.arange(0, dim, 2) / dim)
+    ang = np.outer(np.asarray(pos, dtype=float), freqs)
+    return np.cos(ang), np.sin(ang)
+
+
+def rot(x, c, s):
+    x1, x2 = x[..., 0::2], x[..., 1::2]
+    out = np.stack((x1 * c - x2 * s, x1 * s + x2 * c), axis=-1)
+    return out.reshape(*out.shape[:-2], out.shape[-2] * out.shape[-1])
+
+
+dim = 8
+rng2 = np.random.default_rng(7)
+q = rng2.normal(size=(1, 1, 1, dim))   # 1 token novo
+k_cached = rng2.normal(size=(1, 1, 5, dim))  # cache com 5 tokens posicionados
+
+print("  passo t: query nova (T=1) e keys do cache (posições 0..4)")
+print("  " + "-" * 66)
+scores_sem = []
+scores_com = []
+for t in (1, 2, 3, 10):
+    # o código ANTIGO: a query nova e a key nova recebem pos=0
+    c0, s0 = rope([0], dim)
+    q_rot = rot(q, c0, s0)
+    cc, sc = rope(np.arange(5), dim)
+    k_rot = rot(k_cached, cc, sc)
+    # o que o v23 FAZ: a query nova na posição t (offset = nº de tokens no cache)
+    ct, st_ = rope([t], dim)
+    q_corr = rot(q, ct, st_)
+    dot_codigo = float((q_rot * k_rot).sum(-1).max())
+    dot_corr = float((q_corr * k_rot).sum(-1).max())
+    scores_sem.append(dot_codigo)
+    scores_com.append(dot_corr)
+    print(f"  t={t:<3} <q_rot,k_rot> antigo={dot_codigo:+.6f}  "
+          f"v23 (offset)={dot_corr:+.6f}  "
+          f"{'IDÊNTICO (bug invisível)' if abs(dot_codigo-dot_corr) < 1e-12 else 'DIVERGE'}")
+print()
+print("  CONCLUSÃO: sem offset, o offset relativo (t − j) virava (0 − j): a")
+print("  posição RELATIVA entre o token novo e o cache era destruída — o")
+print("  score era CONSTANTE em t. O v23 restaura o referencial compartilhado.")
+assert len(set(np.round(scores_sem, 9))) == 1, \
+    "sem offset o score deveria ser CONSTANTE em t (bug A-03)"
+assert max(abs(a - b) for a, b in zip(scores_com, scores_com[1:])) > 1e-6, \
+    "com offset o score deve VARIAR com t (correção A-03/P2)"
+print()
+print("  Correção aplicada no v23: aplicar_rope(q, k, desloc=posição_absoluta)")
+print("  e os chamadores propagam o número de tokens já no cache.")
+print()
+print("VERIFICAÇÃO PCGrad+RoPE: VERDE — asserts passaram")
+
+if __name__ == "__main__":
+    sys.exit(0)

configs/base.json

@@ -2,7 +2,7 @@
   "modelo": {
     "vocab": 16384,
     "d_modelo": 192,
-    "n_camadas": 3,
+    "n_camadas": 6,
     "n_cabecas": 4,
     "d_ff": 512,
     "comprimento_ctx": 256,

docs/matematica/26-gsq-rco-stiefel-riemanniano.md

@@ -123,16 +123,27 @@ telemetria (`gsq_rco/entropia`; medido: 0.907 → 0.160 em 400 passos).
 **Teorema 26.5 (agendador e o AJUSTE ANALÍTICO dos hiperparâmetros).**
 τ(t) = τ_min + (τ_0 − τ_min)·e^{−t/T_τ}. Então:
 (i) monotônico decrescente com τ(t) ∈ [τ_min, τ_0] (∀t ≥ 0);
-(ii) Σ_{t=0}^{T} 1/τ(t) ≤ (T_τ/(τ_0−τ_min))·(e^{T/T_τ} − 1) + (T−t*)/τ_min
-< ∞ — o somatório de gradientes do regime quase-disco é FINITO (treino
-estável com lr constante);
+(ii) Σ_{t=0}^{T} 1/τ(t) — **ERRATA v23 (Teo 35.12, achado E-01 da
+auditoria independente): a série DIVERGE**. Como τ(t) ≥ τ_min > 0,
+temos 1/τ(t) ≥ 1/τ_0 > 0 ⟹ Σ_{t≤T} 1/τ(t) ≥ T/τ_0 → ∞ linear
+(medido na suíte v23 §9a com os defaults do projeto, T=10⁶:
+S = 3.998.685 ≈ T/τ_min = 4·10⁶). A conclusão correta
+do regime quase-disco é: o passo por etapa é LIMITADO (1/τ(t) ≤
+1/τ_min) mas o acumulado não é finito — estabilidade do treino NÃO
+depende dessa finitude (o que importa é o passo por etapa e o
+declínio de τ; a alegação original "< ∞" era falsa e foi removida);
 (iii) **inversão exata**: t*(δ) = T_τ·ln((τ_0 − τ_min)/δ) é o instante em
 que τ chega a δ de τ_min ⟹ dado o horizonte de treino t_alvo e a folga δ,
 o T_τ correto é
     T_τ = t_alvo / ln((τ_0 − τ_min)/δ)                    (eq. 26.10)
 Defaults do projeto: τ_0 = 2.0 (softmax suave — exploração), τ_min = 0.25
-(barreira ≤ 2.0), δ = 0.05, t_alvo = 600 passos ⟹ T_τ = 600/ln 7 ≈ 308.1
-(medido: τ(600) = 0.300, t*(0.05) = 600.0 exato).
+(barreira ≤ 2.0), δ = 0.05, t_alvo = 600 passos ⟹ **T_τ =
+600/ln((2,0−0,25)/0,05) = 600/ln 35 ≈ 168,76** (ERRATA v23, achado E-02:
+o texto antigo dizia "600/ln 7 ≈ 308,1" — o ln correto do quociente
+(τ_0−τ_min)/δ = 35 é ln 35 = 3,5553, não ln 7; o valor MEDIDO τ(600) =
+0,300 confirma a avaliação correta: 0,25 + 1,75·e^{−600/168,76} = 0,300
+exato, enquanto T_τ = 308,1 daria τ(600) = 0,500 — a medição sempre
+estava do lado da fórmula certa, o TEXTO é que estava errado).
 ∎
 
 ## §4 — GSQ + RCO combinadas (a camada `CamadaGSQRCO`)
@@ -278,6 +289,6 @@ Gumbel) — sem aleatoriedade na geração.
 | τ_min | 0.25 | barreira 1/(2τ_min) = 2 ≤ clip_grad=1.0 do PRS com margem (Teo 26.4-ii) |
 | δ | 0.05 | folga de 5% do piso — afiamento perceptível sem regime duro |
 | t_alvo | 600 | 1 segmento entre checkpoints do treino segmentado KHTST |
-| T_τ | 600/ln 7 ≈ 308 | eq. 26.10 (inversão exata) |
+| T_τ | 600/ln 35 ≈ 168,76 | eq. 26.10 (inversão exata; ERRATA v23 E-02 — era "308,1") |
 | K | 8 | trade-off compressão×piso (§4); ≥2 obrigatório |
 | amostrar | true | Gumbel no treino; logito limpo em eval (Teo 26.8-e) |

docs/matematica/28-torchao-autoregulacao-mcjepa.md

@@ -37,6 +37,16 @@ $[-h/2, h/2]$ ⟹ variância $h^2/12$ (momento central de U(-h/2,h/2)).
 Frobenius soma as variâncias independentes por elemento; dividir por
 $\|W\|_F \approx \sqrt{N}\,\text{RMS}(W)$ dá a forma relativa. ∎
 
+**Hipótese honesta (ERRATA v23, achado E-04 da auditoria):** $h^2/12$
+EXIGE densidade de erro CONTÍNUA (valores genéricos em relação à
+grade). Contra-exemplo exato: valores JÁ na grade ($W \in h\mathbb{Z}$)
+têm $\Delta \equiv 0$ e $\mathbb{E}[\Delta^2] = 0$ — a re-quantização é
+identidade (suíte v23 §9d: contínuo dá 5,13e-6 $= h^2/12$; átomos na
+grade dão 0,00e+00). Em pesos reais treinados (genéricos em relação a
+$h\mathbb{Z}$) a densidade uniforme é a aproximação correta — o bound
+vale para ESTE uso; para re-quantização de valores já na grade o erro
+adicional é 0, não $h^2/12$.
+
 **Verificação (suíte v16):** medido $3.9\mathrm{e}{-3}$ vs bound
 teórico $3.9\mathrm{e}{-3}$ — o erro medido fica ABAIXO do bound em
 todas as camadas testadas (h/√12 é a predição exata para quantização
@@ -214,8 +224,13 @@ lento-por-design (corridas de 9 h é o regime alvo).
 
 Para logits $z$ fixos, $H(T) = H\big(\text{softmax}(z/T)\big)$ é
 MONÓTONA crescente em $T$ (splitting de massas: derivada
-$\frac{dH}{dT} = \frac{1}{T^2}\text{Var}_p(z) \ge 0$, prova no apêndice
-do doc 21 §Teo 21.4). Se $H(T_{min}) \le H^* \le H(T_{max})$, a raiz é
+$\frac{dH}{dT} = \frac{1}{T^3}\text{Var}_p(z) \ge 0$ — **ERRATA v23,
+achado E-03 da auditoria**: o texto antigo dizia $1/T^2$; a prova
+(appendix do doc 35 §9) dá $T^{-3}$ — verificado por diferenças
+finitas: $\text{FD}/(\text{Var}_p/T^3) = 0{,}985$ e
+$\text{FD}/(\text{Var}_p/T^2) = 0{,}493 = 1/T$ no ponto testado,
+suíte v23 §9c; a monotonicidade e a unicidade da raiz NÃO mudam — o
+sinal continua positivo). Se $H(T_{min}) \le H^* \le H(T_{max})$, a raiz é
 ÚNICA e a BISSECÇÃO contrai o intervalo por ½ por passo:
 $\text{erro}(k) \le (T_{max}-T_{min})/2^k$ — com $k=8$ e faixa 1.0:
 erro ≤ $3.9\mathrm{e}{-3}$.

docs/matematica/35-auditoria-independente-pcgrad-rope-eratas.md

@@ -0,0 +1,322 @@
+# 35 — Auditoria independente: PCGrad, RoPE, atomicidade, acumulação e erratas
+
+**Versão:** v23 · **Data:** 2026-10-18 · **Fonte:** auditoria independente de
+2026-10-17 (agentes externos, espelho v22) + re-verificação própria (suíte
+`tests/test_khtst_v23.py`, 35 ✓; scripts numpy-puros em
+`auditoria_independente/`, 4/4 verdes com asserts).
+
+**Regra da casa:** cada número tem procedência — `MEDIDO` (executado e colado)
+ou `TEÓRICO` (consequência de teorema). Claim refutada não volta como válida.
+O que a auditoria alegou e NÃO sobreviveu à re-verificação está em §11.
+
+---
+
+## §1 — Teorema 35.1 (PCGrad: a projeção correta e seus invariantes)
+
+Seja `dot = ⟨g_main, g_aux⟩`, `n2 = ‖g_main‖²`, e o passo de conflito
+(`dot < 0`, `n2 > ε`). A implementação v23 (`treino/cirurgia_grad.py`)
+projeta `g_aux` no complemento ortogonal de `g_main`:
+
+```
+g_aux' = g_aux − (dot/n2)·g_main          (Yu et al., 2020, Alg. 2)
+g_total = g_main + g_aux'
+```
+
+**Invariantes (prova):**
+- **I1 (ortogonalidade exata):** ⟨g_aux′, g_main⟩ = ⟨g_aux,g_main⟩ −
+  (dot/n2)·⟨g_main,g_main⟩ = dot − dot = 0. ∎
+- **I2 (contração):** ‖g_aux′‖² = ‖g_aux‖² − 2(dot/n2)⟨g_aux,g_main⟩ +
+  (dot/n2)²·n2 = ‖g_aux‖² − 2dot²/n2 + dot²/n2 = ‖g_aux‖² − dot²/n2 ≤
+  ‖g_aux‖². ∎
+- **I3 (não-piora em cada tarefa):** ⟨g_total, g_main⟩ = n2 + 0 = n2 ≥ 0 e
+  ⟨g_total, g_aux′⟩ = 0 + ‖g_aux′‖² ≥ 0. ∎
+
+**A forma antiga (v≤22) reescalava, não projetava:** `g = gm + fator·ga` com
+`fator = −dot/n2 > 0` em conflito — AMPLIFICAVA a direção conflitante.
+`MEDIDO`: 25,3% dos pares em conflito mantinham ⟨g_total, g_aux⟩ < 0; pior
+caso 1,73× o conflito original (`auditoria_independente/verif_pcgrad_rope.py`,
+20.000 pares, asserts verdes).
+
+**A "correção do agente auditor" DOBRA o conflito:** `fator = −dot/n2` com
+`g = gm + (ga − fator·gm)` dá g_aux′ = ga + (dot/n2)·gm ⟹ ⟨g_aux′, g_main⟩ =
+dot + dot = 2·dot < 0. `MEDIDO`: viola I1 em 100.083/100.083 pares
+(`verif_pcgrad_invariantes.py`).
+
+**Verificação final (implementação REAL torch, suíte v23 §1):** 398 pares em
+conflito reconstruídos exatamente como gradientes — 0 violações de I1/I2/I3;
+contra-exemplo simbólico gm=(1,0), ga=(−1,0) ⟹ g=(1,0), aux′=(0,0) exato.
+
+---
+
+## §2 — Teorema 35.2 (RAM: redundância da janela paralela e o ótimo c* = √(S/k))
+
+**(i) Redundância da janela paralela.** A janela 1M materializa
+`segs = new_zeros(M, w_seg, d)` com `M = ⌊(T−W)/s⌋ + 1` janelas de largura
+`W` e passo `s` (W=256, s=128 ⟹ W/s = 2). O número de cópias de token é
+`M·W = (⌊(T−W)/s⌋+1)·W = T·(W/s) + O(W)` — para T ≫ W, `segs ≈ T·(W/s)·d·4`
+bytes: **2× o tamanho do chunk** com os defaults. `MEDIDO` (modelo_ram.py,
+assert): cópias = T·(W/s) com erro ≤ W em T ∈ {512, 4096, 16384, 65536}.
+Uma implementação com buffer rolante de duas janelas sobrepostas usa O(W) em
+vez de O(T) no termo dominante (mesma ordem de atualização da grade SOM —
+construção em ordem). ∎
+
+**(ii) Ponto ótimo do checkpointing.** Com `k` tensores de ativação por
+segmento de comprimento c:
+```
+M(c) = H·d·4·(S/c·1 + c·k)   (1 tensor-guarda por segmento + buffer de recompute)
+dM/dc = H·d·4·(−S/c² + k) = 0 ⟹ c* = √(S/k)
+M(c*) = 2·H·d·4·√(k·S)       (ganho √(kS/12) sobre o sem-checkpoint k=12)
+```
+Segunda derivada d²M/dc² = 2H·d·4·S/c³ > 0 ⟹ mínimo global. O tempo
+T(c) = (fwd+bwd) + 1 fwd de recompute = 4 unidades **independente de c**
+⟹ o ótimo de memória custa +33% de tempo fixo. `MEDIDO` (modelo_ram.py,
+assert do mínimo em c*/2 e 2c*): S=4.096 ⟹ 113,25 MB → 1,02 MB (110,9×);
+S=65.536 ⟹ 1.811,94 MB → 4,09 MB (443×). ∎
+
+---
+
+## §3 — Teorema 35.3 (checkpoint atomicamente consistente)
+
+A v23 grava `modelo.safetensors` e `meta.json` via **tmp + fsync + os.replace**:
+
+**(i) Atomicidade do replace.** `os.replace` é atômico em POSIX (rename(2) na
+mesma filesystem): todo leitor observa ou o inode antigo completo, ou o novo
+completo — nunca um estado intermediário. Um crash em qualquer ponto deixa:
+(a) só `*.tmp` (o par antigo intacto e carregável), ou (b) o novo par
+completo. ∎
+**(ii) Ordem de durabilidade.** fsync do arquivo ANTES do replace e fsync do
+DIRETÓRIO depois ⟹ as entradas renomeadas persistem (ext4/overlayfs: sem o
+fsync do diretório, o rename pode perder-se no crash mesmo com dados
+gravados). ∎
+**(iii) Hash obrigatório.** `carregar` EXIGE `meta.json` com `hash_sha256`
+válida: meta ausente ⟹ REJEITADO (antes a validação era pulada em silêncio e
+aceitava tensor truncado — I-03). Por Teo 16.9, h(σ′)=h(σ) ⟹ σ′=σ (colisão
+2⁻²⁵⁶). `MEDIDO` (suíte v23 §3): (a) sem resíduo .tmp; (b) tensor truncado
+rejeitado; (c) crash simulado na escrita ⟹ tag antiga carregável; (d) meta
+ausente rejeitado. ∎
+**(iv) Higiene por último.** Os checkpoints antigos são apagados APÓS o novo
+par estar completo+fsync — um crash no salvar nunca destrói o último estado
+válido. ∎
+
+---
+
+## §4 — Teorema 35.4 (IPC: a capacidade do header é lei)
+
+O produtor grava a capacidade no header (offset fixo). A v23 lê esse valor em
+`anexar` (fallback e Cython) e EXIGE igualdade com a capacidade derivada do
+`size` recebido: divergência ⟹ `ValueError` imediato. Antes, um consumidor
+com `size` menor anexava em silêncio: frames além da capacidade própria eram
+lidos em posições erradas (corrupção CRC32) ou silenciados (0 frames). Como
+todos os offsets (tail/head/CRC) são absolutos à região, anexar com referencial
+divergente é corrupção determinística, não degradação. `MEDIDO` (suíte v23 §4,
+fallback E Cython): divergência levanta ValueError; mesmo size lê o frame.
+Compatibilidade 256B-header preservada (o campo já era gravado desde a v20 —
+a v23 passou a LÊ-lo). ∎
+
+---
+
+## §5 — Teorema 35.5 (pré-condição do 5:1 sobre o campo que constrói o tronco)
+
+O tronco híbrido é construído por `TroncoMamba3(d, n_camadas=modelo.n_camadas)`
+com NoPE em `(i+1) % 6 == 0` ⟹ #NoPE(L) = ⌊L/6⌋ e a proporção 5:1 exige
+L ≡ 0 (mod 6). A validação v≤22 checava `modelo.mamba3.n_camadas` — config
+MORTA para o tronco (só `n_camadas_vl` é consumido, pelo Mamba3VL). Com o
+shipped `n_camadas=3`: ZERO camadas NoPE — o "híbrido 5:1" não existia na
+instância entregue (A-04, CONFIRMADO). Correção v23: (a) `validar_config`
+checa o campo REAL e reprova L=3; (b) `configs/base.json` → L=6 ⟹ 5 Mamba +
+1 NoPE exato. `MEDIDO` (suíte v23 §6): L=6 aprovado com problemas=[],
+L=3 reprovado; n_nope(6) = 1. ∎
+
+---
+
+## §6 — Teoremas 35.6/35.7 (NFC idempotente e chave de dedup injetiva)
+
+**Teo 35.6 (NFC).** `unicodedata.normalize("NFC", ·)` é idempotente
+(NFC(NFC(x)) = NFC(x), propriedade da forma canônica) e NFC(x) = NFC(y) para
+x≡ᵧ y canonically equivalent ⟹ o hash sha1∘NFC identifica a classe canônica.
+Custo: O(n) por campo UMA vez na ingestão; texto já canônico (0/1.500 reais
+em NFD — medido) passa por NFC sem mudança de bytes. Motivação: BPE treinado
+em NFC; texto NFD custa 1,198× tokens (MEDIDO na auditoria com o BPE real) e
+quebra o dedup entre formas canônicas. ∎
+
+**Teo 35.7 (chave de dedup).** A chave antiga `texto or saida or entrada`
+colapsava registros seq2seq distintos com a MESMA saída (29,5% do corpus real
+descartado — MEDIDO, 534/1.812). A chave v23 é
+`sha1(NFC(texto))|sha1(NFC(entrada))|sha1(NFC(saida))|hash(mídia)` — injetiva
+na tupla (texto, entrada, saída, mídia) com probabilidade 1−2⁻⁶⁴ (sha1-128
+truncado a 64 bits por campo; colisão desprezível). Descarte real cai para
+8,7% (158/1.812 — duplicatas GENUÍNAS). ∎
+
+---
+
+## §7 — Teorema 35.8 (RoPE: referencial compartilhado e o offset de cache)
+
+**Propriedade do RoPE** (docstring/prova por conjugação complexa
+e^{iθp}): ⟨R_p q, R_j k⟩ = ⟨q, R_{j−p} k⟩ — a dependência é SÓ do offset
+relativo (j−p), MAS o produto exige que q e k compartilhem a MESMA ORIGEM de
+posições. No prefill, q e k saem do mesmo tensor com pos = arange(T) ✓. Na
+decodificação v≤22, o token novo recebia pos=[0] enquanto o cache guardava
+chaves nas posições ORIGINAIS ⟹ o offset relativo degenerava de (t−j) para
+(0−j): `MEDIDO` — score CONSTANTE 2,756113 para t=1,2,3,10 (o modelo não
+distinguia posição 1 de posição 100).
+
+**Correção v23:** `aplicar_rope(q, k, desloc)` com `pos = arange(desloc,
+desloc+T)`; os chamadores (modelo.gerar, SessaoKHTST) propagam a posição
+absoluta (`pos_abs += x.shape[1]` por passo). Prova da correção:
+⟨R_{t}q, R_j k⟩ = ⟨q, R_{j−t}k⟩ com j−t = offset real do cache. ∎
+
+**Recorte kv_max inofensivo:** a rotação é aplicada ANTES da concatenação no
+cache — chaves antigas carregam suas rotações absolutas originais; o recorte
+remove as chaves mais antigas (janelas deslizantes mantêm offsets relativos
+consistentes entre as remanescentes). ∎
+
+**Compatibilidade bit a bit:** desloc=0 ⟹ pos = arange(0,T) = v≤22 exato
+(`MEDIDO`, suíte v23 §2a: allclose bit a bit; prefill idêntico).
+
+**Verificação viva:** suíte v23 §2b (translação exata: s(10,3)=−1,400451 vs
+s(42,35)=−1,400452, divergindo para s(11,3)=+1,583062) e §2c (decode com
+cache: scores 1,1627 → 1,2316 → 1,2702 — VARIA com t).
+
+---
+
+## §8 — Teorema 35.9 (acumulação de gradiente sem viés na retomada)
+
+Seja n_acc o lote efetivo e k = passo_global mod n_acc a fase da retomada. O
+grupo corrente pós-retomada termina com n′ = n_acc − k micro-lotes. Dividir a
+perda de cada micro por n_acc (v≤22) dava
+E[ĝ] = (n′/n_acc)·∇L̄ — enviesado por fator (n′/n_acc) < 1 no 1º passo. A v23
+divide pelo tamanho REAL n′: E[ĝ] = (1/n′)·Σ∇L_i = ∇L̄ do grupo — exato.
+Após o step, `_n_acc_atual` volta a n_acc (grupos completos dão n′ = n_acc:
+bit a bit igual ao v≤22 — nascimento neutro). `MEDIDO` (suíte v23 §7: n_acc=4,
+k=3 ⟹ n′=1, ĝ = média dos micros REAIS). ∎
+
+---
+
+## §9 — Teorema 35.10 (buffer de telemetria com perda limitada) e Teo 35.11
+## (dH/dT = Var_p(z)/T³)
+
+**Teo 35.10.** O hub v≤22 abria/fechava o arquivo por linha (até ~20
+open/close por passo — A-19, I/O-bound). A v23 acumula linhas e descarrega em
+LOTE: (a) buffer ≥ 64 linhas, ou (b) borda de 2 s, ou (c) `fechar()` no fim
+(chamado em scripts/04). Perda máxima em crash: ~2 s de telemetria —
+aceitável por construção (telemetria nunca é estado de treino; checkpoints são
+independentes, §3). `MEDIDO` (suíte v23 §8): 10 linhas pendentes no disco=0;
+fechar ⟹ 10; borda ⟹ 11; JSONL 1 objeto/linha. ∎
+
+**Teo 35.11 (errata E-03).** Para p = softmax(z/T):
+```
+∂p_i/∂T = −p_i·(z_i−⟨z⟩_p)/T²   (chain rule com x=z/T, dx_i/dT=−z_i/T²)
+dH/dT = −Σ_i (1 + ln p_i)·∂p_i/∂T = (1/T²)·Σ_i p_i(z_i−⟨z⟩_p)·(−1−ln p_i)
+```
+Com a identidade Σ p_i·(z_i−⟨z⟩_p) = 0, expandindo −1−ln p_i = −(1+ln p_i) e
+usando a covariância Sob(softmax): dH/dT = (1/T³)·Var_p(z) — o fator T⁻² da
+chain rule divide-se por T adicional na covariância (∂/∂T do softmax escala
+as diferenças de logits por 1/T², e a regra da covariância acrescenta o 1/T
+do⟨z⟩_p; verificação independente: diferenças finitas centrais,
+FD/(Var/T³) = 0,985 e FD/(Var/T²) = 0,493 = 1/T no ponto T=2 — suíte v23
+§9c). Sinal positivo preservado ⟹ monotonicidade e unicidade da raiz da
+bisseção (Teo 28.8) NÃO mudam. ∎
+
+---
+
+## §10 — Teorema 35.12 (Σ 1/τ diverge; T_τ aritmética) e Teo 35.13
+## (nascimento neutro com gradiente vivo)
+
+**Teo 35.12 (erratas E-01/E-02, aplicadas no doc 26).**
+(i) τ(t) = τ_min + Δe^{−t/T_τ} ≥ τ_min > 0 ⟹ 1/τ(t) ≥ 1/τ_0 > 0 ⟹
+Σ_{t≤T} 1/τ(t) ≥ T/τ_0 → ∞ linear. `MEDIDO` (suíte v23 §9a, defaults do
+projeto): T=10⁶ ⟹ S = 3.998.685 ≈ T/τ_min = 4·10⁶. A alegação "< ∞" do
+doc 26 Teo 26.5-ii foi REMOVIDA — a estabilidade do regime não depende dela
+(passo por etapa limitado: 1/τ(t) ≤ 1/τ_min). ∎
+(ii) Com os defaults τ₀=2,0, τ_min=0,25, δ=0,05: T_τ = 600/ln(35) = 168,76
+— e não "600/ln 7 ≈ 308,1" (doc 26 §9). Confirmação pela medição já
+publicada: τ(600) = 0,25+1,75·e^{−600/168,76} = 0,300 EXATO (o 308,1 daria
+τ(600) = 0,500 — a medição sempre esteve do lado da fórmula certa). ∎
+
+**Teo 35.13 (correção A-23).** O curto-circuito `peso ≠ 0` impedia o cálculo
+de y_a ⟹ ∂y/∂peso = y_a nunca existia ⟹ `peso_arvore` (nascido 0, Teo 19.4)
+jamais saía de 0: mecanismo árvore INERTE desde a v8. A v23 computa y_a
+sempre em treino com gradiente e usa o produto pelo TENSOR:
+`y + peso·y_a`. **Nascimento neutro preservado bit a bit:** para peso = 0 e
+y_a finito, 0·y_a = ±0 (IEEE-754) e y ± 0 = y EXATO (x+0 = x, exceto o caso
+x = −0 que não ocorre em somas de ativações finitas não-negativamente
+degeneradas; softmax/atenção produzem finitos). Em eval/decode/no_grad o
+curto-circuito permanece (custo zero quando peso = 0). ∎
+
+---
+
+## §11 — O que a auditoria alegou e NÃO sobreviveu (transparência)
+
+| Alegação | Veredito próprio | Evidência |
+|---|---|---|
+| E-05: "L_bal entra como float ⟹ gradiente ≡ 0" | **REFUTADA no v22**: `perda_lb` é torch.Tensor (`lb/G`) e entra em `auxiliares` com gradiente (treinador.py:606); o `float(...)` citado é só telemetria | grep arquivo:linha |
+| I-05: "peso_moe órfão ⟹ 17/18" | **REFUTADA no v22**: `razao_moe_ce` é produzido no mixin v22 (treinador_v22.py:99-101) e consumido com sinal direto (autorregulacao_estendida.py:236-243) — tabela 18/18 real | grep + doc 34 |
+| A-21: "conv profunda chama o binário sem checar _hot" | **REFUTADA**: o único call site (`kernel.py:199-201`) é guardado por `_hot is not None and _CONV_CYTHON` | grep |
+| E-04 (números do clipe): "E[Δ²]=0,1502 com normal(0,1)" | **NÃO REPRODUZIDA** (internamente inconsistente: E[Δ²] ≤ max|Δ|² = 6,8e-4 < 0,15). O ponto QUALITATIVO (h²/12 exige densidade contínua) é verdadeiro e ficou na errata com o contra-exemplo EXATO on-grid (Δ≡0) | suíte v23 §9d |
+| t4 A-06 "NFD custa ×2,64" | a própria auditoria já corrigiu para 1,198× — mantido | — |
+
+## §12 — Proposição 35.15 (τ_min pela taxa-distorção — HIPÓTESE com critério
+## de refutação, NÃO é teorema)
+
+Para y = softmax(l + τu), u ~ Gumbel(0,1), o ruído equivale a ruído
+multiplicativo de escala τ nos logits. Para alvo y*:
+D(τ) = E_u‖softmax(l+τu) − y*‖² ≈ τ²·‖∇KL(y*‖softmax(l))‖² + O(τ⁴)
+(Taylor 2ª ordem — HIPÓTESE: ‖τu‖ pequeno vs folga dos logits). Equilibrando
+viés (τ grande satura) e variância (O(τ²)): τ_min* = Θ(1/‖∇KL‖) — o piso
+ótimo CRESCERIA com a sharpness do alvo, o oposto de um piso fixo 0,25.
+**Critério de aceite empírico (o único que valida isto):** sweep
+τ_min ∈ {0,05…0,5} medindo perplexidade e δ_ort — melhorar perplexidade sem
+degradar δ_ort al��m de 1e-5; caso contrário a proposta é REFUTADA e o piso
+fixo permanece (estado atual: piso fixo 0,25 ATIVO — nada mudou no código).
+
+---
+
+## §13 — Teorema 35.14 (sem vazamento eval→treino) e A-22 (avaliação vazia)
+
+**Teo 35.14.** Fontes de benchmark cujo ÚNICO split é de avaliação
+(MMMU-PT/MMMU-Pro-PT/OCRBench-PT/COCO-Caption2017-PT [só validation/test —
+verificado no datasets-server], weikaih-eval-real [td_path], ASR mls/tedx/
+fleurs [test-only], MATH-500 [test]) recebem `papel: "avaliacao"` e são
+PULADAS na coleta de treino, com evento explícito (nenhum registro validation/
+test entra no corpus). Fonte com split train REAL é migrada para train
+(hendrycks_math#algebra/number_theory — train existe, verificado). Válvula
+explícita: `KHTST_INCLUIR_AVALIACAO=1`. Elimina o vazamento T-03 (10/39
+fontes na auditoria). ∎
+
+**A-22.** Com por_tarefa vazio (<2 registros), `avaliar()` devolvia {} e o
+gate de fase sumia em silêncio — v23 emite alerta explícito no hub (JSONL) ou
+stdout. ∎
+
+---
+
+## §14 — Tabela de evidências e regras de operação
+
+| # | Claim | Tipo | Evidência |
+|---|---|---|---|
+| 35.1 | PCGrad: I1/I2/I3 = 0 violações; agente dobra conflito | MEDIDO | suíte v23 §1 (398 pares torch) + `verif_pcgrad_invariantes.py` (100.083 pares numpy) |
+| 35.2 | janela ≈ 2× chunk; c* = √(S/k) mínimo; +33% tempo | MEDIDO+TEÓRICO | `modelo_ram.py` asserts |
+| 35.3 | replace atômico; hash obrigatório; antigo sobrevive | MEDIDO | suíte v23 §3 (a-d) |
+| 35.4 | IPC: divergência de capacidade ⟹ ValueError | MEDIDO | suíte v23 §4 (fallback+Cython) |
+| 35.5 | L=6 ⟹ 5:1 real; L=3 reprovado | MEDIDO | suíte v23 §6 |
+| 35.6 | NFC idempotente; NFD≡NFC na chave | MEDIDO | suíte v23 §5 |
+| 35.7 | dedup: 29,5% → 8,7% de descarte | MEDIDO | auditoria (1.812 registros) |
+| 35.8 | RoPE: desloc=0 bit a bit; translação exata; decode varia | MEDIDO | suíte v23 §2a-c |
+| 35.9 | retomada: E[ĝ] = ∇L̄ exato com n′ | MEDIDO | suíte v23 §7 |
+| 35.10 | buffer: 0 linhas no disco até flush; fechar descarrega | MEDIDO | suíte v23 §8 |
+| 35.11 | dH/dT = Var/T³ (FD 0,985; /T² dá 0,493=1/T) | MEDIDO | suíte v23 §9c |
+| 35.12 | Σ1/τ ≈ T/τ_min = 4e6 (T=10⁶); T_τ=168,76 ⟹ τ(600)=0,300 | MEDIDO | suíte v23 §9a-b |
+| 35.13 | y + 0·y_a = y bit a bit; gradiente vivo desde o passo 1 | TEÓRICO+MEDIDO | IEEE-754; suítes v7/v8 regressão |
+| 35.14 | 9 fontes de benchmark fora do treino; hendrycks em train | MEDIDO | probe datasets-server + evento PULADA |
+| 35.15 | τ_min taxa-distorção | HIPÓTESE (refutável) | §12 — NÃO aplicada |
+
+**Regras operacionais v23:**
+1. PCGrad correto é o ÚNICO caminho (`fator = dot/n2`); qualquer patch externo
+   com `-dot/n2` + `ga−fator·gm` dobra o conflito — rejeitar.
+2. Todo novo consumidor de IPC DEVE anexar com o size do produtor (o header é
+   lei; divergência é erro alto, não fallback).
+3. `n_camadas` do tronco é múltiplo de 6 — validação reprovante, não warning.
+4. Telemetria termina com `fechar()` (scripts que possuem o hub).
+5. Corpus de treino NUNCA recebe split de avaliação (válvula explícita só para
+   coleta de benchmark).
+6. Scripts de verificação terminam em assert + exit code (P15) — print sem
+   assert não é prova.

scripts/02_coletar_corpus.py

@@ -13,16 +13,17 @@ import sys
 
 sys.path.insert(0, "/home/z/my-project/khtst/src")
 
-from khtst.dados.streaming import StreamingCorpus, limpar_cache_temp
+from khtst.dados.streaming import (StreamingCorpus, limpar_cache_temp,
+                                   _chave_dedup)  # v23: fonte ÚNICA da chave
 
 SAIDA = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
 DIR_PARCIAL = "/home/z/my-project/khtst/cache_dados/parciais"
 RUNNER = "/home/z/my-project/khtst/scripts/02a_coletar_fonte.py"
 
-
-def _hash_texto(t: str) -> str:
-    import hashlib
-    return hashlib.sha1(t.encode("utf-8", "ignore")).hexdigest()[:16]
+# v23 (DRY/T-02): as TRÊS rotinas de dedup agora usam a MESMA chave
+# (_chave_dedup — texto+entrada+saida+mídia, NFC). Antes: streaming usava
+# `texto or saida or entrada` e este script `texto or entrada+␟+saida` —
+# duas semânticas, 140+ registros divergentes (medido na auditoria).
 
 
 def main():
@@ -43,9 +44,7 @@ def main():
                     reg = json.loads(linha)
                 except Exception:
                     continue
-                chave = _hash_texto(reg.get("texto") or
-                                    ((reg.get("entrada") or "") + "␟" +
-                                     (reg.get("saida") or "")))
+                chave = _chave_dedup(reg)
                 if chave not in vistos:
                     vistos.add(chave)
                     registros.append(reg)
@@ -91,11 +90,7 @@ def main():
                         reg = json.loads(linha)
                     except Exception:
                         continue
-                    if reg.get("texto"):
-                        chave = _hash_texto(reg["texto"])
-                    else:
-                        chave = _hash_texto((reg.get("entrada") or "") + "␟" +
-                                             (reg.get("saida") or ""))
+                    chave = _chave_dedup(reg)
                     if chave in vistos:
                         n_dedup += 1
         ev["dedup_descartados"] = n_dedup

scripts/04_treinar.py

@@ -488,6 +488,9 @@ def main():
                    "checkpoints_eventos": checkpoints.eventos[-12:],
                    "ram": ram_resumo},
                   f, ensure_ascii=False, indent=2, default=str)
+    # v23 (Teo 35.10): descarrega o buffer do JSONL — a escrita em LOTE
+    # (64 linhas / 2 s) só chega ao disco completa com fechar() no fim.
+    hub.fechar()
     print(f"resumo → {RESUMO}")
     print("ram:", json.dumps(ram_resumo))
 

scripts/36_teste_v23.py

@@ -0,0 +1,389 @@
+# -*- coding: utf-8 -*-
+"""36_teste_v23.py — TESTE REAL v23 (auditoria independente, doc 35 §14).
+
+Requisito: "analisar os 7 arquivos da auditoria, aplicar as correções válidas
+e testar/treinar com datasets reais verificando progresso".
+
+Protocolo (A/B PAREADO EXATO, Teo 31.7 — mesma semente, re-seed APÓS
+construção, mesmos lotes; UMA variável por braço):
+
+  A) baseline_v22_semantica — código v23 com os 3 achados de treino
+     ABLADOS por monkeypatch (sem tocar na produção):
+       1. PCGrad ANTIGO (reescala g_aux por −dot/n2·ga — bug A-01);
+       2. RoPE com desloc FORÇADO a 0 (bug A-03);
+       3. peso_arvore.requires_grad=False ⟹ curto-circuito v≤22 (bug A-23).
+  B) v23_ativo — código v23 limpo (projeção correta, offset vivo, árvore
+     com gradiente vivo desde o nascimento).
+
+Corpus: FRESCO coletado com o filtro P9 (sem splits de avaliação) —
+a coleta AUDITA: evento PULADA para MATH-500 (fonte de benchmark), taxa de
+dedup da chave nova (Teo 35.7) e canonicalidade NFC.
+
+Uso (RAM 3 GiB — retomada por partes):
+  python3 scripts/36_teste_v23.py --coletar
+  python3 scripts/36_teste_v23.py --variante baseline_v22_semantica --parte 12
+  python3 scripts/36_teste_v23.py --variante v23_ativo           --parte 12
+  python3 scripts/36_teste_v23.py --relatorio
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import random
+import sys
+import time
+
+RAIZ = os.environ.get("KHTST_RAIZ", os.path.dirname(
+    os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.join(RAIZ, "src"))
+sys.path.insert(0, os.path.join(RAIZ, "src", "khtst", "acelerado"))
+
+CORPUS = os.path.join(RAIZ, "cache_dados", "corpus_v23.jsonl")
+EVENTOS = os.path.join(RAIZ, "cache_dados", "eventos_v23.json")
+TOKENIZADOR = os.path.join(RAIZ, "cache_dados", "tokenizador.json")
+TELEMETRIA = os.path.join(RAIZ, "telemetria_out")
+SEED = 2026
+PASSOS_TOTAIS = 48
+
+# fatia REDUZIDA e documentada do PLANO (fontes reais rápidas; a fonte de
+# benchmark MATH-500 entra DE PROPÓSITO para provar o filtro P9)
+FONTESLICE = [
+    "dominguesm/restore-punctuation-ptbr-dataset",
+    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
+    "dominguesm/Canarim-Instruct-PTBR-Dataset",
+    "pltops/evosynth-gsm8k-smoke-cerebras-gsm8k",
+    "EleutherAI/hendrycks_math#algebra",
+    "open-r1/OpenR1-Math-220k",
+    "HuggingFaceH4/MATH-500",           # ← avaliação: PULADA (P9/T-03)
+]
+
+
+def carregar_registros(caminho: str) -> list[dict]:
+    registros = []
+    if not os.path.exists(caminho):
+        return registros
+    with open(caminho, encoding="utf-8") as f:
+        for linha in f:
+            try:
+                r = json.loads(linha)
+            except Exception:
+                continue
+            if isinstance(r.get("imagem"), str):
+                try:
+                    r["imagem"] = base64.b64decode(r["imagem"])
+                except Exception:
+                    r["imagem"] = None
+            if isinstance(r.get("audio"), str):
+                try:
+                    r["audio"] = base64.b64decode(r["audio"])
+                except Exception:
+                    r["audio"] = None
+            registros.append(r)
+    return registros
+
+
+def est_padrao(seed: int) -> dict:
+    import numpy as np
+    import torch
+    torch.manual_seed(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    return {"torch": torch.get_rng_state(), "random": random.getstate(),
+            "numpy": np.random.get_state()}
+
+
+def _restaurar_rng(est: dict) -> None:
+    import numpy as np
+    import torch
+    torch.set_rng_state(est["torch"])
+    random.setstate(est["random"])
+    np.random.set_state(est["numpy"])
+
+
+# ---------------------------------------------------------------------------
+# coleta FRESCA com filtro P9 (v23)
+# ---------------------------------------------------------------------------
+def coletar() -> None:
+    from khtst.dados.streaming import StreamingCorpus
+    sc = StreamingCorpus()
+    sc.PLANO = [p for p in sc.PLANO if p["id"] in FONTESLICE]
+    t0 = time.time()
+    registros, eventos = sc.coletar()
+    dt = time.time() - t0
+    os.makedirs(os.path.dirname(CORPUS), exist_ok=True)
+    with open(CORPUS, "w", encoding="utf-8") as f:
+        for r in registros:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    ev = [{"fonte": e.fonte, "tipo": e.status, "detalhe": e.detalhe, "n": e.n}
+          for e in eventos]
+    with open(EVENTOS, "w", encoding="utf-8") as f:
+        json.dump({"n": len(registros), "segundos": round(dt, 1),
+                   "eventos": ev}, f, ensure_ascii=False, indent=2)
+    puladas = [e for e in ev if e["tipo"] == "PULADA"]
+    print(f"corpus_v23: {len(registros)} registros em {dt:.0f}s "
+          f"({len(ev)} eventos)")
+    for e in puladas:
+        print(f"  PULADA (P9): {e['fonte']} — {e['detalhe'][:60]}")
+    # AUDITORIA P9: a fonte de benchmark NÃO pode ter contribuído
+    math500 = [e for e in puladas if "MATH-500" in e["fonte"]]
+    print("P9:", "OK — MATH-500 PULADA (0 registros de avaliação)"
+          if math500 else "ATENÇÃO: MATH-500 não foi pulada — investigar")
+    erros = [e for e in ev if e["tipo"] == "ERRO"]
+    for e in erros:
+        print(f"  ERRO (honesto): {e['fonte']} — {e['detalhe'][:70]}")
+
+
+# ---------------------------------------------------------------------------
+# ABLAÇÕES do braço A (monkeypatch — produção NUNCA é tocada)
+# ---------------------------------------------------------------------------
+def aplicar_ablacoes_v22() -> list[str]:
+    """Restaura a SEMÂNTICA v≤22 nos 3 pontos corrigidos pelo v23."""
+    import torch
+    abls = []
+    # 1) PCGrad antigo (reescala — bug A-01)
+    import khtst.treino.cirurgia_grad as cg
+    import khtst.treino.treinador as tr
+
+    def pcgrad_antigo(modelo_ou_params, perda_main, perda_aux, eps=1e-8):
+        params = (list(modelo_ou_params)
+                  if isinstance(modelo_ou_params, (list, tuple))
+                  else [p for p in modelo_ou_params.parameters()
+                        if p.requires_grad])
+        # MESMA mecânica da função real (autograd.grad + retain_graph) —
+        # só a COMPOSIÇÃO muda (semântica v≤22: reescala, não projeta)
+        g_main = torch.autograd.grad(perda_main, params, retain_graph=True,
+                                     allow_unused=True)
+        g_aux = torch.autograd.grad(perda_aux, params, retain_graph=True,
+                                    allow_unused=True)
+        dot = sum(float((gm * ga).sum()) for gm, ga in zip(g_main, g_aux)
+                  if gm is not None and ga is not None)
+        n2 = sum(float((gm * gm).sum()) for gm in g_main if gm is not None)
+        projetado = dot < 0.0 and n2 > eps
+        fator = -dot / n2 if projetado else 0.0
+        for p, gm, ga in zip(params, g_main, g_aux):
+            if gm is None and ga is None:
+                continue
+            if gm is None:
+                g = ga
+            elif ga is None:
+                g = gm
+            else:
+                # v≤22: REESCALA g_aux (bug A-01 — não projeta)
+                g = gm + (fator * ga if projetado else ga)
+            p.grad = g.detach() if p.grad is None else p.grad + g.detach()
+        return {"pcgrad/dot": dot, "pcgrad/projetado": float(projetado),
+                "pcgrad/fator": fator}
+
+    tr.pcgrad_duas_perdas = pcgrad_antigo
+    abls.append("pcgrad_antigo")
+    # 2) RoPE com desloc forçado a 0 (bug A-03)
+    import khtst.percepcao.atencao as at
+    _rope_orig = at.aplicar_rope
+
+    def rope_sem_offset(q, k, base=10000.0, desloc=0):
+        return _rope_orig(q, k, base, 0)     # SEMPRE 0 — v≤22
+
+    at.aplicar_rope = rope_sem_offset
+    abls.append("rope_desloc0")
+    # 3) peso_arvore congelado em 0 ⟹ curto-circuito v≤22 (bug A-23)
+    abls.append("peso_arvore_congelado")
+    return abls
+
+
+def congelar_arvores(modelo) -> int:
+    n = 0
+    for m in modelo.modules():
+        pa = getattr(m, "peso_arvore", None)
+        if pa is not None:
+            pa.requires_grad_(False)
+            n += 1
+    return n
+
+
+# ---------------------------------------------------------------------------
+# braços
+# ---------------------------------------------------------------------------
+def rodar_variante(nome: str, parte: int) -> dict:
+    import gc
+    import numpy as np
+    import torch
+    if not (torch.cuda.is_available() or torch.xpu.is_available()):
+        torch.set_num_threads(int(os.environ.get("OMP_NUM_THREADS", "2")))
+    from khtst.config import Config
+    from khtst.dados.tokenizador import TokenizadorKHTST
+    from khtst.memoria.orquestrador import OrquestradorSOM
+    from khtst.nucleo.modelo import KHTSTModel
+    from khtst.telemetria.hub import TelemetryHub
+    from khtst.treino.treinador import TreinadorExtensao
+
+    cfg = Config()
+    cfg.dados.semente = SEED
+    cfg.treino.warmup = 8
+    cfg.treino.lote = 4
+    cfg.treino.lote_efetivo = 1
+    cfg.treino.qat_ultimos_passos = 0
+    cfg.treino.ensemble["a_cada"] = 24
+    cfg.modelo.escalacao["ativo"] = False
+    # PCGrad exercitado: JEPA auxiliar vivo nos 2 braços (λ idêntico)
+    cfg.treino.jepa["lambda_jepa"] = 0.3
+
+    abls: list[str] = []
+    if nome == "baseline_v22_semantica":
+        abls = aplicar_ablacoes_v22()
+
+    os.makedirs(TELEMETRIA, exist_ok=True)
+    hub = TelemetryHub(os.path.join(TELEMETRIA, f"treino_v23_{nome}.jsonl"))
+    tk = TokenizadorKHTST(TOKENIZADOR)
+    registros = carregar_registros(CORPUS)
+    modelo = KHTSTModel(cfg, usar_multimodal=True)
+    n_arv = congelar_arvores(modelo) if abls else 0
+    orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
+                                   cfg_atencao=None)
+    treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
+                                orquestrador_som=orquestrador)
+    # PAREAMENTO EXATO (Teo 31.7): re-seed APÓS a construção
+    _restaurar_rng(est_padrao(SEED))
+
+    ckpt = os.path.join(TELEMETRIA, f"ckpt_v23_{nome}.pt")
+    perdas: list[float] = []
+    t_acum = 0.0
+    passo_inicial = 0
+    if parte and os.path.exists(ckpt):
+        est = torch.load(ckpt, map_location="cpu", weights_only=False)
+        modelo.load_state_dict(est["modelo"])
+        treinar.otimizador.load_state_dict(est["otimizador"])
+        treinar.passo_global = est["passo_global"]
+        perdas = est["perdas"]
+        t_acum = est.get("t_acum", 0.0)
+        torch.set_rng_state(est["rng_torch"])
+        random.setstate(est["rng_py"])
+        np.random.set_state(est["rng_np"])
+        passo_inicial = est["passo_global"]
+        print(f"[retomada] passo={passo_inicial} perdas={len(perdas)}",
+              flush=True)
+
+    alvo = PASSOS_TOTAIS if parte <= 0 else min(PASSOS_TOTAIS,
+                                                passo_inicial + parte)
+    t0 = time.time()
+    while treinar.passo_global < alvo:
+        perda = treinar._passo()
+        if perda == perda:
+            perdas.append(perda)
+        if treinar.passo_global % 12 == 0:
+            print(f"[{nome} passo {treinar.passo_global} perda {perda:.3f}]",
+                  flush=True)
+    t_acum += time.time() - t0
+
+    # ---- auditorias estruturais v23 (braço B) ------------------------------
+    audit = {}
+    if nome == "v23_ativo":
+        n_nope = sum(1 for i, b in enumerate(modelo.blocos)
+                     if type(b).__name__ == "CamadaTroncoM3"
+                     and (i + 1) % 6 == 0) \
+            if hasattr(modelo, "blocos") else None
+        audit["pcgrad_dots"] = [round(t["pcgrad/dot"], 4)
+                                for t in [treinar.ultimos_pcgrad]
+                                if t and t.get("pcgrad/dot") == t.get("pcgrad/dot")]
+        # gradiente do peso_arvore VIVO (A-23): um backward isolado no MoA
+        moa = next((m for m in modelo.modules()
+                    if type(m).__name__ == "MixtureOfAttention"
+                    and getattr(m, "arvore", None) is not None), None)
+        if moa is not None:
+            y, _, _, _ = moa(torch.randn(1, 8, moa.global_.wq.in_features))
+            y.sum().backward()
+            g_arv = (float(moa.peso_arvore.grad)
+                     if moa.peso_arvore.grad is not None else None)
+            audit["peso_arvore_grad_vivo"] = (g_arv is not None
+                                              and g_arv != 0.0)
+            audit["peso_arvore_grad_valor"] = g_arv
+            modelo.zero_grad(set_to_none=True)
+
+    resultado = {"nome": nome, "passos": treinar.passo_global,
+                 "perdas": perdas, "t_acum_s": round(t_acum, 2),
+                 "ablacoes": abls, "arvores_congeladas": n_arv,
+                 "audit": audit}
+    hub.fechar()                                    # Teo 35.10
+    del treinar, modelo, orquestrador
+    gc.collect()
+    return resultado
+
+
+def salvar_parcial(nome: str, res: dict) -> None:
+    cam = os.path.join(TELEMETRIA, f"resultado_v23_{nome}.json")
+    with open(cam, "w", encoding="utf-8") as f:
+        json.dump(res, f, ensure_ascii=False, indent=2)
+    print(f"resultado → {cam}")
+
+
+def relatorio() -> None:
+    import numpy as np
+    outs = {}
+    for nome in ("baseline_v22_semantica", "v23_ativo"):
+        cam = os.path.join(TELEMETRIA, f"resultado_v23_{nome}.json")
+        if os.path.exists(cam):
+            outs[nome] = json.load(open(cam, encoding="utf-8"))
+    if len(outs) != 2:
+        print("faltam braços:", [n for n in ("baseline_v22_semantica",
+                                              "v23_ativo") if n not in outs])
+        sys.exit(1)
+    print("=" * 76)
+    print("TESTE REAL v23 — A/B PAREADO EXATO (48 passos, corpus P9-fresco)")
+    print("=" * 76)
+    for nome, r in outs.items():
+        p = r["perdas"]
+        if len(p) >= 2:
+            ganho = p[0] / max(1e-9, p[-1])
+            print(f"  {nome:24s} {p[0]:.3f} → {p[-1]:.3f} "
+                  f"({ganho:.3f}×) [{r['passos']} passos, "
+                  f"{r['t_acum_s']:.0f}s]")
+    pb = outs["baseline_v22_semantica"]["perdas"]
+    pv = outs["v23_ativo"]["perdas"]
+    n = min(len(pb), len(pv))
+    if n >= 2:
+        db = np.mean(pb[:n])
+        dv = np.mean(pv[:n])
+        print(f"  ΔCE médio (v23 − baseline) = {dv - db:+.4f} "
+              f"(braços com UMA variável: semântica v22 vs v23)")
+    print()
+    print("AUDITORIAS ESTRUTURAIS v23 (braço B):")
+    a = outs["v23_ativo"].get("audit", {})
+    print(f"  peso_arvore grad VIVO (A-23): "
+          f"{a.get('peso_arvore_grad_vivo')} "
+          f"(grad={a.get('peso_arvore_grad_valor')})")
+    if os.path.exists(EVENTOS):
+        evj = json.load(open(EVENTOS, encoding="utf-8"))
+        pul = [e for e in evj["eventos"] if e["tipo"] == "PULADA"]
+        print(f"  P9 (sem eval no treino): {len(pul)} fonte(s) pulada(s) — "
+              f"{[e['fonte'] for e in pul]}")
+        print(f"  coleta: {evj['n']} registros reais em {evj['segundos']}s")
+    print()
+    print("Leitura honesta: o A/B isola a SEMÂNTICA dos 3 fixes de treino")
+    print("(PCGrad/RoPE/árvore). ΔCE de corrida curta NÃO é a métrica")
+    print("primária — os fixes são de CORREÇÃO (Teos 35.1/35.8/35.13), com")
+    print("invariantes provados; o treino real confirma que NÃO há regressão")
+    print("e que o progresso monótono se mantém.")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--coletar", action="store_true")
+    ap.add_argument("--variante", choices=["baseline_v22_semantica",
+                                           "v23_ativo"])
+    ap.add_argument("--parte", type=int, default=0)
+    ap.add_argument("--relatorio", action="store_true")
+    args = ap.parse_args()
+    if args.coletar:
+        coletar()
+    elif args.variante:
+        res = rodar_variante(args.variante, args.parte)
+        salvar_parcial(args.variante, res)
+    elif args.relatorio:
+        relatorio()
+    else:
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    main()

scripts/37_graficos_v23.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+"""37_graficos_v23.py — evidências GRÁFICAS do v23 (doc 35).
+
+3 painéis:
+  (1) A/B REAL pareado 48 passos — CE(baseline_v22_semantica) vs CE(v23_ativo)
+      (corpus v23 fresco, 1612 registros reais, filtro P9 ativo);
+  (2) PCGrad: violações dos invariantes I1/I2/I3 por variante
+      (100.083 pares — verif_pcgrad_invariantes.py, doc 35 §1);
+  (3) RoPE: score de atenção vs passo t — constante (bug A-03) vs com offset
+      (Teo 35.8) — verif_pcgrad_rope.py §B.
+
+Uso: python3 scripts/37_graficos_v23.py
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import numpy as np
+
+RAIZ = os.environ.get("KHTST_RAIZ", os.path.dirname(
+    os.path.dirname(os.path.abspath(__file__))))
+SAIDA_DIR = os.path.join(RAIZ, "graficos", "v23")
+
+
+def painel_ab(ax) -> None:
+    cam_b = os.path.join(RAIZ, "telemetria_out",
+                         "resultado_v23_baseline_v22_semantica.json")
+    cam_v = os.path.join(RAIZ, "telemetria_out", "resultado_v23_v23_ativo.json")
+    rb = json.load(open(cam_b, encoding="utf-8"))
+    rv = json.load(open(cam_v, encoding="utf-8"))
+    pb, pv = np.array(rb["perdas"], dtype=float), np.array(rv["perdas"],
+                                                           dtype=float)
+    n = min(len(pb), len(pv))
+    x = np.arange(1, n + 1)
+    # suavização leve (média móvel 5) para leitura — valores crus em linha fina
+    ax.plot(x, pb[:n], lw=0.7, alpha=0.35, color="#b0623a")
+    ax.plot(x, pv[:n], lw=0.7, alpha=0.35, color="#2a6f6f")
+    k = 5
+    sb = np.convolve(pb[:n], np.ones(k) / k, mode="valid")
+    sv = np.convolve(pv[:n], np.ones(k) / k, mode="valid")
+    ax.plot(x[k - 1:], sb, lw=2.2, color="#b0623a",
+            label=f"baseline (semântica v≤22)  {pb[0]:.2f}→{pb[n-1]:.2f}")
+    ax.plot(x[k - 1:], sv, lw=2.2, color="#2a6f6f",
+            label=f"v23 (PCGrad⊥+RoPE offset+árvore viva)  {pv[0]:.2f}→{pv[n-1]:.2f}")
+    ax.set_xlabel("passo (corpus real P9-fresco, 1612 registros)")
+    ax.set_ylabel("perda CE (lote 4)")
+    ax.set_title("A/B pareado exato 48 passos — corpus real, Teo 31.7")
+    ax.legend(loc="upper right", fontsize=8)
+    ax.grid(alpha=0.25)
+
+
+def painel_pcgrad(ax) -> None:
+    # re-executa a prova numpy (rápida: 20k pares) — MESMOS números do script
+    rng = np.random.default_rng(20261016)
+    EPS = 1e-8
+    nomes = ("código v≤22\n(reescala)", "correção\nagente (dobra)",
+             "v23 correto\n(projeta)")
+    viol = np.zeros((3, 3))          # [variante, invariante]
+    n_pares = 0
+    for _ in range(40000):
+        gm = rng.normal(size=32)
+        ga = rng.normal(size=32)
+        dot = float(gm @ ga)
+        n2 = float(gm @ gm)
+        if dot >= 0 or n2 <= EPS:
+            continue
+        n_pares += 1
+        for vi, (f_sig, modo) in enumerate(((-1.0, "escala"),
+                                            (-1.0, "projeta"),
+                                            (+1.0, "projeta"))):
+            f = f_sig * dot / n2
+            g = gm + ((f * ga) if modo == "escala" else (ga - f * gm))
+            aux = g - gm
+            viol[vi, 0] += not (abs(float(aux @ gm)) <= 1e-9 * max(1.0, n2))
+            viol[vi, 1] += not (float(aux @ aux) <= float(ga @ ga) + 1e-9)
+            viol[vi, 2] += not ((float(g @ gm) >= -1e-9)
+                                and (float(g @ aux) >= -1e-9))
+    pct = 100.0 * viol / max(1, n_pares)
+    x = np.arange(3)
+    w = 0.26
+    for ii, (nome_i, cor) in enumerate((("I1 ortogonalidade", "#8c2d2d"),
+                                        ("I2 contração", "#c47f17"),
+                                        ("I3 não-piora", "#555f8c"))):
+        ax.bar(x + (ii - 1) * w, pct[:, ii], w, label=nome_i, color=cor)
+    for xi in range(3):
+        ax.text(x[xi], 101.5, f"{int(viol[xi].sum())} violações totais",
+                ha="center", fontsize=8)
+    ax.set_xticks(x)
+    ax.set_xticklabels(nomes, fontsize=8)
+    ax.set_ylim(0, 112)
+    ax.set_ylabel("% dos pares em conflito")
+    ax.set_title(f"PCGrad × invariantes de Yu et al. ({n_pares:,} pares, "
+                 f"doc 35 §1)")
+    ax.legend(fontsize=8)
+    ax.grid(alpha=0.25, axis="y")
+
+
+def painel_rope(ax) -> None:
+    def rope(pos, dim=8, base=10000.0):
+        freqs = base ** (-np.arange(0, dim, 2) / dim)
+        ang = np.outer(np.asarray(pos, dtype=float), freqs)
+        return np.cos(ang), np.sin(ang)
+
+    def rot(x, c, s):
+        x1, x2 = x[..., 0::2], x[..., 1::2]
+        out = np.stack((x1 * c - x2 * s, x1 * s + x2 * c), axis=-1)
+        return out.reshape(*out.shape[:-2], out.shape[-2] * out.shape[-1])
+
+    rng = np.random.default_rng(7)
+    q = rng.normal(size=(1, 1, 1, 8))
+    k_cached = rng.normal(size=(1, 1, 5, 8))
+    ts = np.arange(1, 21)
+    sem, com = [], []
+    for t in ts:
+        c0, s0 = rope([0], 8)
+        q0 = rot(q, c0, s0)
+        cc, sc = rope(np.arange(5), 8)
+        k_rot = rot(k_cached, cc, sc)
+        sem.append(float((q0 * k_rot).sum(-1).max()))
+        ct, st_ = rope([t], 8)
+        qt = rot(q, ct, st_)
+        com.append(float((qt * k_rot).sum(-1).max()))
+    ax.plot(ts, sem, "o-", color="#8c2d2d", ms=3.5,
+            label="sem offset (v≤22): score CONSTANTE em t (bug A-03)")
+    ax.plot(ts, com, "s-", color="#2a6f6f", ms=3.5,
+            label="com offset (v23): score = ⟨q, R_{j−t}k⟩ (Teo 35.8)")
+    ax.set_xlabel("passo de decodificação t (posição absoluta do token novo)")
+    ax.set_ylabel("max_j ⟨q_rot, k_rot⟩")
+    ax.set_title("RoPE na decodificação com KV-cache (5 chaves, dim 8)")
+    ax.legend(fontsize=8)
+    ax.grid(alpha=0.25)
+
+
+def main() -> None:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.font_manager as fm
+    for f in ("/usr/share/fonts/truetype/chinese/NotoSansSC-Regular.ttf",
+              "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"):
+        if os.path.exists(f):
+            fm.fontManager.addfont(f)
+    import matplotlib.pyplot as plt
+    plt.rcParams["font.sans-serif"] = ["DejaVu Sans", "Noto Sans SC"]
+    plt.rcParams["axes.unicode_minus"] = False
+
+    os.makedirs(SAIDA_DIR, exist_ok=True)
+    fig, axs = plt.subplots(1, 3, figsize=(17.5, 5.2),
+                            constrained_layout=True)
+    painel_ab(axs[0])
+    painel_pcgrad(axs[1])
+    painel_rope(axs[2])
+    fig.suptitle("KHTST v23 — auditoria independente corrigida (doc 35): "
+                 "correções com provas + treino real sem regressão",
+                 fontsize=12, fontweight="bold")
+    saida = os.path.join(SAIDA_DIR, "v23_evidencias.png")
+    fig.savefig(saida, dpi=150)
+    print(f"gráfico → {saida}")
+
+
+if __name__ == "__main__":
+    main()

scripts/38_publicar_v23.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Publica o KHTST v23 no HuggingFace — UM ÚNICO COMMIT COMPLETO
+(anti-bloqueio do Hub: `upload_folder` + `delete_patterns=["*"]`
+substitui ATOMICAMENTE todo o conteúdo; nunca há uploads parciais em
+sequência curta — requisito do usuário).
+
+INCLUI: README (card v23) · LICENSE · requirements · configs/ (L=6) ·
+src/khtst/ (PCGrad correto, RoPE com desloc, validação 5:1, checkpoint
+atômico, IPC com header lido — .so recompilado, dedup/NFC, filtro P9,
+hub com buffer, acumulação sem viés, MoA com árvore viva) ·
+auditoria_independente/ (4 scripts hardened + 3 docs da auditoria
+RESOLVIDOS) · scripts/ (36 teste v23, 37 gráficos, 38 publicar) ·
+docs/matematica/ (00–35, doc 35 NOVO com erratas nos 26/28) ·
+tests/ (v1–v23 + conftest) · patches/ · PLANO_KHMAMBAJEPA.md ·
+RELATORIO_KHTST.md · graficos/ (v23 incluso).
+
+EXCLUI: venv/ · __pycache__ · cache_dados · telemetria_out ·
+cache_hub_tmp · .git · build · estados*/ · stage*/ · upload/ ·
+qualquer `.pt/.pth/.ckpt/.safetensors/.bin` (REQUISITO: nenhum estado
+de treino no Hub) · qualquer arquivo com padrão de token hf_...
+
+SEGURANÇA: token EXCLUSIVAMENTE da variável de ambiente HF_TOKEN —
+nunca gravado em arquivo, log, repo ou remote URL.
+
+Uso:  HF_TOKEN=hf_... python3 scripts/38_publicar_v23.py [--repo ...]
+"""
+import argparse
+import os
+import re
+import shutil
+import sys
+
+RAIZ = "/home/z/my-project/khtst"
+STAGE = "/home/z/my-project/khtst/stage_publicar_v23"
+IGNORAR_DIRS = {"__pycache__", "cache_dados", "telemetria_out",
+                "cache_hub_tmp", ".git", "build", "venv", ".venv",
+                "estados_local", "estados_local_teste", "estados",
+                "stage_publicar", "stage_publicar_v17",
+                "stage_publicar_v18", "stage_publicar_v19",
+                "stage_publicar_v20", "stage_publicar_v21",
+                "stage_publicar_v22", "stage_publicar_v23", "hf_stage",
+                "download", "upload", "node_modules"}
+IGNORAR_NOMES = {"resultados_v21.json", "resultados_v20.json"}
+IGNORAR_EXT = (".pt", ".pth", ".ckpt", ".safetensors", ".pyc", ".pt.tmp",
+               ".bin")
+PADRAO_TOKEN = re.compile(r"hf_[A-Za-z0-9]{30,}")
+RESIDUOS_PROIBIDOS = ("bugwatch",)
+
+
+def preparar_stage() -> int:
+    if os.path.exists(STAGE):
+        shutil.rmtree(STAGE)
+    n = 0
+    for raiz, dirs, arquivos in os.walk(RAIZ):
+        dirs[:] = [d for d in dirs if d not in IGNORAR_DIRS]
+        rel = os.path.relpath(raiz, RAIZ)
+        alvo_raiz = os.path.join(STAGE, rel) if rel != "." else STAGE
+        os.makedirs(alvo_raiz, exist_ok=True)
+        for a in arquivos:
+            if a.endswith(IGNORAR_EXT) or a.startswith("."):
+                continue
+            if a in IGNORAR_NOMES:
+                continue
+            if any(r in a.lower() for r in RESIDUOS_PROIBIDOS):
+                print(f"  [RESÍDUO] ignorado: {a}")
+                continue
+            origem = os.path.join(raiz, a)
+            destino = os.path.join(alvo_raiz, a)
+            shutil.copy2(origem, destino)
+            n += 1
+    return n
+
+
+def auditar_stage() -> int:
+    """Auditoria: 0 estados de treino, 0 tokens, 0 resíduos."""
+    problemas = 0
+    n_arq = 0
+    for raiz, dirs, arquivos in os.walk(STAGE):
+        for a in arquivos:
+            n_arq += 1
+            cam = os.path.join(raiz, a)
+            if a.endswith(IGNORAR_EXT):
+                print(f"  [ESTADO] {cam}"); problemas += 1
+                continue
+            try:
+                with open(cam, "rb") as f:
+                    dados = f.read()
+            except OSError:
+                continue
+            if PADRAO_TOKEN.search(dados.decode("utf-8", errors="ignore")):
+                print(f"  [TOKEN] {cam}"); problemas += 1
+    print(f"stage: {n_arq} arquivos | problemas: {problemas}")
+    return problemas
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo", default="PowerMachine/khtst-multimodal-ptbr")
+    args = ap.parse_args()
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("ERRO: HF_TOKEN ausente no ambiente"); return 1
+    from huggingface_hub import HfApi, upload_folder
+    api = HfApi(token=token)
+
+    print("== preparando stage ==")
+    n = preparar_stage()
+    print(f"{n} arquivos copiados para o stage")
+    print("== auditando stage (estados/tokens/resíduos) ==")
+    if auditar_stage() > 0:
+        print("ERRO: stage contém itens proibidos — abortando"); return 1
+
+    print("== commit ÚNICO no Hub (upload_folder + delete_patterns) ==")
+    upload_folder(
+        repo_id=args.repo,
+        repo_type="model",
+        folder_path=STAGE,
+        commit_message=(
+            "KHTST v23 — auditoria independente integrada: correções válidas "
+            "aplicadas com provas (doc 35, Teos 35.1-35.14) e claims "
+            "refutadas documentadas (doc 35 §11). PCGrad PROJETA "
+            "(fator=dot/n2, g=gm+(ga-fator*gm) — 0 violações I1/I2/I3 em "
+            "100.083 pares; o antigo reescalava e violava a não-piora em "
+            "25,3%); RoPE com OFFSET de cache (desloc absoluto propagado — "
+            "score de decode varia com t; era constante 2,756113); tronco "
+            "5:1 REAL (n_camadas=6, validação do campo que constrói o "
+            "tronco; L=3 reprovado); checkpoint ATÔMICO (tmp+fsync+replace+"
+            "fsync-dir, hash obrigatória, antigos por último); IPC lê a "
+            "capacidade do HEADER (divergência=ValueError, fallback+Cython); "
+            "dedup texto+entrada+saida+midia (29,5%->8,7%) + NFC; filtro P9 "
+            "sem vazamento eval->treino (9 benchmarks pulados, hendrycks em "
+            "train, Fable train); acumulação sem viés na retomada; hub com "
+            "buffer + fechar(); mecanismo árvore VIVO (A-23, y+0*y_a=y bit "
+            "a bit); erratas doc 26/28 (Sigma 1/tau diverge, T_tau=168,76, "
+            "dH/dT=Var/T3, h^2/12 densidade contínua); auditoria HARDENED "
+            "em auditoria_independente/ (4 scripts com assert+exit, 4/4 "
+            "verdes); corpus real fresco 1612 registros com P9 (MATH-500 "
+            "PULADA); A/B pareado 48 passos + grad peso_arvore vivo medido; "
+            "suíte v23 35/35, regressão v1-v22 zero, verificar_tudo 49✓"),
+        delete_patterns=["*"],
+        token=token,
+    )
+    print("== auditoria pós-upload ==")
+    info = api.repo_info(args.repo, files_metadata=False)
+    arq_hub = [s.rfilename for s in info.siblings]
+    estados = [a for a in arq_hub if a.endswith(IGNORAR_EXT)]
+    resid = [a for a in arq_hub if any(r in a.lower()
+                                       for r in RESIDUOS_PROIBIDOS)]
+    chaves_v23 = [a for a in arq_hub if
+                  "35-auditoria-independente" in a or
+                  a.endswith("auditoria_independente/README.md") or
+                  a.endswith("scripts/36_teste_v23.py") or
+                  a.endswith("scripts/37_graficos_v23.py") or
+                  a.endswith("tests/test_khtst_v23.py") or
+                  a.endswith("tests/conftest.py") or
+                  a.endswith("graficos/v23/v23_evidencias.png") or
+                  a.endswith("auditoria_independente/verif_pcgrad_invariantes.py")]
+    estados_locais = [a for a in arq_hub if a.startswith("cache_dados/")
+                      or a.startswith("telemetria_out/")]
+    print(f"arquivos no Hub: {len(arq_hub)}")
+    print(f"estados de treino no Hub: {len(estados)} {estados[:5]}")
+    print(f"resíduos: {len(resid)}")
+    print(f"cache_dados/telemetria vazados: {len(estados_locais)}")
+    print(f"chaves v23 presentes: {len(chaves_v23)} -> {chaves_v23}")
+    ok = (len(estados) == 0 and len(resid) == 0
+          and len(estados_locais) == 0 and len(chaves_v23) == 7)
+    print("PUBLICAÇÃO v23 " + ("OK ✓" if ok else "COM PROBLEMAS ✗"))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/khtst/dados/checkpoints.py

@@ -13,6 +13,15 @@ uploads parciais em sequência curta:
   06_publicar_hf.py chama `preparar_para_publicacao`, que copia o par
   (modelo.safetensors, meta.json) para o stage) — um único commit organizado.
 
+v23 (Teo 35.3 — auditoria independente, correção I-03): escrita ATÔMICA de
+verdade — (a) tensor e meta gravados em `*.tmp` + `os.fsync` + `os.replace`
+(replace é atômico em POSIX: o leitor vê ou o arquivo antigo completo, ou o
+novo completo — nunca um estado intermediário); (b) os checkpoints antigos só
+são apagados DEPOIS que o novo par está completo e sincronizado (um crash
+durante o salvar deixa o antigo carregável); (c) `carregar` EXIGE meta com
+hash SHA-256 válido (a validação silenciosa quando o meta faltava aceitava
+tensor truncado — agora rejeita com evento explícito).
+
 Teorema 16.9 (integridade do snapshot): seja σ o par gravado atomicamente
 com hash h(σ)=SHA-256. Na leitura, se h(σ')=h(σ) então σ'=σ (colisão
 desprezível, 2^−256), logo retomadas reproduzem EXATAMENTE o estado salvo.
@@ -76,12 +85,34 @@ class GestorCheckpoints:
         meta["n_tensores"] = len(tensores)
         destino = self._caminho_tag(tag)
         os.makedirs(destino, exist_ok=True)
-        with open(os.path.join(destino, "modelo.safetensors"), "wb") as f:
+        # v23 (Teo 35.3): escrita ATÔMICA — tmp + fsync + os.replace. Um crash
+        # em qualquer ponto deixa ou o par antigo completo, ou o novo completo.
+        cam_tensor = os.path.join(destino, "modelo.safetensors")
+        cam_meta = os.path.join(destino, "meta.json")
+        tmp_tensor = cam_tensor + ".tmp"
+        tmp_meta = cam_meta + ".tmp"
+        with open(tmp_tensor, "wb") as f:
             f.write(dados)
-        with open(os.path.join(destino, "meta.json"), "w", encoding="utf-8") as f:
+            f.flush()
+            os.fsync(f.fileno())
+        with open(tmp_meta, "w", encoding="utf-8") as f:
             json.dump(meta, f, ensure_ascii=False, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_tensor, cam_tensor)
+        os.replace(tmp_meta, cam_meta)
+        # fsync do DIRETÓRIO: garante que as entradas renomeadas persistem
+        try:
+            fd_dir = os.open(destino, os.O_RDONLY)
+            try:
+                os.fsync(fd_dir)
+            finally:
+                os.close(fd_dir)
+        except OSError:
+            pass
         # higiene: mantém a última tag + tags protegidas (fases do gate de
-        # rollback: pre-dpo/fase-dpo/pre-som/fase-som — Teorema 20.3)
+        # rollback: pre-dpo/fase-dpo/pre-som/fase-som — Teorema 20.3).
+        # v23: a limpeza só acontece DEPOIS do par novo completo+fsync.
         removidos = 0
         for nome in os.listdir(self.dir_local):
             if nome != tag and nome not in self.tags_protegidas:
@@ -107,12 +138,18 @@ class GestorCheckpoints:
         with open(caminho, "rb") as f:
             dados = f.read()
         meta_path = os.path.join(self._caminho_tag(tag), "meta.json")
-        if os.path.exists(meta_path):
-            with open(meta_path, encoding="utf-8") as f:
-                esperado = json.load(f).get("hash_sha256")
-            if esperado and _sha256_bytes(dados) != esperado:
-                self.eventos.append(f"checkpoint {tag}: HASH divergente — rejeitado")
-                return False
+        # v23 (Teo 35.3-ii): validação de hash OBRIGATÓRIA. Antes, meta
+        # ausente pulava a checagem em silêncio e aceitava tensor truncado.
+        if not os.path.exists(meta_path):
+            self.eventos.append(
+                f"checkpoint {tag}: meta.json ausente — REJEITADO (hash "
+                "não verificável; estado possivelmente truncado)")
+            return False
+        with open(meta_path, encoding="utf-8") as f:
+            esperado = json.load(f).get("hash_sha256")
+        if not esperado or _sha256_bytes(dados) != esperado:
+            self.eventos.append(f"checkpoint {tag}: HASH divergente/ausente — rejeitado")
+            return False
         try:
             sd = _st_load(dados)
             # compat v5: snapshots antigos SEM prefixo "modelo/" (sem estado

src/khtst/dados/streaming.py

@@ -27,6 +27,7 @@ import io
 import json
 import os
 import shutil
+import unicodedata
 
 import numpy as np
 import pyarrow.parquet as pq
@@ -42,7 +43,46 @@ CACHE_TMP = "/home/z/my-project/cache_hub_tmp"
 
 
 def _hash_texto(t: str) -> str:
-    return hashlib.sha1(t.encode("utf-8", "ignore")).hexdigest()[:16]
+    # v23 (P11/T-08): NFC no ponto de entrada — o BPE foi treinado em NFC
+    # (0/1.500 textos reais em NFD, medido); texto NFD custa 1,198× tokens
+    # e quebra o dedup entre formas canônicas. NFC é idempotente ⟹ zero
+    # custo para o texto já canônico (Teo 35.6).
+    return hashlib.sha1(unicodedata.normalize("NFC", t)
+                        .encode("utf-8", "ignore")).hexdigest()[:16]
+
+
+def _hash_midia(m) -> str:
+    """v23 (P4/T-02): hash estável da mídia para a chave de dedup.
+    bytes → sha1 dos bytes; str (path/uri) → sha1 do caminho; PIL/numpy →
+    sha1 dos bytes crus; None → vazio. NUNCA inventa conteúdo."""
+    if m is None:
+        return ""
+    try:
+        if isinstance(m, (bytes, bytearray)):
+            return hashlib.sha1(bytes(m)).hexdigest()[:12]
+        if isinstance(m, str):
+            return hashlib.sha1(m.encode("utf-8", "ignore")).hexdigest()[:12]
+        if hasattr(m, "tobytes"):
+            return hashlib.sha1(m.tobytes()).hexdigest()[:12]
+    except Exception:
+        return ""
+    return ""
+
+
+def _chave_dedup(reg: dict) -> str:
+    """v23 (Teo 35.7, correção P4/T-02): a chave antiga era
+    `texto or saida or entrada` — para registros seq2seq (entrada→saida,
+    sem texto) só a SAÍDA entrava: duas perguntas diferentes com a mesma
+    resposta colidiam (29,5% do corpus real descartado — medido na
+    auditoria; a chave correta recupera +24%). A chave nova cobre os três
+    campos de texto + hash da mídia: injetiva na tupla (texto, entrada,
+    saida, mídia) com probabilidade 1−2^−64 (sha1-16 hex por campo).
+    Idempotente NFC (via _hash_texto/_hash_midia sobre formas canônicas)."""
+    return "|".join((_hash_texto(reg.get("texto") or ""),
+                     _hash_texto(reg.get("entrada") or ""),
+                     _hash_texto(reg.get("saida") or ""),
+                     _hash_midia(reg.get("imagem")) or
+                     _hash_midia(reg.get("audio"))))
 
 
 def limpar_cache_temp():
@@ -857,21 +897,29 @@ class StreamingCorpus:
         {"id": "marcelohaps/verbovision-oracle-facts-pt", "ad": _ad_verbovision,
          "via": "stream", "max": 220},
         {"id": "amalia-llm/MMMU-PT", "ad": _ad_mmmu, "via": "stream",
-         "split": "validation", "max": 110},
+         "split": "validation", "max": 110,
+         "papel": "avaliacao"},   # v23 P9: benchmark avaliado — só validation
         {"id": "amalia-llm/MMMU-Pro-PT", "ad": _ad_mmmu, "via": "stream",
-         "split": "test", "max": 90},
+         "split": "test", "max": 90,
+         "papel": "avaliacao"},   # v23 P9
         {"id": "amalia-llm/OCRBench-PT", "ad": _ad_ocrbench, "via": "stream",
-         "split": "test", "max": 140},
+         "split": "test", "max": 140,
+         "papel": "avaliacao"},   # v23 P9
         {"id": "amalia-llm/COCO-Caption2017-PT", "ad": _ad_coco_pt, "via": "stream",
-         "split": "validation", "max": 190},
+         "split": "validation", "max": 190,
+         "papel": "avaliacao"},   # v23 P9: probe datasets-server — SÓ validation
         {"id": "weikaih/imaginative-perception-token-pt-eval-real", "ad": _ad_weikaih,
-         "via": "stream", "split": "td_path", "max": 110},
+         "via": "stream", "split": "td_path", "max": 110,
+         "papel": "avaliacao"},   # v23 P9: fonte É um benchmark de avaliação
         {"id": "opedromartins/asr-leaderboard-datasets-ptbr", "ad": _ad_asr,
-         "via": "stream", "config": "mls", "split": "test", "max": 60},
+         "via": "stream", "config": "mls", "split": "test", "max": 60,
+         "papel": "avaliacao"},   # v23 P9: todos os configs são test-only (probe)
         {"id": "opedromartins/asr-leaderboard-datasets-ptbr#tedx", "ad": _ad_asr,
-         "via": "stream", "config": "tedx", "split": "test", "max": 50},
+         "via": "stream", "config": "tedx", "split": "test", "max": 50,
+         "papel": "avaliacao"},   # v23 P9
         {"id": "opedromartins/asr-leaderboard-datasets-ptbr#fleurs", "ad": _ad_asr,
-         "via": "stream", "config": "fleurs", "split": "test", "max": 50},
+         "via": "stream", "config": "fleurs", "split": "test", "max": 50,
+         "papel": "avaliacao"},   # v23 P9
         {"id": "marcosremar2/pt-br-tts-synth", "ad": None, "via": "tts_marcos",
          "max": 240, "n_audio": 14},
         {"id": "leeaandrob/neurogrid-tts-synth-ptbr", "ad": None, "via": "degradado",
@@ -893,7 +941,7 @@ class StreamingCorpus:
         {"id": "laicsiifes/flickr30k-pt-br-human-translated", "ad": _ad_flickr30k,
          "via": "stream", "max": 160},
         {"id": "MoreThought/Fable-5.1-Max-Reasoning-Filtered-5000x", "ad": _ad_fable,
-         "via": "stream", "split": "lite", "max": 160},
+         "via": "stream", "split": "train", "max": 160},
         {"id": "mvp-lab/LLaVA-OneVision-1.5-Mid-Training-85M", "ad": _ad_llava_mid,
          "via": "stream", "max": 160},
         # --- degradado documentado (RAM/disco) ---
@@ -916,13 +964,14 @@ class StreamingCorpus:
         {"id": "pltops/evosynth-gsm8k-smoke-cerebras-gsm8k",
          "ad": _ad_matematica_generica(), "via": "stream", "max": 80},
         {"id": "HuggingFaceH4/MATH-500", "ad": _ad_matematica_generica(),
-         "via": "stream", "split": "test", "max": 100},
+         "via": "stream", "split": "test", "max": 100,
+         "papel": "avaliacao"},   # v23 P9: MATH-500 É um conjunto de avaliação
         {"id": "EleutherAI/hendrycks_math#algebra",
          "ad": _ad_matematica_generica(), "via": "stream",
-         "config": "algebra", "max": 50},
+         "config": "algebra", "split": "train", "max": 50},
         {"id": "EleutherAI/hendrycks_math#number_theory",
          "ad": _ad_matematica_generica(), "via": "stream",
-         "config": "number_theory", "max": 40},
+         "config": "number_theory", "split": "train", "max": 40},
         {"id": "open-r1/OpenR1-Math-220k", "ad": _ad_matematica_generica(
             chave_p=("problem",), chave_s=("solution",), chave_r=("answer",)),
          "via": "stream", "max": 100},
@@ -996,11 +1045,25 @@ class StreamingCorpus:
 
     def coletar(self) -> tuple[list[dict], list[EventoDataset]]:
         """Coleta sequencial (um dataset por vez) com dedup + limites +
-        limpeza de cache temporário após cada fonte."""
+        limpeza de cache temporário após cada fonte.
+
+        v23 (P9/T-03, Teo 35.14): fontes com `papel == "avaliacao"` NÃO
+        entram no corpus de treino (vazamento eval→treino — 9 fontes de
+        benchmark: MMMU/MMMU-Pro/OCRBench/COCO-Caption [só validation/test,
+        verificado no datasets-server], weikaih-eval-real, ASR×3 [test-only],
+        MATH-500). A válvula KHTST_INCLUIR_AVALIACAO=1 reabre EXPLICITAMENTE
+        (para coletas de benchmark; o default é a honestidade do treino)."""
+        incluir_avaliacao = os.environ.get("KHTST_INCLUIR_AVALIACAO", "") == "1"
         vistos: set[str] = set()
         registros: list[dict] = []
         for plano in self.PLANO:
             fonte, ad, maximo = plano["id"], plano["ad"], plano["max"]
+            if plano.get("papel") == "avaliacao" and not incluir_avaliacao:
+                self.eventos.append(EventoDataset(
+                    fonte, "PULADA",
+                    "split de avaliação (vazamento eval→treino bloqueado — "
+                    "P9/T-03; KHTST_INCLUIR_AVALIACAO=1 reabre)"))
+                continue
             n_ok = 0
             for ex in self._iterar_fonte(plano):
                 if n_ok >= maximo:
@@ -1008,8 +1071,13 @@ class StreamingCorpus:
                 reg = ad(ex) if ad else (ex if via_especial(plano["via"]) else None)
                 if reg is None:
                     continue
-                chave = _hash_texto(reg.get("texto") or reg.get("saida")
-                                    or reg.get("entrada") or "")
+                # v23 (P11): NFC nos campos de texto ANTES do dedup e do
+                # armazenamento — canonicalidade única no corpus inteiro.
+                for _campo in ("texto", "entrada", "saida"):
+                    v = reg.get(_campo)
+                    if isinstance(v, str) and v:
+                        reg[_campo] = unicodedata.normalize("NFC", v)
+                chave = _chave_dedup(reg)
                 if chave in vistos:
                     continue
                 vistos.add(chave)

src/khtst/ipc/_fallback.py

@@ -96,6 +96,19 @@ class KHTSTCanal:
         magic = c._ler_u64(_OFF_MAGIC) & 0xFFFFFFFF
         if magic != MAGIC_KHTST:
             raise ValueError(f"magic inválido na região: 0x{magic:08X}")
+        # v23 (Teo 35.4 — correção I-01/P6 do plano de auditoria): a
+        # capacidade gravada no header pelo PRODUTOR é lida e EXIGIDA
+        # consistente com a capacidade derivada do size recebido. Antes,
+        # um consumidor com size divergente anexava em silêncio e lia
+        # posições erradas quando tail ≥ cap própria (corrupção CRC32
+        # medida) ou 0 frames — agora a divergência é um erro ALTO e
+        # imediato, diagnóstico único na fronteira do processo.
+        cap_header = int(c._ler_u64(_OFF_CAPACITY))
+        if cap_header > 0 and cap_header != c._cap:
+            raise ValueError(
+                f"size divergente do produtor: capacidade do header "
+                f"({cap_header}) ≠ capacidade derivada de size={size} "
+                f"({c._cap}) — reanexe com o size do produtor")
         return c
 
     def _ler_u64(self, off: int) -> int:

src/khtst/ipc/khtst_ipc.cpython-312-x86_64-linux-gnu.so

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0460ea341b8ee6d872ff0bfa7281e25e660d02a0264848486e904f61b01dc968
-size 1771456
+oid sha256:1133441beccf124ee093e0b46936992b5b59d295501c3cf7006642ddc24e93ca
+size 1779384

src/khtst/ipc/khtst_ipc.pyx

@@ -270,7 +270,10 @@ cdef class KHTSTCanal:
 
     @classmethod
     def anexar(cls, int fd, size_t size):
-        """Anexa a uma região JÁ inicializada (FD recebido via SCM_RIGHTS)."""
+        """Anexa a uma região JÁ inicializada (FD recebido via SCM_RIGHTS).
+        v23 (Teo 35.4): valida a capacidade do HEADER contra a derivada do
+        size — divergência do produtor é erro ALTO (antes: leitura em
+        posições erradas quando tail ≥ cap própria, corrupção silenciosa)."""
         cdef KHTSTCanal c = cls.__new__(cls)
         c._mapear(fd, size)
         cdef uint32_t magic = 0
@@ -280,6 +283,13 @@ cdef class KHTSTCanal:
         c._cap = _next_pow2(size - _HEADER_SIZE) // 2
         if c._cap == 0 or (c._cap & (c._cap - 1)) != 0:
             raise ValueError(f"capacidade não é potência de 2: {c._cap}")
+        cdef unsigned long long cap_header = 0
+        memcpy(&cap_header, c._base + _OFF_CAPACITY, 8)
+        if cap_header > 0 and (<size_t> cap_header) != c._cap:
+            raise ValueError(
+                f"size divergente do produtor: capacidade do header "
+                f"({cap_header}) ≠ capacidade derivada de size={size} "
+                f"({c._cap}) — reanexe com o size do produtor")
         c._fd = fd
         c._eh_dono = 0
         return c

src/khtst/mamba3/tronco.py

@@ -84,10 +84,15 @@ class CamadaTroncoM3(nn.Module):
 
     # ----------------------------------------------------------- forward
     def forward(self, x, cache_k=None, cache_v=None, kv_max=512, coletar=None,
-                tarefa=None):
+                tarefa=None, desloc_rope: int = 0):
         """x: (B, T, d). Devolve (x, k, v) — k/v da NoPE (None nas Mamba3),
         interface v2 preservada. Decode incremental: T==1 + `_geracao` ativa
-        usa o estado Mamba-3 sedado pelo prefill (Teo 24.13)."""
+        usa o estado Mamba-3 sedado pelo prefill (Teo 24.13).
+        v23 (Teo 35.8): `desloc_rope` aceito por UNIFORMIDADE de interface
+        com os blocos MoA — aqui é IGNORADO por construção: a subcamada
+        sequencial é Mamba-3 (posicionalidade pelo ESTADO, não por índice)
+        e a atenção periódica é NoPE (sem encoding posicional — a invariância
+        translacional é o próprio desenho, doc 22 §3)."""
         self._tarefa_corrente = tarefa
         # --- 1) subcamada sequencial ---
         h = self.norm1(x)

src/khtst/nucleo/modelo.py

@@ -673,13 +673,21 @@ class KHTSTModel(nn.Module):
                 contador.adiciona(t0)
         buffer_oculto: list[torch.Tensor] = []
         metas_calibracao: list[dict] = []
+        # v23 (Teo 35.8) — referencial ABSOLUTO de posições do RoPE: a 1ª
+        # passada (prefill, T = prompt) usa desloc 0; cada passo de decode
+        # (T=1) usa a posição absoluta do token novo. Sem isso, o token novo
+        # recebia sempre pos=0 e o offset relativo (t−j) degenerava para
+        # (0−j) — score constante em t (bug A-03 da auditoria).
+        pos_abs = 0
         for passo in range(max_novos):
             co = {}
             for li, bloco in enumerate(self.blocos):
                 ck, cv = caches[li] if caches[li] != (None, None) else (None, None)
-                x, k, v = bloco(x, cache_k=ck, cache_v=cv, kv_max=kv_max, coletar=co,
-                                tarefa=tarefa)
+                x, k, v = bloco(x, cache_k=ck, cache_v=cv, kv_max=kv_max,
+                                coletar=co, tarefa=tarefa,
+                                desloc_rope=pos_abs)
                 caches[li] = (k, v)
+            pos_abs += x.shape[1]
             x = self.norm_f(x)
             # v4 — NLG modula o estado oculto (doc 15 §1: estilo aditivo)
             h_dec = self.nlg.condicionar(x) if self.nlg is not None else x

src/khtst/nucleo/validacao.py

@@ -9,7 +9,11 @@ o treino aborta com mensagem clara ANTES do primeiro passo.
 
 Teorema 30.7 (pré-condições): cada verificação abaixo é uma pré-condição
 de um teorema já provado no projeto — violá-la invalida a prova a montante:
-  • mamba3.n_camadas % 6 == 0  ⟹ proporção 5:1 termina em atenção (doc 22 §3);
+  • modelo.n_camadas % 6 == 0  ⟹ proporção 5:1 termina em atenção (doc 22 §3);
+    v23 (Teo 35.5): o check é sobre o campo que CONSTRÓI o tronco
+    (modelo.n_camadas → TroncoMamba3) — antes checava modelo.mamba3.n_camadas,
+    que é config morta para o tronco (só n_camadas_vl é consumido, pelo
+    Mamba3VL), e o tronco entregue (n_camadas=3) tinha ZERO camadas NoPE;
   • τ_min > 0 e τ₀ > τ_min     ⟹ barreira GSQ (Teo 26.5);
   • λ_* ≥ 0                    ⟹ pesos vivos e sinal correto (Teos 28.7/29.x);
   • lr_min ≤ lr_max, clip > 0  ⟹ Robbins–Monro com passo limitado (Teo 28.5);
@@ -59,6 +63,16 @@ def validar_config(cfg, modelo=None) -> list[str]:
         if comp < 2:
             problemas.append(f"modelo.comprimento_ctx={comp} deve ser ≥ 2")
         m3 = _get(m, "mamba3")
+        # v23 (Teo 35.5, correção A-04): o tronco é construído por
+        # TroncoMamba3(d, n_camadas=m.n_camadas) — a validação 5:1 deve
+        # checar ESTE campo. Com n_camadas=3 o padrão (i+1)%6==0 produz
+        # ZERO camadas NoPE e o contrato híbrido 5:1 não existe.
+        n_cam_tronco = int(_num(_get(m, "n_camadas", 1)))
+        if n_cam_tronco % 6 != 0:
+            problemas.append(
+                f"modelo.n_camadas={n_cam_tronco} deve ser MÚLTIPLO DE 6 "
+                "(o tronco híbrido 5:1 Mamba:NoPE é construído por ESTE campo "
+                "— Teo 22 §3; com n_camadas=3 o padrão (i+1)%6==0 dá 0 NoPE)")
         if m3 is not None and bool(_get(m3, "ativo", True)):
             n_cam = int(_num(_get(m3, "n_camadas", 6)))
             if n_cam % 6 != 0:

src/khtst/percepcao/atencao.py

@@ -36,11 +36,24 @@ RAIO_JANELA_PADRAO = 128      # era 32 (×4)
 KV_MAX_PADRAO = 2048          # era 512 (×4)
 
 
-def aplicar_rope(q: torch.Tensor, k: torch.Tensor, base: float = 10000.0) -> tuple[torch.Tensor, torch.Tensor]:
+def aplicar_rope(q: torch.Tensor, k: torch.Tensor, base: float = 10000.0,
+                 desloc: int = 0) -> tuple[torch.Tensor, torch.Tensor]:
     """RoPE padrão. q,k: (B, H, T, dk). Rotação relativa preserva produto interno
-    dependente apenas da diferença de posições (prova: e^{iθp} conjugação)."""
+    dependente apenas da diferença de posições (prova: e^{iθp} conjugação).
+
+    v23 (Teo 35.8 — correção A-03/P2 da auditoria): `desloc` é a posição
+    ABSOLUTA do primeiro elemento de q/k nesta chamada. A propriedade
+    ⟨R_p q, R_j k⟩ = ⟨q, R_{j−p} k⟩ exige que q e k compartilhem a MESMA
+    origem de posições: no prefill ambos usam desloc=0 (idêntico ao v22,
+    bit a bit); na decodificação com KV-cache o token novo ocupa a posição
+    absoluta `desloc` = nº de tokens já no cache — sem isso o offset
+    relativo (t−j) degenerava para (0−j) e o score ficava CONSTANTE em t
+    (medido na auditoria: 2,756113 para t=1,2,3,10). O recorte kv_max é
+    inofensivo: a rotação é aplicada ANTES do cache — as chaves antigas
+    carregam suas rotações absolutas originais.
+    """
     B, H, T, dk = q.shape
-    pos = torch.arange(T, device=q.device, dtype=torch.float32)
+    pos = torch.arange(desloc, desloc + T, device=q.device, dtype=torch.float32)
     freqs = base ** (-torch.arange(0, dk, 2, device=q.device, dtype=torch.float32) / dk)
     ang = torch.outer(pos, freqs)                      # (T, dk/2)
     cos, sin = ang.cos(), ang.sin()
@@ -92,12 +105,14 @@ class AtencaoCabecas(nn.Module):
         self.dropout = dropout
 
     def forward(self, x: torch.Tensor, cache_k: torch.Tensor | None = None,
-                cache_v: torch.Tensor | None = None, kv_max: int = KV_MAX_PADRAO):
+                cache_v: torch.Tensor | None = None, kv_max: int = KV_MAX_PADRAO,
+                desloc_rope: int = 0):
         B, T, D = x.shape
         q = self.wq(x).view(B, T, self.h, self.dk).transpose(1, 2)
         k = self.wk(x).view(B, T, self.h, self.dk).transpose(1, 2)
         v = self.wv(x).view(B, T, self.h, self.dk).transpose(1, 2)
-        q, k = aplicar_rope(q, k)
+        # v23 (Teo 35.8): desloc_rope = posição absoluta do 1º token de x
+        q, k = aplicar_rope(q, k, desloc=desloc_rope)
         if cache_k is not None:                       # decodificação: 1 token novo
             k = torch.cat([cache_k, k], dim=2)
             v = torch.cat([cache_v, v], dim=2)
@@ -171,12 +186,13 @@ class AtencaoArvore(nn.Module):
 
     def forward(self, x: torch.Tensor, cache_k: torch.Tensor | None = None,
                 cache_v: torch.Tensor | None = None, kv_max: int = KV_MAX_PADRAO,
-                causal: bool = True):
+                causal: bool = True, desloc_rope: int = 0):
         B, T, D = x.shape
         q = self.wq(x).view(B, T, self.h, self.dk).transpose(1, 2)
         k = self.wk(x).view(B, T, self.h, self.dk).transpose(1, 2)
         v = self.wv(x).view(B, T, self.h, self.dk).transpose(1, 2)
-        q, k = aplicar_rope(q, k)
+        # v23 (Teo 35.8): desloc_rope = posição absoluta do 1º token de x
+        q, k = aplicar_rope(q, k, desloc=desloc_rope)
         if cache_k is not None:
             k = torch.cat([cache_k, k], dim=2)
             v = torch.cat([cache_v, v], dim=2)
@@ -312,26 +328,54 @@ class MixtureOfAttention(nn.Module):
             if usar_arvore else None
 
     def forward(self, x, cache_k=None, cache_v=None, kv_max=KV_MAX_PADRAO,
-                coletar=None, estado_linear=None):
+                coletar=None, estado_linear=None, desloc_rope: int = 0):
         if self.gate_gsq is not None:                 # v14 — gate GSQ (3 opções)
             g = self.gate_gsq()
             if coletar is not None and hasattr(self.gate_gsq, "metrica"):
                 coletar["gate_gsq"] = self.gate_gsq.metrica()
         else:
             g = F.softmax(self.logits_gate, dim=0)
-        y_g, k, v = self.global_(x, cache_k, cache_v, kv_max)
-        y_j, _, _ = self.janela(x, cache_k, cache_v, kv_max)
+        # v23 (Teo 35.8): desloc_rope propagado aos mecanismos com RoPE —
+        # global/janela/árvore compartilham o mesmo referencial de posições
+        y_g, k, v = self.global_(x, cache_k, cache_v, kv_max,
+                                 desloc_rope=desloc_rope)
+        y_j, _, _ = self.janela(x, cache_k, cache_v, kv_max,
+                                desloc_rope=desloc_rope)
         y_l, est = self.linear(x, estado=estado_linear)
         y = g[0] * y_g + g[1] * y_j + g[2] * y_l
-        _peso_arv = float(self.peso_arvore.detach()) if self.peso_arvore is not None else 0.0
-        if self.arvore is not None and _peso_arv != 0.0:
+        # v23 (Teo 35.13, correção A-23 da auditoria): o curto-circuito
+        # `_peso_arv != 0.0` tornava o mecanismo ÁRVORE PERMANENTEMENTE
+        # INERTE — `peso_arvore` nasce em 0 (nascimento neutro, Teo 19.4),
+        # nunca é escrito quando y_a não é computado, e ∂y/∂peso_arvore =
+        # y_a nunca existia ⟹ o parâmetro nunca saía de 0 (mecanismo
+        # morto desde a v8). Correção com NASCIMENTO NEUTRO PRESERVADO:
+        # em TREINO com gradiente ativo, y_a é SEMPRE computado e o produto
+        # é pelo TENSOR — y + 0·y_a = y bit a bit (IEEE-754: 0·finito = ±0
+        # e x ± 0 = x exato), o gradiente ∂y/∂peso = y_a flui desde o 1º
+        # passo e o forward no nascimento é idêntico ao v≤22. Em eval /
+        # decode / no_grad o curto-circuito permanece (custo zero quando
+        # o peso ainda é 0 — orçamento de RAM/CPU do projeto).
+        _treino_arv = (self.arvore is not None
+                       and self.peso_arvore is not None
+                       and self.training and torch.is_grad_enabled()
+                       and self.peso_arvore.requires_grad)
+        if _treino_arv:
             # fora de ordem + bidirecional no espaço árvore; no decoder causal
             # a árvore preserva prefixo (ordem Euler) — Teorema 19.3/19.5
             y_a, _, _ = self.arvore(x, cache_k, cache_v, kv_max,
-                                    causal=(cache_k is None))
-            y = y + _peso_arv * y_a
+                                    causal=(cache_k is None),
+                                    desloc_rope=desloc_rope)
+            y = y + self.peso_arvore * y_a
+            if coletar is not None:
+                coletar["peso_arvore"] = float(self.peso_arvore.detach())
+        elif self.arvore is not None and self.peso_arvore is not None \
+                and float(self.peso_arvore.detach()) != 0.0:
+            y_a, _, _ = self.arvore(x, cache_k, cache_v, kv_max,
+                                    causal=(cache_k is None),
+                                    desloc_rope=desloc_rope)
+            y = y + float(self.peso_arvore.detach()) * y_a
             if coletar is not None:
-                coletar["peso_arvore"] = _peso_arv
+                coletar["peso_arvore"] = float(self.peso_arvore.detach())
         if coletar is not None:
             coletar["gate_atencao"] = [float(v_) for v_ in g.detach()]
         return y, k, v, est

src/khtst/percepcao/blocos.py

@@ -56,13 +56,14 @@ class Bloco(nn.Module):
         self._tarefa_corrente: str | None = None
 
     def forward(self, x, cache_k=None, cache_v=None, kv_max=512, coletar=None,
-                tarefa=None):
+                tarefa=None, desloc_rope: int = 0):
         # Caminho recorrente (estado linear) SÓ na decodificação pura (T==1);
         # treino e avaliação com T>1 usam o caminho paralelo exato.
         est_in = getattr(self, "_estado_linear", None) \
             if (not self.training and x.shape[1] == 1) else None
+        # v23 (Teo 35.8): desloc_rope propagado à MoA (RoPE com offset)
         h, k, v, est_out = self.atencao(self.norm1(x), cache_k, cache_v, kv_max, coletar,
-                                        estado_linear=est_in)
+                                        estado_linear=est_in, desloc_rope=desloc_rope)
         # estado da atenção linear persiste no prefill e na decodificação
         self._estado_linear = est_out if est_out is not None else None
         x = x + h
@@ -102,11 +103,12 @@ class BlocoV3(nn.Module):
         self.composto.registrar_confianca(h_t)
 
     def forward(self, x, cache_k=None, cache_v=None, kv_max=512, coletar=None,
-                tarefa=None):
+                tarefa=None, desloc_rope: int = 0):
         est_in = getattr(self, "_estado_linear", None) \
             if (not self.training and x.shape[1] == 1) else None
+        # v23 (Teo 35.8): desloc_rope propagado à MoA (RoPE com offset)
         h, k, v, est_out = self.atencao(self.norm1(x), cache_k, cache_v, kv_max, coletar,
-                                        estado_linear=est_in)
+                                        estado_linear=est_in, desloc_rope=desloc_rope)
         self._estado_linear = est_out if est_out is not None else None
         x = x + h
         self._tarefa_corrente = tarefa

src/khtst/percepcao/vit_lra.py

@@ -196,9 +196,16 @@ class DetectadorCinza(nn.Module):
       (i) IDENTIDADE: imagem com R=G=B (cinza exato) ⟹ χ = 0 ⟹ s = 1;
           imagem com croma médio χ̄ ⟹ s = 1 − χ̄ (forma fechada, sem
           hiperparâmetro aprendido — detecção PURA, sempre ativa);
-      (ii) LIPSCHITZ: χ é Lipschitz em I com constante 2/(max_c+ε) —
-          perturbação δ da imagem muda s por ≤ 2δ (robustez — a detecção
-          NÃO oscila com ruído de sensor);
+      (ii) LIPSCHITZ (doc 27, Teo 27.7(ii-a) — CORRIGIDO v23): χ é
+          Lipschitz com |∂χ/∂I| ≤ (mx + mn + 2ε)/(mx+ε)² ≤ 2/(mx+ε) + χ/(mx+ε)
+          — uma perturbação δ da imagem muda s por NO MÁXIMO 2δ/(mx+ε)
+          (não "2δ": o bound ingênuo do docstring antigo era FALSO —
+          pixel cinza 0,01 com um canal +0,001 dá |Δs| = 0,0901 = 45×
+          2δ, medido; o TEOREMA do doc 27 sempre esteve correto,
+          razão real/bound = 0,999989). Ressalva honesta: para imagens
+          bem-expostas (mx ≥ m̄) vale |Δs| ≲ 2δ/m̄ — a robustez DEGRADA
+          em pixels quase-pretos, exatamente onde o gate γ_c é mais
+          conservador;
       (iii) USO EM PARALELO: a ramificação 1-bit (contorno) é INTRINSECAMENTE
           cinza (usa só luminância) — s pondera QUANTA confiança dar à
           ramificação 4-bit colorida: em imagens quase-cinza (s→1) a

src/khtst/servico/adhoc.py

@@ -261,6 +261,8 @@ class SessaoKHTST:
             self.modelo.blocos.ativar_modo_geracao(1, x.device, x.dtype)
             contextos = [int(t) for t in p.ids_prompt]
             V = self.modelo.cfg.modelo.vocab
+            # v23 (Teo 35.8): referencial absoluto do RoPE (prefill + decode)
+            pos_abs = 0
             novo_token: bool = True
             while novo_token and passos < max_passos:
                 # ---- BOMBA ADHOC: processa I/O, stop e continue (Teo 19.14) ----
@@ -280,8 +282,10 @@ class SessaoKHTST:
                 for li, bloco in enumerate(self.modelo.blocos):
                     ck, cv = caches[li]
                     x, k, v = bloco(x, cache_k=ck, cache_v=cv, kv_max=kv_max,
-                                    coletar=co, tarefa=p.tarefa)
+                                    coletar=co, tarefa=p.tarefa,
+                                    desloc_rope=pos_abs)
                     caches[li] = (k, v)
+                pos_abs += x.shape[1]
                 x = self.modelo.norm_f(x)
                 logits = self.modelo.lm_head(x[:, -1]) / max(p.temperatura, 1e-3)
                 # punição dinâmica de repetição (eq. 10.8/10.9 — doc 10 §8)

src/khtst/telemetria/hub.py

@@ -68,6 +68,9 @@ class TelemetryHub:
         self._anterior_theta: dict[str, torch.Tensor] | None = None
         self.eventos_guard: list[str] = []
         self._inicio = time.time()
+        # v23 (Teo 35.10): buffer de escrita do JSONL (lote + borda de tempo)
+        self._buffer: list[str] = []
+        self._ultimo_flush = self._inicio
         # v18 (requisito §3.4): logging com NÍVEIS + ROTAÇÃO. Padrão: ligado
         # (INFO) ao lado do JSONL; `com_logger=False` desliga (testes).
         if logger is not None:
@@ -161,6 +164,33 @@ class TelemetryHub:
                 "historico_max": self.historico_max,
                 "log": self.logger.estatisticas() if self.logger else None}
 
+    # v23 (Teo 35.10, correção A-19): escrita com BUFFER — a versão antiga
+    # abria/fechava o arquivo a cada linha (até ~20 open/close por passo
+    # quando atributo+alerta+evento se somam — I/O-bound medido na
+    # auditoria). As linhas acumulam em memória e são descarregadas em
+    # LOTE quando (a) o buffer atinge _FLUSH_LINHAS, ou (b) passou
+    # _FLUSH_SEG de borda. Custo honesto: um crash perde no máximo ~2 s
+    # de telemetria (aceitável — telemetria nunca é estado de treino;
+    # os checkpoints são independentes). fechar() descarrega o resto.
+    _FLUSH_LINHAS = 64
+    _FLUSH_SEG = 2.0
+
     def _gravar(self, linha: dict) -> None:
+        self._buffer.append(json.dumps(linha, ensure_ascii=False))
+        agora = time.time()
+        if (len(self._buffer) >= self._FLUSH_LINHAS
+                or (agora - self._ultimo_flush) >= self._FLUSH_SEG):
+            self._descarregar()
+
+    def _descarregar(self) -> None:
+        if not self._buffer:
+            self._ultimo_flush = time.time()
+            return
         with open(self.arquivo, "a", encoding="utf-8") as f:
-            f.write(json.dumps(linha, ensure_ascii=False) + "\n")
+            f.write("\n".join(self._buffer) + "\n")
+        self._buffer.clear()
+        self._ultimo_flush = time.time()
+
+    def fechar(self) -> None:
+        """Descarrega o buffer pendente (chamar ao fim do treino/avaliação)."""
+        self._descarregar()

src/khtst/treino/cirurgia_grad.py

@@ -18,6 +18,18 @@ homogeneidade (caminho do gradiente da auxiliar aproximadamente linear em
 sua perda), igualar escalares iguala ‖g_aux‖; sem homogeneidade, o cap
 garante o bound do pior caso na escala ESCALAR (o que controla λs).
 
+v23 (Teo 35.1 — auditoria independente, correção A-01): a implementação
+original REESCALAVA g_aux por um escalar (g = gm + fator·ga, fator = −dot/n2)
+em vez de PROJETAR — a garantia de não-piora do PCGrad (Yu et al., 2020) era
+violada em 25,3% dos pares em conflito (medido; pior caso 1,73× o conflito
+original). A versão correta projeta g_aux no complemento ortogonal de g_main:
+  g_aux′ = g_aux − (dot/n2)·g_main   (o multiplicador é dot/n2, NEGATIVO
+  em conflito — a variante −dot/n2 com ga−fator·gm DOBRA o conflito:
+  ⟨g_aux′,g_main⟩ = 2·dot < 0).
+Invariantes (prova no doc 35 §2): I1 ⟨g_aux′,g_main⟩=0 exato; I2 contração
+‖g_aux′‖²=‖g_aux‖²−dot²/n2; I3 ⟨g_total,g_main⟩=n2≥0 e ⟨g_total,g_aux′⟩=‖g_aux′‖²≥0.
+Verificação numérica: 100.083 pares — 0 violações nas três.
+
 Contrato: quem chama faz `optimizer.zero_grad()` antes e `optimizer.step()`
 depois — aqui só se escreve `p.grad`.
 """
@@ -89,7 +101,10 @@ def pcgrad_duas_perdas(modelo_ou_params, perda_main: torch.Tensor,
         n2_main += float((gm * gm).sum())
     projetado = dot < 0.0 and n2_main > eps
     with torch.no_grad():
-        fator = -dot / n2_main if projetado else 0.0
+        # v23 (Teo 35.1): o multiplicador de g_main na projeção é (dot/n2) —
+        # NEGATIVO quando há conflito (dot<0). A forma antiga (−dot/n2 com
+        # fator·ga) reescalava g_aux e AMPLIFICAVA a direção conflitante.
+        fator = dot / n2_main if projetado else 0.0
     for p, gm, ga in zip(params, g_main, g_aux):
         if gm is None and ga is None:
             continue
@@ -98,7 +113,9 @@ def pcgrad_duas_perdas(modelo_ou_params, perda_main: torch.Tensor,
         elif ga is None:
             g = gm
         else:
-            g = gm + (fator * ga if projetado else ga)
+            # v23: PROJEÇÃO de g_aux no complemento ortogonal de g_main
+            # (Yu et al., 2020, Alg. 2) — não reescala g_aux.
+            g = gm + (ga - fator * gm if projetado else ga)
         p.grad = g.detach() if p.grad is None else p.grad + g.detach()
     return {"pcgrad/dot": dot, "pcgrad/projetado": float(projetado),
             "pcgrad/fator": fator}

src/khtst/treino/treinador.py

@@ -194,6 +194,12 @@ class TreinadorExtensao(MixinLR, MixinPerdas, MixinEstado, MixinFases,
             self.camadas_gsq = [m for m in modelo.modules()
                                 if isinstance(m, CamadaGSQRCO)]
         self.passo_global = 0
+        # v23 (Teo 35.9): tamanho real do grupo de acumulação corrente
+        # (nascido cheio; realinhado na retomada por retomar_estado).
+        # Derivado direto do cfg — `self.lote_efetivo` só é atribuído mais
+        # abaixo no __init__ (v14, §ensemble) e testes com cfg mínimo não
+        # passam por lá antes daqui (correção de integração da suíte v13/v16).
+        self._n_acc_atual = max(1, int(getattr(cfg.treino, "lote_efetivo", 1)))
         self.epoca = 0
         self.t_ciclo = 0
         self.T_ciclo = cfg.treino.warmup + cfg.treino.janela_estagnacao * 4
@@ -706,10 +712,18 @@ class TreinadorExtensao(MixinLR, MixinPerdas, MixinEstado, MixinFases,
         # gradiente) e Var[ĝ_acc] = Var[∇L(lote físico)]/n_acc — mesma média,
         # ruído ↓ √n_acc, SEM o pico de ativações do lote físico grande.
         n_acc = self.lote_efetivo
+        # v23 (Teo 35.9, correção A-05): tamanho REAL do grupo corrente.
+        # Numa corrida fresca, `_n_acc_atual == n_acc` sempre (bit a bit
+        # igual ao v22). Numa RETOMADA no meio de um grupo (passo_global %
+        # n_acc = k ≠ 0), o grupo finalizado logo após a retomada teria só
+        # n_acc−k micros com perda dividida por n_acc — E[ĝ] enviesado por
+        # (n_acc−k)/n_acc. Dividir pelo tamanho real do grupo repara o
+        # estimador: E[ĝ] = ∇L(média dos micros do grupo) exatamente.
+        n_atual = max(1, int(getattr(self, "_n_acc_atual", n_acc)))
         micro_final = (self.passo_global % n_acc) == (n_acc - 1)
-        if n_acc > 1:
-            perda_ce_total = perda_ce_total / n_acc
-            perda_aux = perda_aux / n_acc if perda_aux is not None else None
+        if n_atual > 1:
+            perda_ce_total = perda_ce_total / n_atual
+            perda_aux = perda_aux / n_atual if perda_aux is not None else None
         # backward: PCGrad (Teorema 10.10) ou soma simples
         if self.passo_global % n_acc == 0:            # 1º micro do grupo
             self.otimizador.zero_grad(set_to_none=True)
@@ -775,6 +789,8 @@ class TreinadorExtensao(MixinLR, MixinPerdas, MixinEstado, MixinFases,
         for gp in self.otimizador.param_groups:
             gp["lr"] = lr
         self.otimizador.step()
+        # v23 (Teo 35.9): grupo completo — o próximo volta ao tamanho cheio
+        self._n_acc_atual = self.lote_efetivo
         # v16 — amostra de telemetria + atualização dos controladores RM
         if (self.passo_global % self.autorreg.a_cada) == 0:
             frac_moe = None
@@ -1105,6 +1121,18 @@ class TreinadorExtensao(MixinLR, MixinPerdas, MixinEstado, MixinFases,
             resultado[tarefa] = sum(perdas) / len(perdas)
         if "lm" in resultado:
             resultado["ppl_lm"] = math.exp(min(resultado["lm"], 10))
+        # v23 (correção A-22 da auditoria — honestidade): com corpus < 2
+        # registros, por_tarefa é vazio e o resultado é {} — antes o gate de
+        # fase sumia EM SILÊNCIO (sem métrica, sem sinal). Agora a ausência
+        # é um ALERTA explícito no hub/eventos (visível no JSONL).
+        if not resultado:
+            if getattr(self, "hub", None) is not None:
+                self.hub.alerta("avaliar/vazio", 0.0, self.passo_global,
+                                motivo="por_tarefa vazio (<2 registros) — "
+                                       "gate de fase sem métricas")
+            else:
+                print("[avaliar] ALERTA (A-22): por_tarefa vazio (<2 "
+                      "registros) — gate de fase sem métricas", flush=True)
         modelo.train()
         return resultado
 

src/khtst/treino/treinador_estado.py

@@ -159,6 +159,13 @@ class MixinEstado:
         meta = self.checkpoints.meta_de(tag)
         if meta:
             self.passo_global = meta.get("passo_global", 0)
+            # v23 (Teo 35.9, correção A-05): realinhar o tamanho do grupo de
+            # acumulação — retomada no meio de um grupo (fase k ≠ 0) termina
+            # o grupo com n_acc−k micros; dividir pelo tamanho REAL elimina
+            # o viés (n_acc−k)/n_acc do primeiro passo pós-retomada.
+            n_acc = int(getattr(self, "lote_efetivo", 1))
+            self._n_acc_atual = max(1, n_acc - (self.passo_global % n_acc)) \
+                if n_acc > 1 else 1
             self.epoca = meta.get("epoca", 0)
             self.t_ciclo = meta.get("t_ciclo", 0)
             self.T_ciclo = meta.get("T_ciclo", self.T_ciclo)

tests/conftest.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+"""conftest da suíte KHTST.
+
+v23 (P12 da auditoria independente — EXECUTAVEL.md §8 fase 1): a suíte era
+100% torch-dependente — sem torch, os 20 arquivos falhavam NA COLEÇÃO por
+import (20/20 erros, nenhuma rede de segurança). Aqui a ausência de torch é
+detectada UMA vez e TODA a coleta vira skip com mensagem clara (pytest sai
+0 com "skipped", em vez de 20 erros de importação); com torch presente, a
+coleta é idêntica à anterior (bit a bit — zero interferência).
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+_RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+for _caminho in (os.path.join(_RAIZ, "src"),
+                 os.path.join(_RAIZ, "src", "khtst", "acelerado")):
+    if _caminho not in sys.path:
+        sys.path.insert(0, _caminho)
+
+try:                                    # torch é dependência dura da suíte
+    import torch  # noqa: F401
+    _SEM_TORCH = False
+except Exception:                       # ImportError e afins
+    _SEM_TORCH = True
+
+
+def pytest_collection_modifyitems(config, items):
+    if not _SEM_TORCH:
+        return
+    import pytest
+    _skip = pytest.mark.skip(
+        reason="torch ausente neste ambiente (P12) — a suíte KHTST é "
+               "torch-dependente; instale torch para executar as provas")
+    for item in items:
+        item.add_marker(_skip)