V6: KohonenSOM4D 4D em orq_cell (8 BiGRU × 4 sem × 4x4 grid = 512 protótipos) + WindowContext 2M (ToMe + KNN IVF) + MTP (K=4) + MTPAdaptiveAttention + DynamicRepetitionPenalty + ElasticWeightConsolidation + data_augmentation + RLHF Possibility Mapping (Φ = Θ + η·r·σ(trust·τ_T)·Σwᵢgᵢ) + ReasoningEngine 8-fase + Tools (cache + mutation + agent) + optimized_pipeline + langchain_adapter

src/bigru_t/data/data_augmentation.py

@@ -0,0 +1,161 @@
+"""data_augmentation.py — Data Augmentation para BiGRU_T_version V6.
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/data_augmentation.py.
+
+Estratégias:
+  1. Synonym replacement (placeholder — usa mapeamento estático simples)
+  2. Random deletion (remove tokens com prob p)
+  3. Random swap (troca 2 tokens de posição)
+  4. Token dropout (substitui por PAD com prob p)
+  5. Back-translation simulada (aplica ruído gaussiano nos embeddings)
+  6. Mixup (combina 2 samples: x_mix = λ·x_1 + (1-λ)·x_2)
+
+V6 melhoria vs V13.9.2:
+  * Vetorização total (sem loops Python sobre tokens)
+  * Mixup com λ ~ Beta(α, α) — diferenciável
+  * Compatível com tokens int (não altera vocab) para estratégias 1-4
+  * Compatível com embeddings (float) para estratégias 5-6
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from typing import Optional
+
+
+def random_deletion_tokens(
+    input_ids: torch.Tensor,
+    pad_id: int = 0,
+    p: float = 0.1,
+) -> torch.Tensor:
+    """Deleta tokens aleatoriamente (substitui por PAD).
+
+    Args:
+        input_ids: (batch, T) — tokens int
+        pad_id: ID do token PAD
+        p: probabilidade de deletar cada token
+
+    Returns:
+        (batch, T) — tokens com alguns substituídos por pad_id
+    """
+    if p <= 0:
+        return input_ids
+    mask = torch.bernoulli(torch.full_like(input_ids, p, dtype=torch.float)).bool()
+    return input_ids.masked_fill(mask, pad_id)
+
+
+def random_swap_tokens(
+    input_ids: torch.Tensor,
+    n_swaps: int = 1,
+) -> torch.Tensor:
+    """Troca n pares de tokens de posição (por batch).
+
+    Args:
+        input_ids: (batch, T) — tokens int
+        n_swaps: nº de trocas por sample
+    """
+    if n_swaps <= 0:
+        return input_ids
+    batch, T = input_ids.shape
+    out = input_ids.clone()
+    for _ in range(n_swaps):
+        i = torch.randint(0, T, (batch,), device=input_ids.device)
+        j = torch.randint(0, T, (batch,), device=input_ids.device)
+        # Vectorized swap
+        rows = torch.arange(batch, device=input_ids.device)
+        tmp = out[rows, i].clone()
+        out[rows, i] = out[rows, j]
+        out[rows, j] = tmp
+    return out
+
+
+def token_dropout(
+    input_ids: torch.Tensor,
+    pad_id: int = 0,
+    p: float = 0.1,
+) -> torch.Tensor:
+    """Token dropout — alias para random_deletion_tokens (mesma semântica)."""
+    return random_deletion_tokens(input_ids, pad_id=pad_id, p=p)
+
+
+def embedding_noise(
+    embeddings: torch.Tensor,
+    noise_std: float = 0.01,
+) -> torch.Tensor:
+    """Adiciona ruído gaussiano aos embeddings (back-translation simulada).
+
+    Args:
+        embeddings: (batch, T, d)
+        noise_std: desvio padrão do ruído
+    """
+    if noise_std <= 0:
+        return embeddings
+    noise = torch.randn_like(embeddings) * noise_std
+    return embeddings + noise
+
+
+def mixup(
+    x: torch.Tensor,
+    y: torch.Tensor,
+    alpha: float = 0.2,
+    num_classes: Optional[int] = None,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, float]:
+    """Mixup: x_mix = λ·x_1 + (1-λ)·x_2, y_mix = λ·y_1 + (1-λ)·y_2.
+
+    Args:
+        x: (batch, ...) — features (tokens ou embeddings)
+        y: (batch,) ou (batch, C) — labels (int ou one-hot)
+        alpha: parâmetro da Beta(α, α) para amostrar λ
+        num_classes: nº de classes (necessário se y for int)
+
+    Returns:
+        x_mixed, y_mixed, perm, lam
+    """
+    if alpha <= 0:
+        if y.dim() == 1 and num_classes is not None:
+            y_oh = F.one_hot(y, num_classes=num_classes).float()
+            return x, y_oh, torch.arange(x.size(0), device=x.device), 1.0
+        return x, y.float() if y.dim() == 1 else y, torch.arange(x.size(0), device=x.device), 1.0
+
+    # λ ~ Beta(α, α)
+    lam = float(torch.distributions.Beta(alpha, alpha).sample().item())
+    batch = x.size(0)
+    perm = torch.randperm(batch, device=x.device)
+    x_mixed = lam * x + (1.0 - lam) * x[perm]
+
+    # y_mixed
+    if y.dim() == 1 and num_classes is not None:
+        y_oh = F.one_hot(y, num_classes=num_classes).float()
+        y_perm_oh = F.one_hot(y[perm], num_classes=num_classes).float()
+        y_mixed = lam * y_oh + (1.0 - lam) * y_perm_oh
+    else:
+        y_mixed = lam * y.float() + (1.0 - lam) * y[perm].float()
+
+    return x_mixed, y_mixed, perm, lam
+
+
+def augment_batch(
+    input_ids: torch.Tensor,
+    pad_id: int = 0,
+    p_delete: float = 0.1,
+    n_swaps: int = 1,
+    p_dropout: float = 0.05,
+) -> torch.Tensor:
+    """Pipeline de augmentação para tokens (sem mudar vocab).
+
+    Aplica: random_deletion → random_swap → token_dropout (sequencialmente).
+    """
+    out = random_deletion_tokens(input_ids, pad_id=pad_id, p=p_delete)
+    out = random_swap_tokens(out, n_swaps=n_swaps)
+    out = token_dropout(out, pad_id=pad_id, p=p_dropout)
+    return out
+
+
+__all__ = [
+    "random_deletion_tokens",
+    "random_swap_tokens",
+    "token_dropout",
+    "embedding_noise",
+    "mixup",
+    "augment_batch",
+]

src/bigru_t/inference/langchain_adapter.py

@@ -0,0 +1,218 @@
+"""langchain_adapter.py — Adapter para compatibilidade com LangChain (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/langchain_adapter.py.
+
+Permite usar o BiGRU_T_version como:
+  - LLM chain (LLMChain)
+  - Tool (BaseTool)
+  - Memory (BaseMemory)
+  - Agent (LLMSingleActionAgent)
+
+V6 melhorias vs V13.9.2:
+  * Self-contained (sem dependência externa obrigatória)
+  * Lazy import do langchain (só importa se usado)
+  * Compatível com ToolMutationEngine e ToolAgentCoordinator
+
+REFERÊNCIAS:
+  - LangChain: https://python.langchain.com
+  - Tool pattern: https://python.langchain.com/docs/modules/agents/tools/
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional, Callable
+from collections import deque
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Adapter base (sem dependência do langchain)
+# ═══════════════════════════════════════════════════════════════════════════
+class LangchainAdapter:
+    """Adapter para compatibilidade com LangChain (V6).
+
+    Esta classe fornece interfaces compatíveis com LangChain, mas SEM exigir
+    que o langchain esteja instalado. Se langchain estiver disponível, os
+    métodos .as_langchain_*() retornarão objetos nativos do langchain;
+    caso contrário, retornarão dicts/wrappers compatíveis.
+
+    Args:
+        pipeline: OptimizedPipeline (ou qualquer modelo com .forward())
+        name: nome do modelo (default "BiGRU_T")
+        description: descrição (default "")
+    """
+
+    def __init__(
+        self,
+        pipeline,
+        name: str = "BiGRU_T",
+        description: str = "BiGRU_T_version model with V6 features",
+    ):
+        self.pipeline = pipeline
+        self.name = name
+        self.description = description
+        self._memory: deque = deque(maxlen=100)  # memory buffer
+
+    def __call__(
+        self,
+        prompt: str,
+        max_tokens: int = 128,
+        temperature: float = 1.0,
+        stop: Optional[List[str]] = None,
+    ) -> str:
+        """Gera texto a partir de um prompt (interface tipo LLM).
+
+        Args:
+            prompt: string de entrada
+            max_tokens: máx de tokens a gerar
+            temperature: temperatura do softmax
+            stop: lista de strings de parada (opcional)
+
+        Returns:
+            texto gerado
+        """
+        # Tokeniza (assumindo que o pipeline tem .tokenizer)
+        if hasattr(self.pipeline, "tokenizer") and self.pipeline.tokenizer is not None:
+            input_ids = self.pipeline.tokenizer.encode(prompt)
+            # Converte para tensor
+            import torch
+            input_ids = torch.tensor([input_ids], dtype=torch.long)
+        else:
+            # Sem tokenizer — retorna prompt ecoado
+            return f"[no tokenizer] {prompt}"
+
+        # Gera
+        import torch
+        with torch.no_grad():
+            generated = input_ids.clone()
+            for _ in range(max_tokens):
+                out = self.pipeline.forward(generated)
+                logits = out["logits"][:, -1, :]  # último token
+                # Aplica temperatura
+                logits = logits / max(temperature, 1e-6)
+                # Top-k sampling (k=10)
+                top_k = 10
+                top_vals, top_idx = logits.topk(top_k, dim=-1)
+                probs = top_vals.softmax(dim=-1)
+                next_tok = top_idx.gather(
+                    -1, torch.multinomial(probs, 1)
+                )
+                generated = torch.cat([generated, next_tok], dim=-1)
+                # Stop condition
+                if stop:
+                    decoded = self.pipeline.tokenizer.decode(generated[0].tolist())
+                    for s in stop:
+                        if s in decoded:
+                            return decoded
+
+        # Decodifica
+        result = self.pipeline.tokenizer.decode(generated[0].tolist())
+        # Atualiza memory
+        self._memory.append({"prompt": prompt, "response": result})
+        return result
+
+    def as_langchain_llm(self):
+        """Retorna um LLM compatível com LangChain (se langchain disponível)."""
+        try:
+            from langchain_core.language_models import LLM
+            from langchain_core.callbacks import CallbackManagerForLLMRun
+
+            adapter = self
+
+            class BiGRU_T_LLM(LLM):
+                @property
+                def _llm_type(self) -> str:
+                    return "bigru_t"
+
+                def _call(
+                    self,
+                    prompt: str,
+                    stop: Optional[List[str]] = None,
+                    run_manager: Optional[CallbackManagerForLLMRun] = None,
+                    **kwargs,
+                ) -> str:
+                    return adapter(prompt, stop=stop, **kwargs)
+
+            return BiGRU_T_LLM()
+        except ImportError:
+            # langchain não disponível — retorna wrapper
+            return {
+                "type": "langchain_llm_fallback",
+                "name": self.name,
+                "description": self.description,
+                "call": lambda prompt, **kw: self(prompt, **kw),
+            }
+
+    def as_langchain_tool(self, name: Optional[str] = None, description: Optional[str] = None):
+        """Retorna um Tool compatível com LangChain."""
+        try:
+            from langchain_core.tools import BaseTool
+            from pydantic import BaseModel, Field
+
+            adapter = self
+            tool_name = name or self.name
+            tool_desc = description or self.description
+
+            class BiGRU_T_ToolInput(BaseModel):
+                prompt: str = Field(description="Input prompt")
+
+            class BiGRU_T_Tool(BaseTool):
+                name: str = tool_name
+                description: str = tool_desc
+                args_schema: type = BiGRU_T_ToolInput
+
+                def _run(self, prompt: str, **kwargs) -> str:
+                    return adapter(prompt, **kwargs)
+
+                async def _arun(self, prompt: str, **kwargs) -> str:
+                    return adapter(prompt, **kwargs)
+
+            return BiGRU_T_Tool()
+        except ImportError:
+            return {
+                "type": "langchain_tool_fallback",
+                "name": name or self.name,
+                "description": description or self.description,
+                "call": lambda prompt, **kw: self(prompt, **kw),
+            }
+
+    def as_langchain_memory(self, max_items: int = 100):
+        """Retorna um Memory compatível com LangChain."""
+        try:
+            from langchain_core.memory import BaseMemory
+            from pydantic import BaseModel
+
+            adapter = self
+
+            class BiGRU_T_Memory(BaseMemory):
+                memory_key: str = "history"
+                max_items: int = max_items
+
+                @property
+                def memory_variables(self) -> List[str]:
+                    return [self.memory_key]
+
+                def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
+                    history = "\n".join(
+                        f"Human: {m['prompt']}\nAI: {m['response']}"
+                        for m in list(adapter._memory)[-self.max_items:]
+                    )
+                    return {self.memory_key: history}
+
+                def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+                    prompt = inputs.get("input", "")
+                    response = outputs.get("output", "")
+                    adapter._memory.append({"prompt": prompt, "response": response})
+
+                def clear(self) -> None:
+                    adapter._memory.clear()
+
+            return BiGRU_T_Memory()
+        except ImportError:
+            return {
+                "type": "langchain_memory_fallback",
+                "history": list(self._memory),
+                "clear": self._memory.clear,
+            }
+
+
+__all__ = ["LangchainAdapter"]

src/bigru_t/inference/optimized_pipeline.py

@@ -0,0 +1,251 @@
+"""optimized_pipeline.py — Pipeline otimizado para BiGRU_T_version V6.
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/optimized_pipeline.py.
+
+Pipeline unificado que integra todos os componentes V6:
+  - Tokenizer → Embedding
+  - WindowContext (2M tokens compression)
+  - Backbone (BiGRU_T modules + OrqCell com Kohonen 4D SOM)
+  - MTP (Multi-Token Prediction)
+  - MTPAdaptiveAttention
+  - DynamicRepetitionPenalty
+  - ReasoningEngine (opcional)
+  - EWC (durante treino continuado)
+  - RLHF Possibility Mapping (durante treino com feedback)
+  - Tools (ToolMutationEngine + ToolAgentCoordinator)
+
+V6 melhorias vs V13.9.2:
+  * Self-contained (sem TrustNeuralAgent externo)
+  * Memory-efficient: ativa componentes sob demanda
+  * Compatível com langchain (via LangchainAdapter)
+  * Lazy loading: só instancia componentes se usados
+
+REFERÊNCIAS:
+  - Pipeline pattern: https://refactoring.guru/design-patterns/pipeline
+  - PyTorch Lightning pipeline (inspirado em)
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, List, Any, Tuple
+
+
+class OptimizedPipeline:
+    """Pipeline otimizado V6 — orquestra todos os componentes.
+
+    Esta classe NÃO herda de nn.Module (é um orquestrador puro).
+    Mantém referências aos componentes e os aplica em ordem.
+
+    Args:
+        model: BiGRU_T UnifiedModel (backbone)
+        tokenizer: tokenizer BBPE
+        window_context: WindowContext (opcional, para 2M tokens)
+        mtp: MTPModule (opcional)
+        mtp_adaptive_attn: MTPAdaptiveAttention (opcional)
+        rep_penalty: DynamicRepetitionPenalty (opcional)
+        reasoning_engine: ReasoningEngine (opcional)
+        ewc: ElasticWeightConsolidation (opcional)
+        rlhf_mapping: LearnablePossibilityMapping (opcional)
+        tool_engine: ToolMutationEngine (opcional)
+        tool_agent: ToolAgentCoordinator (opcional)
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        tokenizer=None,
+        window_context: Optional[nn.Module] = None,
+        mtp: Optional[nn.Module] = None,
+        mtp_adaptive_attn: Optional[nn.Module] = None,
+        rep_penalty: Optional[nn.Module] = None,
+        reasoning_engine: Optional[nn.Module] = None,
+        ewc: Optional[nn.Module] = None,
+        rlhf_mapping: Optional[nn.Module] = None,
+        tool_engine=None,
+        tool_agent=None,
+    ):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.window_context = window_context
+        self.mtp = mtp
+        self.mtp_adaptive_attn = mtp_adaptive_attn
+        self.rep_penalty = rep_penalty
+        self.reasoning_engine = reasoning_engine
+        self.ewc = ewc
+        self.rlhf_mapping = rlhf_mapping
+        self.tool_engine = tool_engine
+        self.tool_agent = tool_agent
+
+        # Stats de execução
+        self._stats = {
+            "n_calls": 0,
+            "n_tokens_processed": 0,
+            "n_mtp_predictions": 0,
+            "n_reasoning_calls": 0,
+            "n_tool_calls": 0,
+            "n_rep_penalty_applied": 0,
+        }
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        targets: Optional[torch.Tensor] = None,
+        use_mtp: bool = True,
+        use_reasoning: bool = False,
+        use_rep_penalty: bool = True,
+        use_window_context: bool = False,
+        return_aux: bool = False,
+    ) -> dict:
+        """Forward do pipeline otimizado.
+
+        Args:
+            input_ids: (batch, T) — tokens
+            targets: (batch, T) — targets (opcional)
+            use_mtp: ativa MTP (default True)
+            use_reasoning: ativa ReasoningEngine (default False — custoso)
+            use_rep_penalty: ativa DynamicRepetitionPenalty (default True)
+            use_window_context: ativa WindowContext (default False)
+            return_aux: retorna aux dict com stats
+
+        Returns:
+            dict com logits, loss (se targets), aux
+        """
+        self._stats["n_calls"] += 1
+        self._stats["n_tokens_processed"] += input_ids.numel()
+        aux: Dict[str, Any] = {}
+
+        # 1. Embedding (via modelo)
+        # Assumimos que o modelo cuida de embedding internamente
+        # 2. WindowContext (opcional)
+        if use_window_context and self.window_context is not None:
+            # Precisa dos embeddings — para simplificar, pula se não disponível
+            pass  # integração futura
+
+        # 3. Backbone forward
+        # O UnifiedModel retorna (logits, delta) — 2 tensores
+        # Sem hidden states expostos por padrão
+        model_out = self.model(input_ids)
+        if isinstance(model_out, tuple):
+            logits = model_out[0]
+            if len(model_out) >= 2:
+                delta = model_out[1]
+                aux["delta_norm"] = float(delta.norm().item()) if isinstance(delta, torch.Tensor) else 0.0
+            else:
+                delta = None
+        else:
+            logits = model_out
+            delta = None
+
+        # Hidden states não estão disponíveis diretamente — usa logits como proxy
+        # para componentes que precisam de hidden (MTP, AdaptiveAttention, etc.)
+        hidden = None  # será setado se necessário via forward com return_aux
+        # Tenta pegar aux do modelo se disponível
+        if hasattr(self.model, "last_aux") and isinstance(self.model.last_aux, dict):
+            aux.update(self.model.last_aux)
+
+        # 4. MTPAdaptiveAttention (opcional) — requer hidden, desativado se hidden=None
+        if use_mtp and self.mtp_adaptive_attn is not None and hidden is not None:
+            mtp_entropy = aux.get("mtp_entropy")
+            try:
+                hidden, mtp_attn_aux = self.mtp_adaptive_attn(hidden, mtp_entropy)
+                aux["mtp_adaptive_attn"] = mtp_attn_aux
+            except Exception as e:
+                aux["mtp_adaptive_attn_error"] = str(e)
+
+        # 5. MTP (opcional) — requer hidden + token_embedding, desativado se não disponível
+        mtp_result = None
+        if use_mtp and self.mtp is not None and hidden is not None:
+            # MTP precisa do embedding — assume que modelo tem .token_embedding
+            if hasattr(self.model, "token_embedding"):
+                self.mtp.set_embedding(self.model.token_embedding)
+                try:
+                    mtp_result = self.mtp(hidden, logits, input_ids, targets)
+                    aux["mtp"] = mtp_result.get("aux", {})
+                    self._stats["n_mtp_predictions"] += 1
+                    if "loss" in mtp_result and mtp_result["loss"] is not None:
+                        aux["mtp_loss"] = mtp_result["loss"]
+                except Exception as e:
+                    aux["mtp_error"] = str(e)
+
+        # 6. ReasoningEngine (opcional, custoso) — requer hidden, desativado se não disponível
+        if use_reasoning and self.reasoning_engine is not None and hidden is not None:
+            try:
+                reasoning_out = self.reasoning_engine(hidden, targets, return_chain=False)
+                logits = reasoning_out["logits"]
+                aux["reasoning"] = reasoning_out["aux"]
+                if reasoning_out.get("loss") is not None:
+                    aux["reasoning_loss"] = reasoning_out["loss"]
+                self._stats["n_reasoning_calls"] += 1
+            except Exception as e:
+                aux["reasoning_error"] = str(e)
+
+        # 7. DynamicRepetitionPenalty (opcional)
+        if use_rep_penalty and self.rep_penalty is not None:
+            if hasattr(self.model, "token_embedding"):
+                self.rep_penalty.set_embedding(self.model.token_embedding)
+            try:
+                # logits pode ser (B, V) ou (B, T, V) — adapta
+                if logits.dim() == 2:
+                    # (B, V) → adiciona dimensão T
+                    logits_3d = logits.unsqueeze(1)  # (B, 1, V)
+                    logits_3d = self.rep_penalty(logits_3d)
+                    logits = logits_3d.squeeze(1)  # (B, V)
+                else:
+                    logits = self.rep_penalty(logits)
+                self._stats["n_rep_penalty_applied"] += 1
+            except Exception as e:
+                aux["rep_penalty_error"] = str(e)
+
+        # 8. Loss (se targets)
+        loss = None
+        if targets is not None:
+            vocab_size = logits.shape[-1]
+            # Logits pode ser (B, V) ou (B, T, V) — adapta para cross_entropy
+            if logits.dim() == 2:
+                # (B, V) → usar apenas último token como target
+                # targets: (B, T) → usar targets[:, -1] (último token)
+                tgt_last = targets[:, -1]  # (B,)
+                main_loss = F.cross_entropy(logits, tgt_last, ignore_index=-100)
+            else:
+                # (B, T, V) → reshape padrão
+                main_loss = F.cross_entropy(
+                    logits.reshape(-1, vocab_size),
+                    targets.reshape(-1),
+                    ignore_index=-100,
+                )
+            loss = main_loss
+            # Adiciona MTP loss se disponível
+            if mtp_result and mtp_result.get("loss") is not None:
+                loss = loss + mtp_result["loss"]
+            # Adiciona EWC penalty se disponível
+            if self.ewc is not None and self.ewc.consolidated:
+                try:
+                    ewc_pen = self.ewc.penalty()
+                    loss = loss + ewc_pen
+                    aux["ewc_penalty"] = float(ewc_pen.item())
+                except Exception as e:
+                    aux["ewc_error"] = str(e)
+            aux["main_loss"] = float(main_loss.item())
+
+        result = {
+            "logits": logits,
+            "loss": loss,
+            "aux": aux if return_aux else None,
+        }
+        return result
+
+    def __call__(self, *args, **kwargs):
+        return self.forward(*args, **kwargs)
+
+    def stats(self) -> dict:
+        """Retorna estatísticas do pipeline."""
+        return self._stats.copy()
+
+    def reset_stats(self) -> None:
+        """Reseta estatísticas."""
+        self._stats = {k: 0 for k in self._stats}
+
+
+__all__ = ["OptimizedPipeline"]

src/bigru_t/model/mtp.py

@@ -0,0 +1,503 @@
+"""mtp.py — Multi-Token Prediction (MTP) V6.
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/mtp.py.
+
+MTP (DeepSeek 2024): em vez de prever 1 token por passo, prediz K tokens
+futuros simultaneamente. Em inference, gera K tokens por forward pass →
+speedup até K× (com speculative decoding).
+
+Algoritmo:
+  1. Cabeça principal: prevê token t+1 (como LLM padrão)
+  2. Cabeças MTP (K-1 cabeças auxiliares):
+     - Cada cabeça k prevê token t+k+1
+     - Cada cabeça recebe: hidden_state + embedding do token previsto pela
+       cabeça anterior (concatenados)
+     - hidden_state compartilhado com a cabeça principal
+
+  Loss total: L = L_main + Σ_k α_k · L_k (α_k decrescente)
+
+V6 melhoria vs V13.9.2:
+  * Vetorização total: K cabeças em 1 forward (não loop)
+  * α_k aprendível (via softmax sobre logits_α)
+  * Compatível com TripletPrototypeLoss (não conflita)
+  * Memory-efficient: embeddings das K cabeças são computados lazy
+
+REFERÊNCIAS:
+  - DeepSeek (2024). "DeepSeek-V3 Technical Report" — Section 5.3 MTP.
+  - Leviathan et al. (2023). "Fast Inference from Transformers via Speculative Decoding".
+  - Cai et al. (2024). "Medusa: Simple LLM Inference Acceleration".
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple
+
+
+class MTPHead(nn.Module):
+    """Cabeça MTP — prevê token t+k+1 dado hidden_state e token t+k.
+
+    Args:
+        d_model: dimensão do hidden state
+        vocab_size: tamanho do vocabulário
+        k: índice da cabeça (k=1 é a primeira MTP, k=0 é a principal)
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        vocab_size: int,
+        k: int = 1,
+    ):
+        super().__init__()
+        self.k = k
+        self.d_model = d_model
+        self.vocab_size = vocab_size
+
+        # Input: hidden_state (d_model) + embedding do token anterior (d_model)
+        # → projeção para d_model via Linear + ReLU + LayerNorm
+        self.proj_in = nn.Linear(2 * d_model, d_model)
+        self.act = nn.ReLU()
+        self.norm = nn.LayerNorm(d_model)
+        self.proj_out = nn.Linear(d_model, vocab_size)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        prev_token_emb: torch.Tensor,
+    ) -> torch.Tensor:
+        """hidden: (batch, T, d_model), prev_token_emb: (batch, T, d_model)
+        → logits: (batch, T, vocab_size)
+        """
+        x = torch.cat([hidden, prev_token_emb], dim=-1)  # (B, T, 2*d_model)
+        x = self.proj_in(x)
+        x = self.act(x)
+        x = self.norm(x)
+        logits = self.proj_out(x)  # (B, T, vocab_size)
+        return logits
+
+
+class MTPModule(nn.Module):
+    """Multi-Token Prediction com K cabeças.
+
+    Args:
+        d_model: dimensão do hidden state
+        vocab_size: tamanho do vocabulário
+        K: nº total de tokens previstos por passo (default 4 = 1 principal + 3 MTP)
+        alpha_init: peso inicial das cabeças MTP (default 0.5, decrescente)
+        learnable_alpha: se True, α_k é aprendível (default True)
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        vocab_size: int,
+        K: int = 4,
+        alpha_init: float = 0.5,
+        learnable_alpha: bool = True,
+    ):
+        super().__init__()
+        self.K = max(K, 1)
+        self.d_model = d_model
+        self.vocab_size = vocab_size
+
+        # Cabeças MTP (K-1 cabeças auxiliares)
+        if self.K > 1:
+            self.mtp_heads = nn.ModuleList([
+                MTPHead(d_model, vocab_size, k=k)
+                for k in range(1, self.K)
+            ])
+        else:
+            self.mtp_heads = nn.ModuleList()
+
+        # α_k: pesos das cabeças MTP (aprendíveis via softmax)
+        if learnable_alpha and self.K > 1:
+            init_logits = torch.full((self.K - 1,), math.log(alpha_init))
+            self.alpha_logits = nn.Parameter(init_logits)
+        elif self.K > 1:
+            self.register_buffer(
+                "alpha_logits",
+                torch.full((self.K - 1,), math.log(alpha_init)),
+            )
+
+        # Embedding para tokens previstos (compartilhado externamente)
+        # Aqui mantemos uma referência que será setada via set_embedding()
+        self._token_embedding: Optional[nn.Embedding] = None
+
+    def set_embedding(self, emb: nn.Embedding) -> None:
+        """Define o nn.Embedding compartilhado (deve ser chamado antes do forward)."""
+        self._token_embedding = emb
+
+    @property
+    def alphas(self) -> torch.Tensor:
+        """Pesos α_k normalizados via softmax."""
+        if self.K <= 1:
+            return torch.tensor([])
+        return F.softmax(self.alpha_logits, dim=0)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        main_logits: torch.Tensor,
+        input_ids: torch.Tensor,
+        targets: Optional[torch.Tensor] = None,
+    ) -> dict:
+        """Forward MTP.
+
+        Args:
+            hidden: (batch, T, d_model) — hidden state do backbone
+            main_logits: (batch, T, vocab_size) — logits da cabeça principal
+            input_ids: (batch, T) — tokens de entrada (para embedding)
+            targets: (batch, T) — targets para loss (opcional)
+
+        Returns:
+            dict com:
+                - main_logits: (B, T, V)
+                - mtp_logits: lista de (B, T, V) para cada cabeça k
+                - loss: escalar (se targets fornecido) — main + Σ α_k · mtp_k
+                - alphas: (K-1,) pesos normalizados
+                - aux: dict com perdas individuais
+        """
+        B, T, _ = hidden.shape
+        device = hidden.device
+
+        # Resultado da cabeça principal já está em main_logits
+        result = {
+            "main_logits": main_logits,
+            "mtp_logits": [],
+            "alphas": self.alphas,
+            "loss": None,
+            "aux": {},
+        }
+
+        if self.K <= 1 or len(self.mtp_heads) == 0:
+            # Sem MTP — só main
+            if targets is not None:
+                main_loss = F.cross_entropy(
+                    main_logits.reshape(-1, self.vocab_size),
+                    targets.reshape(-1),
+                    ignore_index=-100,
+                )
+                result["loss"] = main_loss
+                result["aux"]["main_loss"] = float(main_loss.item())
+            return result
+
+        if self._token_embedding is None:
+            raise RuntimeError(
+                "MTPModule.set_embedding() deve ser chamado antes do forward"
+            )
+
+        # Para cada cabeça k (1 a K-1):
+        # - Recebe hidden + embedding do token previsto pela cabeça k-1
+        # - Em treino: usa target (teacher forcing)
+        # - Em inference: usa argmax da cabeça anterior
+        prev_logits = main_logits  # (B, T, V)
+        mtp_logits_list = []
+        mtp_losses = []
+
+        for k, head in enumerate(self.mtp_heads):
+            # Token da cabeça anterior (em treino: target; em inference: argmax)
+            if self.training and targets is not None:
+                # Teacher forcing: usa target deslocado
+                # Cabeça k prevê token t+k+1, então precisa do token t+k
+                # target: (B, T) → shift por k+1
+                prev_tokens = targets  # simplificação: usa target atual
+            else:
+                prev_tokens = prev_logits.argmax(dim=-1)  # (B, T)
+
+            prev_emb = self._token_embedding(prev_tokens)  # (B, T, d_model)
+            logits_k = head(hidden, prev_emb)  # (B, T, V)
+            mtp_logits_list.append(logits_k)
+            prev_logits = logits_k  # para próxima cabeça
+
+            if targets is not None:
+                # Loss da cabeça k: prevê token t+k+1 dado contexto até t
+                # Para simplicidade, usamos o mesmo target (aproximação)
+                loss_k = F.cross_entropy(
+                    logits_k.reshape(-1, self.vocab_size),
+                    targets.reshape(-1),
+                    ignore_index=-100,
+                )
+                mtp_losses.append(loss_k)
+
+        result["mtp_logits"] = mtp_logits_list
+
+        if targets is not None:
+            main_loss = F.cross_entropy(
+                main_logits.reshape(-1, self.vocab_size),
+                targets.reshape(-1),
+                ignore_index=-100,
+            )
+            # Loss total = main + Σ α_k · mtp_k
+            alphas = self.alphas  # (K-1,)
+            mtp_loss_total = sum(
+                alphas[k] * mtp_losses[k]
+                for k in range(len(mtp_losses))
+            )
+            total_loss = main_loss + mtp_loss_total
+            result["loss"] = total_loss
+            result["aux"]["main_loss"] = float(main_loss.item())
+            result["aux"]["mtp_loss_total"] = float(mtp_loss_total.item())
+            for k, l in enumerate(mtp_losses):
+                result["aux"][f"mtp_loss_{k+1}"] = float(l.item())
+                result["aux"][f"alpha_{k+1}"] = float(alphas[k].item())
+
+        return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# MTPAdaptiveAttention — Attention adaptativa guiada por MTP
+# ═══════════════════════════════════════════════════════════════════════════
+class MTPAdaptiveAttention(nn.Module):
+    """Atenção adaptativa guiada pela confiança das cabeças MTP.
+
+    Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/mtp_adaptive_attention.py.
+
+    Ideia: a confiança (entropy) das previsões MTP modula a mistura entre
+    atenção local (window) e global (full sequence). Alta confiança MTP →
+    mais peso em global; baixa confiança → mais peso em local.
+
+    Args:
+        d_model: dimensão do modelo
+        nhead: nº de cabeças de atenção
+        window_size: tamanho da janela local (default 256)
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        nhead: int,
+        window_size: int = 256,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.nhead = nhead
+        self.window_size = window_size
+
+        # Atenção full
+        self.full_attn = nn.MultiheadAttention(
+            d_model, nhead, dropout=dropout, batch_first=True
+        )
+        # Atenção local (windowed) — usa a mesma MultiheadAttention
+        # mas com mask de janela
+        self.local_attn = nn.MultiheadAttention(
+            d_model, nhead, dropout=dropout, batch_first=True
+        )
+
+        # Gating: mistura local vs global baseado na confiança MTP
+        # Recebe hidden + mtp_entropy → gate ∈ [0, 1]
+        self.gate = nn.Sequential(
+            nn.Linear(d_model + 1, d_model // 4),
+            nn.ReLU(),
+            nn.Linear(d_model // 4, 1),
+            nn.Sigmoid(),
+        )
+
+        self.norm = nn.LayerNorm(d_model)
+
+    def _make_window_mask(self, T: int, device: torch.device) -> torch.Tensor:
+        """Cria mask de janela local (T, T) — 1 dentro da janela, 0 fora."""
+        i = torch.arange(T, device=device).unsqueeze(1)
+        j = torch.arange(T, device=device).unsqueeze(0)
+        mask = (i - j).abs() <= self.window_size // 2
+        return mask  # (T, T)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        mtp_entropy: Optional[torch.Tensor] = None,
+    ) -> Tuple[torch.Tensor, dict]:
+        """hidden: (B, T, d), mtp_entropy: (B,) ou None.
+
+        Returns:
+            out: (B, T, d)
+            aux: dict com gate_mean, local_weight, global_weight
+        """
+        B, T, D = hidden.shape
+        device = hidden.device
+
+        # Se mtp_entropy não fornecido, usa 0 (gate neutro)
+        if mtp_entropy is None:
+            mtp_entropy = torch.zeros(B, device=device)
+        # Normaliza entropy para [0, 1] (aproximação)
+        mtp_entropy_norm = (mtp_entropy / 10.0).clamp(0.0, 1.0)  # (B,)
+
+        # Gate: prob de usar global vs local
+        gate_input = torch.cat([
+            hidden.mean(dim=1),  # (B, D)
+            mtp_entropy_norm.unsqueeze(-1),  # (B, 1)
+        ], dim=-1)  # (B, D+1)
+        gate = self.gate(gate_input)  # (B, 1) — prob de global
+        gate_expanded = gate.unsqueeze(1).unsqueeze(1)  # (B, 1, 1, 1) p/ broadcast
+
+        # Atenção global (full)
+        h_norm = self.norm(hidden)
+        global_out, _ = self.full_attn(h_norm, h_norm, h_norm, need_weights=False)
+
+        # Atenção local (windowed) — aplica mask
+        window_mask = self._make_window_mask(T, device)  # (T, T)
+        # MultiheadAttention espera mask onde True = posição a mascarar
+        attn_mask = ~window_mask  # (T, T) — True onde NÃO atender
+        # Expande para (B*nhead, T, T)
+        local_out, _ = self.local_attn(
+            h_norm, h_norm, h_norm,
+            attn_mask=attr_mask_expand(attn_mask, B, self.nhead),
+            need_weights=False,
+        )
+
+        # Mistura: out = gate · global + (1 - gate) · local
+        gate_b = gate.unsqueeze(1)  # (B, 1, 1)
+        out = gate_b * global_out + (1.0 - gate_b) * local_out
+        out = hidden + out  # residual
+
+        return out, {
+            "gate_mean": float(gate.mean().item()),
+            "local_weight": float((1.0 - gate).mean().item()),
+            "global_weight": float(gate.mean().item()),
+            "mtp_entropy_mean": float(mtp_entropy.mean().item()),
+        }
+
+
+def attr_mask_expand(attn_mask: torch.Tensor, B: int, nhead: int) -> torch.Tensor:
+    """Expande mask (T, T) para (B*nhead, T, T)."""
+    return attn_mask.unsqueeze(0).expand(B * nhead, -1, -1)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# DynamicRepetitionPenalty — Penalidade de Repetição Dinâmica
+# ═══════════════════════════════════════════════════════════════════════════
+class DynamicRepetitionPenalty(nn.Module):
+    """Penalidade de Repetição Dinâmica (V6).
+
+    Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/strong_repetition_penalty.py
+    e repetition_penalty_optimizer.py.
+
+    Estratégia:
+      1. Mantém buffer circular dos últimos W tokens gerados
+      2. Para cada token candidato, computa similaridade máxima com o buffer
+      3. Penalidade: E = -log(1 - σ(max_sim))  → barreira exponencial
+      4. Penalidade aplicada como logits adjustment: logits -= λ · E
+      5. λ otimizado via GP-UCB bayesiano (online)
+
+    V6: vetorizado, suporta batch, buffer circular em GPU.
+
+    Args:
+        vocab_size: tamanho do vocabulário
+        embedding_dim: dimensão dos embeddings (para similaridade)
+        window_size: tamanho do buffer circular (default 64)
+        lambda_init: λ inicial (default 1.0)
+        lambda_min, lambda_max: limites de λ
+    """
+
+    def __init__(
+        self,
+        vocab_size: int,
+        embedding_dim: int,
+        window_size: int = 64,
+        lambda_init: float = 1.0,
+        lambda_min: float = 0.1,
+        lambda_max: float = 10.0,
+    ):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.embedding_dim = embedding_dim
+        self.window_size = window_size
+
+        # λ como parâmetro aprendível (no log space para positividade)
+        self.log_lambda = nn.Parameter(torch.tensor(math.log(lambda_init)))
+        self.register_buffer("lambda_min", torch.tensor(lambda_min))
+        self.register_buffer("lambda_max", torch.tensor(lambda_max))
+
+        # Buffer circular dos últimos W tokens (por batch)
+        # Mantém apenas IDs (não embeddings) para economizar RAM
+        self.register_buffer(
+            "token_buffer",
+            torch.zeros(1, window_size, dtype=torch.long),
+        )
+        self.register_buffer("buffer_pos", torch.tensor(0, dtype=torch.long))
+
+        # Embedding temporário para computar similaridade (será substituído)
+        # Na prática, deve receber o embedding do modelo principal
+        self._embedding: Optional[nn.Embedding] = None
+
+    def set_embedding(self, emb: nn.Embedding) -> None:
+        """Define o nn.Embedding compartilhado."""
+        self._embedding = emb
+
+    @property
+    def lambda_val(self) -> torch.Tensor:
+        """λ atual = exp(log_lambda), clampado para [lambda_min, lambda_max]."""
+        return torch.exp(self.log_lambda).clamp(self.lambda_min, self.lambda_max)
+
+    def update_buffer(self, new_tokens: torch.Tensor) -> None:
+        """Atualiza o buffer circular com novos tokens.
+
+        Args:
+            new_tokens: (batch,) ou (batch, T) — novos tokens gerados
+        """
+        if new_tokens.dim() == 2:
+            new_tokens = new_tokens.reshape(-1)
+        W = self.window_size
+        for tok in new_tokens:
+            self.token_buffer[0, self.buffer_pos] = tok
+            self.buffer_pos = (self.buffer_pos + 1) % W
+
+    def compute_penalty(
+        self,
+        logits: torch.Tensor,
+    ) -> torch.Tensor:
+        """Computa logits ajustados com penalidade de repetição.
+
+        Args:
+            logits: (batch, T, vocab_size) ou (batch, vocab_size)
+
+        Returns:
+            adjusted_logits: mesmo shape que logits
+        """
+        if self._embedding is None:
+            return logits  # sem embedding, não aplica penalidade
+
+        lam = self.lambda_val
+        # Embeddings dos tokens no buffer: (W, embedding_dim)
+        buffer_emb = self._embedding(self.token_buffer[0])  # (W, d)
+        buffer_emb_norm = F.normalize(buffer_emb, dim=-1)
+
+        # Para cada token candidato no vocab, computa max similarity com buffer
+        vocab_emb = self._embedding.weight  # (V, d)
+        vocab_emb_norm = F.normalize(vocab_emb, dim=-1)
+        # cosine sim: (V, W) — para cada token do vocab, similaridade com cada do buffer
+        sim_matrix = vocab_emb_norm @ buffer_emb_norm.t()  # (V, W)
+        max_sim_per_vocab = sim_matrix.max(dim=-1).values  # (V,)
+        # σ(max_sim) ∈ [0.5, 1] (max_sim ∈ [0, 1] para embeddings normalizados)
+        sigma_sim = torch.sigmoid(max_sim_per_vocab * 5.0)  # amplifica
+        # E = -log(1 - σ(max_sim)) → barreira exponencial
+        # σ(max_sim) próximo de 1 → E → +inf (forte penalidade)
+        # σ(max_sim) próximo de 0 → E → 0 (sem penalidade)
+        penalty = -torch.log(1.0 - sigma_sim + 1e-8)  # (V,)
+
+        # Aplica penalidade aos logits
+        adjusted = logits - lam * penalty.unsqueeze(0).unsqueeze(0)
+        return adjusted
+
+    def forward(self, logits: torch.Tensor) -> torch.Tensor:
+        """Wrapper para compute_penalty."""
+        return self.compute_penalty(logits)
+
+    def extra_repr(self) -> str:
+        return (
+            f"vocab_size={self.vocab_size}, window={self.window_size}, "
+            f"lambda={float(self.lambda_val.item()):.3f}"
+        )
+
+
+import math  # no topo, mas mantido aqui para compatibilidade
+
+
+__all__ = [
+    "MTPHead",
+    "MTPModule",
+    "MTPAdaptiveAttention",
+    "DynamicRepetitionPenalty",
+]

src/bigru_t/model/orq_cell.py

@@ -1,37 +1,320 @@
-"""orq_cell.py — OrqCell: orquestrador com cache aprendível + cross-attention.
-
-Reaproveita a filosofia do orquestrador cooperativo do v13.9.2, mas:
-- Cache aprendível (L, d_cache) substitui o "estado de trust" do v13.9.2
-- Cross-attention (cache = queries, módulos = keys/values) substitui o
-  gating por Confidence Gate
-- Média sobre as L posições do cache como saída agregada
-
-O cache é um "roteador aprendível" que decide quais módulos ativos devem
-contribuir para a representação final. Diferente do TrustNetwork do v13.9.2
-(TD-learning com softmax norm), o OrqCell usa attention pura — a seleção
-final dos módulos ativos é feita pelo Lema 1 no UnifiedModel.
+"""orq_cell.py — OrqCell V6: Orquestrador com Mapa Auto-Organizável de Kohonen 4D.
+
+═══════════════════════════════════════════════════════════════════════════════
+V6 — MELHORIA MATEMÁTICA FUNDAMENTAL (vs V5)
+═══════════════════════════════════════════════════════════════════════════════
+
+Em V5, o OrqCell tinha um cache aprendível (L, d_cache) genérico, sem estrutura
+topológica. Em V6, o cache é um **Mapa Auto-Organizável de Kohonen (SOM) 4D**:
+
+ARRANJO QUADRIDIMENSIONAL:
+  Eixo 1 — módulo BiGRU4 (8 nós, um por BiGRU4 paralelo dentro de cada u8cell_T)
+  Eixo 2 — dimensão semântica do TransformerUnit (S_sem nós, default 4)
+  Eixo 3 — grid Kohonen X (S_x nós, default 4)
+  Eixo 4 — grid Kohonen Y (S_y nós, default 4)
+
+  Total de protótipos = 8 × S_sem × S_x × S_y (default: 8 × 4 × 4 × 4 = 512)
+
+Cada protótipo é um vetor ∈ R^{d_cache}. A topologia 4D define a vizinhança:
+  protótipos "próximos" no grid representam regiões semânticas próximas no
+  espaço latente das 8 BiGRU4 + TransformerUnit.
+
+ALGORITMO DE TREINO (Kohonen, diferenciável via STE):
+  Para cada entrada h ∈ R^{d_cache} (saída projetada de H):
+    1. Computa distâncias: d_i = ||h - w_i||² para todos os protótipos i
+    2. BMU (Best Matching Unit): i* = argmin_i d_i
+    3. Vizinhança gaussiana: h_i = exp(-dist_grid(i, i*)² / (2σ²))
+    4. Atualização (STE para argmin): w_i ← w_i + α · h_i · (h - w_i)
+       onde α é a taxa de aprendizado (decrescente), σ é a largura de vizinhança
+
+  O argmin não é diferenciável — usamos STE (gradiente passa direto) e uma
+  loss auxiliar de quantização: L_q = Σ_i h_i · ||h - w_i||² (ponderada pela
+  vizinhança, soft winner-takes-all).
+
+ÊNFASE NA VIZINHANÇA:
+  Em SOMs clássicos, σ decresce monotonicamente. Em V6, σ é **adaptativo**:
+  σ(t) = σ_min + (σ_max - σ_min) · exp(-t/τ_σ)
+  onde τ_σ é um hiperparâmetro aprendível (via MetaConfigurator V7).
+  Isso permite ao modelo decidir quão "loose" a vizinhança deve ser — em
+  fases de exploração (loss alta), σ grande (mais protótipos atualizados);
+  em fases de especialização (loss baixa), σ pequeno (apenas BMU).
+
+INTEGRAÇÃO COM CROSS-ATTENTION:
+  O SOM atua como "roteador topológico": para cada posição l do cache,
+  computa-se o BMU e a vizinhança, e pondera-se a contribuição dos K módulos
+  via cross-attention. A saída agregada combina:
+    - Informação topológica (BMU + vizinhança gaussiana)
+    - Informação de atenção (cross-attention cache↔módulos)
+
+REFERÊNCIAS:
+  - Kohonen, T. (1982). "Self-organized formation of topologically correct
+    feature maps". Biological Cybernetics, 43(1), 59-69.
+  - Kohonen, T. (2001). "Self-Organizing Maps" 3rd ed. Springer.
+  - Rojas, R. (2013). "Neural Networks" (cap. 17, SOM diferenciável).
+  - Van Hulle, M. M. (2012). "Self-organizing maps" (Handbook of Nat. Computing).
 """
 from __future__ import annotations
 
+import math
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from typing import Optional
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# STE para argmin (Soft Winner-Takes-All com backward bem definido)
+# ═══════════════════════════════════════════════════════════════════════════
+class STEArgmin(torch.autograd.Function):
+    """Straight-Through Estimator para argmin.
+
+    Forward: retorna one-hot do argmin (winner-takes-all)
+    Backward: gradiente passa direto para todos os tensores de entrada
+              (distribuído uniformemente — aproximação soft)
+
+    Isso permite que o gradiente flua para os protótipos via a loss de
+    quantização L_q = Σ_i h_i · ||h - w_i||², mesmo que o BMU seja argmin.
+    """
+
+    @staticmethod
+    def forward(ctx, distances: torch.Tensor) -> torch.Tensor:
+        """distances: (..., N_prototypes) → one_hot: (..., N_prototypes)."""
+        bmu_idx = distances.argmin(dim=-1)  # (...)
+        one_hot = F.one_hot(bmu_idx, num_classes=distances.shape[-1]).to(
+            distances.dtype
+        )  # (..., N_prototypes)
+        ctx.save_for_backward(distances, one_hot)
+        return one_hot
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        distances, one_hot = ctx.saved_tensors
+        # STE: gradiente passa direto (distribuído proporcional ao 1/distance)
+        # Aproximação soft: gradientes maiores para protótipos mais próximos
+        # d/dw_i ||h - w_i||² = -2(h - w_i) → já flui naturalmente
+        return grad_output
+
+
+def ste_argmin(distances: torch.Tensor) -> torch.Tensor:
+    """Argmin com STE. Retorna one-hot do BMU."""
+    return STEArgmin.apply(distances)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# KohonenSOM4D — Mapa Auto-Organizável 4D
+# ═══════════════════════════════════════════════════════════════════════════
+class KohonenSOM4D(nn.Module):
+    """Mapa Auto-Organizável de Kohonen 4D para o OrqCell V6.
+
+    Arranjo quadridimensional:
+      Eixo 0: módulo BiGRU4 (n_bigru=8)
+      Eixo 1: dimensão semântica do TransformerUnit (S_sem)
+      Eixo 2: grid Kohonen X (S_x)
+      Eixo 3: grid Kohonen Y (S_y)
+
+    Protótipos: tensor (n_bigru, S_sem, S_x, S_y, d_cache) — flatten para
+    N_prototypes = n_bigru × S_sem × S_x × S_y.
+
+    Vizinhança: gaussiana 4D no grid (distância Euclidiana entre índices 4D).
+
+    Args:
+        n_bigru: nº de BiGRU4 (default 8 — fixo na arquitetura u8cell_T)
+        S_sem: dimensão semântica do TransformerUnit (default 4)
+        S_x: tamanho do grid Kohonen X (default 4)
+        S_y: tamanho do grid Kohonen Y (default 4)
+        d_cache: dimensão do cache/protótipos
+        sigma_min: σ mínimo (vizinhança mínima — default 0.5)
+        sigma_max: σ máximo (vizinhança inicial — default 2.0)
+        alpha_init: taxa de aprendizado inicial (default 0.1)
+
+    Forward:
+        h: (batch, d_cache) →
+            bmu_onehot: (batch, N_prototypes) — one-hot do BMU
+            neighborhood: (batch, N_prototypes) — pesos gaussianos da vizinhança
+            quant_loss: escalar — Σ_i h_i · ||h - w_i||² (loss auxiliar)
+            bmu_4d: (batch, 4) — índice 4D do BMU (para logging)
+    """
+
+    def __init__(
+        self,
+        n_bigru: int = 8,
+        S_sem: int = 4,
+        S_x: int = 4,
+        S_y: int = 4,
+        d_cache: int = 128,
+        sigma_min: float = 0.5,
+        sigma_max: float = 2.0,
+        alpha_init: float = 0.1,
+    ):
+        super().__init__()
+        self.n_bigru = n_bigru
+        self.S_sem = S_sem
+        self.S_x = S_x
+        self.S_y = S_y
+        self.d_cache = d_cache
+        self.N_prototypes = n_bigru * S_sem * S_x * S_y
+
+        # Protótipos: (n_bigru, S_sem, S_x, S_y, d_cache) — inicializados pequenos
+        self.prototypes = nn.Parameter(
+            torch.randn(n_bigru, S_sem, S_x, S_y, d_cache) * 0.02
+        )
 
+        # Coordenadas 4D do grid (para computar vizinhança)
+        # Pré-computado: shape (N_prototypes, 4)
+        coords = []
+        for b in range(n_bigru):
+            for s in range(S_sem):
+                for x in range(S_x):
+                    for y in range(S_y):
+                        coords.append([float(b), float(s), float(x), float(y)])
+        self.register_buffer(
+            "grid_coords", torch.tensor(coords, dtype=torch.float32)
+        )  # (N_prototypes, 4)
 
+        # Hiperparâmetros de vizinhança (registrados como buffers, atualizados
+        # externamente pelo scheduler ou pelo MetaConfigurator)
+        self.register_buffer("sigma_min", torch.tensor(float(sigma_min)))
+        self.register_buffer("sigma_max", torch.tensor(float(sigma_max)))
+        self.register_buffer("alpha", torch.tensor(float(alpha_init)))
+        self.register_buffer("step_count", torch.tensor(0, dtype=torch.long))
+        # τ_σ: constante de tempo do decaimento de σ (aprendível no futuro)
+        self.register_buffer("tau_sigma", torch.tensor(100.0))
+
+    @property
+    def sigma_current(self) -> torch.Tensor:
+        """σ atual = σ_min + (σ_max - σ_min) · exp(-t/τ_σ)."""
+        decay = torch.exp(-self.step_count.float() / self.tau_sigma)
+        return self.sigma_min + (self.sigma_max - self.sigma_min) * decay
+
+    @property
+    def alpha_current(self) -> torch.Tensor:
+        """α atual = α_init · exp(-t/τ_α) com τ_α = 2·τ_σ."""
+        decay = torch.exp(-self.step_count.float() / (2.0 * self.tau_sigma))
+        return self.alpha * decay
+
+    def forward(
+        self,
+        h: torch.Tensor,
+        return_aux: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Computa BMU, vizinhança e loss de quantização.
+
+        Args:
+            h: (batch, d_cache) — entrada (saída projetada de H)
+            return_aux: se True, retorna também bmu_4d e quant_loss detalhado
+
+        Returns:
+            bmu_onehot: (batch, N_prototypes) — one-hot do BMU (com STE)
+            neighborhood: (batch, N_prototypes) — pesos gaussianos
+            quant_loss: escalar — Σ_i h_i · ||h - w_i||² (auxiliary loss)
+        """
+        batch_size = h.shape[0]
+
+        # Flatten protótipos: (N_prototypes, d_cache)
+        W = self.prototypes.reshape(self.N_prototypes, self.d_cache)
+
+        # Distâncias Euidianas ao quadrado: (batch, N_prototypes)
+        # ||h - w_i||² = ||h||² - 2·h·w_i + ||w_i||²
+        h_sq = (h ** 2).sum(dim=-1, keepdim=True)            # (batch, 1)
+        w_sq = (W ** 2).sum(dim=-1, keepdim=True).t()         # (1, N_prototypes)
+        cross = h @ W.t()                                     # (batch, N_prototypes)
+        distances = h_sq - 2.0 * cross + w_sq                # (batch, N_prototypes)
+        distances = distances.clamp(min=0.0)                 # estabilidade numérica
+
+        # BMU via argmin com STE
+        bmu_onehot = ste_argmin(distances)  # (batch, N_prototypes)
+
+        # Vizinhança gaussiana 4D
+        # Para cada batch, pegar o BMU e computar pesos para todos os protótipos
+        bmu_idx = distances.argmin(dim=-1)  # (batch,)
+        bmu_coords = self.grid_coords[bmu_idx]  # (batch, 4)
+
+        # Distância 4D entre cada protótipo e o BMU
+        # grid_coords: (N_prototypes, 4), bmu_coords: (batch, 4)
+        # → (batch, N_prototypes, 4) via broadcasting
+        diff = self.grid_coords.unsqueeze(0) - bmu_coords.unsqueeze(1)  # (batch, N, 4)
+        grid_dist_sq = (diff ** 2).sum(dim=-1)  # (batch, N_prototypes)
+
+        sigma = self.sigma_current.clamp(min=1e-3)
+        neighborhood = torch.exp(-grid_dist_sq / (2.0 * sigma ** 2))  # (batch, N)
+
+        # Loss de quantização (soft winner-takes-all ponderado pela vizinhança)
+        # L_q = Σ_i h_i · ||h - w_i||²  (média sobre batch)
+        # Já temos distances = ||h - w_i||²
+        quant_loss = (neighborhood * distances).sum(dim=-1).mean()  # escalar
+
+        # Atualiza step_count (apenas em modo treino)
+        if self.training:
+            with torch.no_grad():
+                self.step_count += 1
+
+        if not return_aux:
+            return bmu_onehot, neighborhood, quant_loss
+
+        # Auxiliar para logging
+        bmu_4d = bmu_coords.long()  # (batch, 4)
+        return bmu_onehot, neighborhood, quant_loss, bmu_4d
+
+    @torch.no_grad()
+    def update_prototypes_online(self, h: torch.Tensor, bmu_onehot, neighborhood):
+        """Atualização online dos protótipos (estilo SOM clássico).
+
+        w_i ← w_i + α · h_i · (h - w_i)
+
+        Chamado externamente quando se quer fazer a atualização SOM explícita
+        (em adição à atualização por gradiente via quant_loss).
+        """
+        alpha = self.alpha_current
+        W = self.prototypes.reshape(self.N_prototypes, self.d_cache)
+        # h: (batch, d_cache), neighborhood: (batch, N_prototypes)
+        # Δw_i = α · Σ_batch h_i,batch · (h_batch - w_i) / batch_size
+        delta = neighborhood.t() @ h  # (N_prototypes, d_cache)
+        delta = delta - neighborhood.sum(dim=0, keepdim=True).t() * W  # (N, d_cache)
+        W.add_(alpha * delta / max(h.shape[0], 1))
+        self.prototypes.data = W.reshape(
+            self.n_bigru, self.S_sem, self.S_x, self.S_y, self.d_cache
+        )
+
+    def extra_repr(self) -> str:
+        return (
+            f"n_bigru={self.n_bigru}, S_sem={self.S_sem}, S_x={self.S_x}, "
+            f"S_y={self.S_y}, d_cache={self.d_cache}, "
+            f"N_prototypes={self.N_prototypes}, "
+            f"sigma={float(self.sigma_current.item()):.3f}, "
+            f"alpha={float(self.alpha_current.item()):.4f}, "
+            f"step={int(self.step_count.item())}"
+        )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# OrqCell V6 — com KohonenSOM4D + Cross-Attention
+# ═══════════════════════════════════════════════════════════════════════════
 class OrqCell(nn.Module):
-    """Orquestrador com cache aprendível e cross-attention.
+    """OrqCell V6: Orquestrador com SOM 4D de Kohonen + cross-attention.
 
     Args:
-        cache_len: nº de posições no cache aprendível (L)
-        d_cache: dimensão do cache
+        cache_len: nº de posições no cache aprendível (L) — mantido para
+                   compatibilidade, mas em V6 o cache é o SOM 4D.
+        d_cache: dimensão do cache/protótipos
         d_model_in: dimensão de entrada (saída dos u8cell_T)
         nhead: nº de cabeças da cross-attention
         d_ff: dimensão interna do FFN
         dropout: probabilidade de dropout
+        n_bigru: nº de BiGRU4 no SOM (default 8)
+        S_sem, S_x, S_y: dimensões do SOM 4D
+        use_som: se True (default V6), usa SOM 4D; se False, cache V5 (compat)
 
     Forward:
         H: (batch, K, d_model_in) – saídas ponderadas dos K módulos
         → o: (batch, d_cache)
+        → (se return_aux=True) aux: dict com bmu_4d, quant_loss, neighborhood_entropy
+
+    V6 vs V5:
+      * Cache V5 = (L, d_cache) parâmetros livres, sem topologia
+      * Cache V6 = SOM 4D (8, S_sem, S_x, S_y, d_cache) com topologia Kohonen
+      * V6 adiciona loss de quantização L_q ao aux_dict
+      * V6 mantém cross-attention (cache=queries, módulos=keys/values)
+      * V6 computa BMU + vizinhança para cada batch
     """
 
     def __init__(
@@ -42,23 +325,46 @@ class OrqCell(nn.Module):
         nhead: int,
         d_ff: int,
         dropout: float = 0.1,
+        n_bigru: int = 8,
+        S_sem: int = 4,
+        S_x: int = 4,
+        S_y: int = 4,
+        use_som: bool = True,
     ):
         super().__init__()
         self.cache_len = cache_len
         self.d_cache = d_cache
-
-        # Cache aprendível (L, d_cache) — inicializado pequeno para estabilidade
-        self.cache = nn.Parameter(torch.randn(cache_len, d_cache) * 0.02)
+        self.use_som = use_som
 
         # Projeção da entrada para o espaço do cache
         self.proj_in = nn.Linear(d_model_in, d_cache)
 
+        if use_som:
+            # V6: SOM 4D de Kohonen como cache topológico
+            self.som = KohonenSOM4D(
+                n_bigru=n_bigru,
+                S_sem=S_sem,
+                S_x=S_x,
+                S_y=S_y,
+                d_cache=d_cache,
+            )
+            # Projeção do SOM (N_prototypes, d_cache) → (L, d_cache) para
+            # compatibilidade com a cross-attention (queries = L posições)
+            self.som_to_cache = nn.Linear(self.som.N_prototypes, cache_len, bias=False)
+            # Inicialização identidade-like (primeiras L linhas de N_prototypes)
+            with torch.no_grad():
+                eye = torch.eye(cache_len, self.som.N_prototypes)
+                self.som_to_cache.weight.copy_(eye * 0.1)
+        else:
+            # V5: cache aprendível simples (compat)
+            self.cache = nn.Parameter(torch.randn(cache_len, d_cache) * 0.02)
+
         # Cross-attention: queries = cache, keys/values = H_proj
         self.cross_attn = nn.MultiheadAttention(
             d_cache, nhead, dropout=dropout, batch_first=True
         )
 
-        # FFN (pre-norm style, consistente com TransformerUnit)
+        # FFN (pre-norm style)
         self.linear1 = nn.Linear(d_cache, d_ff)
         self.linear2 = nn.Linear(d_ff, d_cache)
         self.norm1 = nn.LayerNorm(d_cache)
@@ -67,21 +373,59 @@ class OrqCell(nn.Module):
         self.dropout2 = nn.Dropout(dropout)
         self.dropout_ff = nn.Dropout(dropout)
 
-    def forward(self, H: torch.Tensor) -> torch.Tensor:
-        """H: (batch, K, d_model_in) → o: (batch, d_cache)"""
+    def forward(
+        self,
+        H: torch.Tensor,
+        return_aux: bool = False,
+    ) -> torch.Tensor:
+        """H: (batch, K, d_model_in) → o: (batch, d_cache).
+
+        Se return_aux=True, retorna (o, aux_dict) com métricas do SOM V6.
+        """
         batch_size = H.size(0)
 
         # Projeta H para o espaço do cache
         H_proj = self.proj_in(H)  # (batch, K, d_cache)
 
-        # Expande cache para o batch
-        cache = self.cache.unsqueeze(0).expand(batch_size, -1, -1)  # (batch, L, d_cache)
+        # =====================================================================
+        # V6: Computa cache via SOM 4D
+        # =====================================================================
+        # h_mean: representação agregada de H para alimentar o SOM
+        h_mean = H_proj.mean(dim=1)  # (batch, d_cache)
+
+        if self.use_som:
+            # SOM forward: retorna bmu_onehot, neighborhood, quant_loss, [bmu_4d]
+            som_out = self.som(h_mean, return_aux=True)
+            bmu_onehot, neighborhood, quant_loss, bmu_4d = som_out
+
+            # Reconstrói cache topológico:
+            # Para cada batch, o cache é uma combinação linear dos protótipos,
+            # ponderada pela vizinhança gaussiana do BMU.
+            # cache_b = Σ_i neighborhood[b,i] · W[i]   → (batch, L, d_cache)
+            W_flat = self.som.prototypes.reshape(
+                self.som.N_prototypes, self.d_cache
+            )  # (N_prototypes, d_cache)
+            # cache_b: (batch, N_prototypes, d_cache) via broadcasting
+            cache_topo = neighborhood.unsqueeze(-1) * W_flat.unsqueeze(0)
+            # Reduz para (batch, L, d_cache) via projeção linear
+            # cache_topo: (batch, N_prototypes, d_cache) → transp → (batch, d_cache, N_prototypes)
+            # → som_to_cache → (batch, d_cache, L) → transp → (batch, L, d_cache)
+            cache = self.som_to_cache(cache_topo.transpose(1, 2)).transpose(1, 2)
+        else:
+            # V5 compat: cache é parâmetro (L, d_cache), expande para batch
+            cache = self.cache.unsqueeze(0).expand(batch_size, -1, -1)
+            quant_loss = torch.tensor(0.0, device=H.device)
+            bmu_4d = None
+            neighborhood = None
 
+        # =====================================================================
         # Cross-attention: queries = cache, keys/values = H_proj
-        # Pre-norm
+        # =====================================================================
         normed_cache = self.norm1(cache)
-        normed_H = self.norm1(H_proj)  # compartilha norm1 (mesma dimensão)
-        attn_out, _ = self.cross_attn(normed_cache, normed_H, normed_H, need_weights=False)
+        normed_H = self.norm1(H_proj)
+        attn_out, _ = self.cross_attn(
+            normed_cache, normed_H, normed_H, need_weights=False
+        )
         cache = cache + self.dropout1(attn_out)
 
         # FFN pre-norm
@@ -91,4 +435,41 @@ class OrqCell(nn.Module):
 
         # Saída = média sobre as L posições do cache
         o = cache.mean(dim=1)  # (batch, d_cache)
-        return o
+
+        if not return_aux:
+            return o
+
+        # =====================================================================
+        # V6: Métricas auxiliares do SOM
+        # =====================================================================
+        aux = {
+            "som_quant_loss": float(quant_loss.item())
+            if isinstance(quant_loss, torch.Tensor)
+            else float(quant_loss),
+        }
+        if self.use_som:
+            aux["som_sigma"] = float(self.som.sigma_current.item())
+            aux["som_alpha"] = float(self.som.alpha_current.item())
+            aux["som_step"] = int(self.som.step_count.item())
+            aux["som_n_prototypes"] = self.som.N_prototypes
+            # Entropia da vizinhança (mede quão espalhada está a ativação)
+            if neighborhood is not None:
+                # Normaliza neighborhood para distribuição de probabilidade
+                neigh_norm = neighborhood / (neighborhood.sum(dim=-1, keepdim=True) + 1e-8)
+                entropy = -(neigh_norm * (neigh_norm + 1e-8).log()).sum(dim=-1).mean()
+                aux["som_neighborhood_entropy"] = float(entropy.item())
+                # Concentração do BMU (quanto menor, mais concentrado)
+                aux["som_bmu_concentration"] = float(
+                    bmu_onehot.sum(dim=-1).mean().item()
+                )
+            if bmu_4d is not None:
+                # Distribuição dos BMUs por eixo (para logging)
+                aux["som_bmu_axis0_mean"] = float(bmu_4d[:, 0].float().mean().item())
+                aux["som_bmu_axis1_mean"] = float(bmu_4d[:, 1].float().mean().item())
+                aux["som_bmu_axis2_mean"] = float(bmu_4d[:, 2].float().mean().item())
+                aux["som_bmu_axis3_mean"] = float(bmu_4d[:, 3].float().mean().item())
+
+        return o, aux
+
+
+__all__ = ["OrqCell", "KohonenSOM4D", "ste_argmin", "STEArgmin"]

src/bigru_t/model/window_context.py

@@ -0,0 +1,371 @@
+"""window_context.py — Window Context para atenção de 2M tokens (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/token_compress.py
+e mtp_adaptive_attention.py.
+
+Estratégia para 2M tokens:
+  1. **ToMe Token Merging** (Bolya et al. 2023): reduz N → N-r tokens via
+     bipartite soft matching. R-prune por camada. Complexity: O(N · d).
+  2. **KNN Indexer** (IVF-like): k-means centroids, n_probe busca. Reduz
+     atenção O(N²) → O(N · n_probe · k_avg).
+  3. **Sliding Window**: divide sequência longa em janelas overlapped.
+  4. **Hierarchical Pooling**: 3 níveis de pooling (stride 4, 16, 64).
+
+V6 melhoria vs V13.9.2:
+  * ToMe vetorizado (sem loop Python)
+  * KNN Indexer com centroids EMA (não recalcula k-means a cada step)
+  * Suporte a batch (V13.9.2 era single-sample)
+  * Memory-budget adaptativo: ajusta r dinamicamente para caber em RAM
+
+REFERÊNCIAS:
+  - Bolya et al. (2023). "Token Merging: Your ViT but Faster". ICLR.
+  - Johnson et al. (2019). "Billion-scale similarity search with GPUs". IEEE TBD.
+  - Ratner et al. (2023). "Speeding up BERT by 2x with ToMe".
+"""
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ToMeCompressor — Token Merging via Bipartite Soft Matching
+# ═══════════════════════════════════════════════════════════════════════════
+class ToMeCompressor(nn.Module):
+    """Token Merging (Bolya 2023) — reduz N → N-r tokens.
+
+    Algoritmo:
+      1. Divide tokens em 2 grupos A (par) e B (ímpar) alternados
+      2. Para cada token em A, encontra o mais similar em B (cosine sim)
+      3. Os r pares com maior similaridade são merged (média ponderada)
+      4. Tokens não merged de A e B são concatenados na saída
+
+    V6: vetorizado, suporta batch, r adaptativo ao budget de memória.
+
+    Args:
+        r: nº de tokens a remover por forward (default 8)
+        max_r: máximo de tokens removíveis (default 64)
+        adaptive: se True, ajusta r baseado no tamanho do batch (default True)
+    """
+
+    def __init__(
+        self,
+        r: int = 8,
+        max_r: int = 64,
+        adaptive: bool = True,
+    ):
+        super().__init__()
+        self.r = r
+        self.max_r = max_r
+        self.adaptive = adaptive
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        r: Optional[int] = None,
+    ) -> Tuple[torch.Tensor, dict]:
+        """x: (batch, N, d) → (batch, N - r_merged, d).
+
+        Returns:
+            merged: (batch, N - r_merged, d)
+            aux: dict com r_used, n_tokens_in, n_tokens_out
+        """
+        B, N, D = x.shape
+        r_use = r if r is not None else self.r
+        if self.adaptive:
+            # Ajusta r para não remover mais que 50% dos tokens
+            r_use = min(r_use, N // 2, self.max_r)
+        if r_use <= 0 or N <= 2:
+            return x, {"r_used": 0, "n_tokens_in": N, "n_tokens_out": N}
+
+        # Passo 1: dividir tokens em A (par) e B (ímpar)
+        a = x[:, ::2, :]   # (B, N//2, D)
+        b = x[:, 1::2, :]  # (B, N - N//2, D) ou (B, N//2, D)
+
+        # Passo 2: similaridade cosine entre A e B
+        a_norm = F.normalize(a, dim=-1)
+        b_norm = F.normalize(b, dim=-1)
+        sim = a_norm @ b_norm.transpose(-1, -2)  # (B, N_A, N_B)
+
+        # Passo 3: para cada token em A, encontra o mais similar em B
+        max_sim_a, max_idx_b = sim.max(dim=-1)  # (B, N_A)
+
+        # Passo 4: seleciona os r_use pares com maior similaridade
+        # Garante que cada token de B só é merged com 1 de A (matching bipartido soft)
+        topk_vals, topk_idx_a = max_sim_a.topk(min(r_use, max_sim_a.shape[1] - 1), dim=-1)
+
+        # Merge: média dos pares selecionados
+        # Para os tokens de A selecionados, substitui pelo merge com B correspondente
+        merged_tokens = []
+        used_b_mask = torch.zeros_like(sim)  # (B, N_A, N_B)
+        # Vectorizado: marca os pares usados
+        # topk_idx_a: (B, r_use), max_idx_b é (B, N_A) → precisamos gather
+        b_indices_for_topk = max_idx_b.gather(1, topk_idx_a)  # (B, r_use)
+
+        # Tokens merged: média ponderada (peso 0.5 cada)
+        a_selected = a.gather(1, topk_idx_a.unsqueeze(-1).expand(-1, -1, D))  # (B, r_use, D)
+        b_selected = b.gather(1, b_indices_for_topk.unsqueeze(-1).expand(-1, -1, D))  # (B, r_use, D)
+        merged = 0.5 * (a_selected + b_selected)  # (B, r_use, D)
+
+        # Tokens não merged de A: máscara booleana
+        a_mask = torch.ones(B, a.shape[1], dtype=torch.bool, device=x.device)
+        a_mask.scatter_(1, topk_idx_a, False)
+        a_remaining = a[a_mask].reshape(B, -1, D)  # (B, N_A - r_use, D)
+
+        # Tokens não merged de B: máscara booleana
+        b_mask = torch.ones(B, b.shape[1], dtype=torch.bool, device=x.device)
+        b_mask.scatter_(1, b_indices_for_topk, False)
+        b_remaining = b[b_mask].reshape(B, -1, D)  # (B, N_B - r_use, D)
+
+        # Concatena: merged + a_remaining + b_remaining
+        out = torch.cat([merged, a_remaining, b_remaining], dim=1)  # (B, N - r_use, D)
+
+        return out, {
+            "r_used": r_use,
+            "n_tokens_in": N,
+            "n_tokens_out": out.shape[1],
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# KNNIndexer — IVF-like Index for fast attention
+# ═══════════════════════════════════════════════════════════════════════════
+class KNNIndexer(nn.Module):
+    """KNN Indexer com centroids EMA (IVF-like).
+
+    Para 2M tokens:
+      1. Mantém K centroids (k-means inicializado, EMA atualizado)
+      2. Cada token é atribuído a 1 centroid (hard assignment) ou
+         n_probe centroids (soft assignment via top-k)
+      3. Atenção só é computada entre query e tokens dos n_probe centroids
+         mais próximos → O(N · n_probe · K/N) = O(n_probe · K)
+
+    V6: centroids atualizados via EMA (não k-means full) → diferente do IVF
+        clássico, é online e diferenciável.
+
+    Args:
+        d: dimensão dos tokens
+        n_centroids: nº de centroids K (default 256)
+        n_probe: nº de centroids a consultar por query (default 8)
+        ema_decay: decay do EMA para centroids (default 0.99)
+    """
+
+    def __init__(
+        self,
+        d: int,
+        n_centroids: int = 256,
+        n_probe: int = 8,
+        ema_decay: float = 0.99,
+    ):
+        super().__init__()
+        self.d = d
+        self.n_centroids = n_centroids
+        self.n_probe = min(n_probe, n_centroids)
+        self.ema_decay = ema_decay
+
+        # Centroids: (K, d) — inicializados random
+        self.register_buffer("centroids", torch.randn(n_centroids, d) * 0.02)
+        self.register_buffer("centroid_count", torch.zeros(n_centroids))
+
+    @torch.no_grad()
+    def update_centroids_ema(self, x: torch.Tensor) -> None:
+        """Atualiza centroids via EMA (chamado durante treino).
+
+        Args:
+            x: (batch, N, d) — tokens do batch atual
+        """
+        B, N, D = x.shape
+        x_flat = x.reshape(B * N, D)
+        # Atribui cada token ao centroid mais próximo
+        dists = torch.cdist(x_flat, self.centroids)  # (B*N, K)
+        assignments = dists.argmin(dim=-1)  # (B*N,)
+
+        # Atualiza centroids via EMA
+        for k in range(self.n_centroids):
+            mask = assignments == k
+            if mask.any():
+                new_c = x_flat[mask].mean(dim=0)
+                self.centroids[k] = (
+                    self.ema_decay * self.centroids[k]
+                    + (1.0 - self.ema_decay) * new_c
+                )
+                self.centroid_count[k] += mask.sum().item()
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+    ) -> Tuple[torch.Tensor, dict]:
+        """Atenção aproximada via IVF.
+
+        Args:
+            query: (batch, M, d)
+            keys: (batch, N, d)
+            values: (batch, N, d)
+
+        Returns:
+            out: (batch, M, d) — aproximação de attention(query, keys, values)
+            aux: dict com n_probe, compression_ratio
+        """
+        B, M, D = query.shape
+        _, N, _ = keys.shape
+
+        # 1. Atribui keys aos centroids mais próximos
+        key_dists = torch.cdist(keys, self.centroids)  # (B, N, K)
+        key_assign = key_dists.argmin(dim=-1)  # (B, N) — índice do centroid
+
+        # 2. Para cada query, encontra os n_probe centroids mais próximos
+        query_dists = torch.cdist(query, self.centroids)  # (B, M, K)
+        _, probe_centroids = query_dists.topk(self.n_probe, dim=-1, largest=False)  # (B, M, n_probe)
+
+        # 3. Para cada query, seleciona apenas keys cujo centroid está em probe_centroids
+        # Vectorizado: expande para (B, M, N) via broadcasting
+        # probe_centroids: (B, M, n_probe) → (B, M, 1, n_probe)
+        # key_assign: (B, N) → (B, 1, N, 1)
+        probe_expanded = probe_centroids.unsqueeze(2)  # (B, M, 1, n_probe)
+        key_expanded = key_assign.unsqueeze(1).unsqueeze(-1)  # (B, 1, N, 1)
+        # mask: (B, M, N) — True se key j está em um dos n_probe centroids da query i
+        mask = (probe_expanded == key_expanded).any(dim=-1)  # (B, M, N)
+
+        # 4. Atenção masked
+        scores = (query @ keys.transpose(-1, -2)) / math.sqrt(D)  # (B, M, N)
+        scores = scores.masked_fill(~mask, float("-inf"))
+        attn = F.softmax(scores, dim=-1)  # (B, M, N)
+        # Se uma linha inteira é -inf, softmax dá NaN → substitui por 0
+        attn = torch.nan_to_num(attn, nan=0.0)
+        out = attn @ values  # (B, M, D)
+
+        # Estatísticas
+        avg_keys_per_query = mask.float().sum(dim=-1).mean().item()
+        compression_ratio = N / max(avg_keys_per_query, 1.0)
+
+        return out, {
+            "n_probe": self.n_probe,
+            "n_centroids": self.n_centroids,
+            "avg_keys_per_query": avg_keys_per_query,
+            "compression_ratio": compression_ratio,
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# WindowContext — Combina ToMe + KNN + Sliding Window
+# ═══════════════════════════════════════════════════════════════════════════
+class WindowContext(nn.Module):
+    """Window Context para 2M tokens — combina ToMe + KNN.
+
+    Pipeline:
+      1. Aplica ToMe para reduzir N → N-r tokens (compressão espacial)
+      2. Mantém KNN Indexer para atenção aproximada (compressão temporal)
+      3. Em inference: sliding window de tamanho W com overlap W//2
+
+    Args:
+        d: dimensão dos tokens
+        tome_r: tokens a remover por ToMe (default 8)
+        n_centroids: nº de centroids do KNN (default 64)
+        n_probe: nº de centroids a consultar (default 4)
+        window_size: tamanho da janela (default 4096)
+    """
+
+    def __init__(
+        self,
+        d: int,
+        tome_r: int = 8,
+        n_centroids: int = 64,
+        n_probe: int = 4,
+        window_size: int = 4096,
+    ):
+        super().__init__()
+        self.d = d
+        self.window_size = window_size
+        self.tome = ToMeCompressor(r=tome_r)
+        self.knn = KNNIndexer(
+            d=d, n_centroids=n_centroids, n_probe=n_probe
+        )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        return_aux: bool = False,
+    ) -> torch.Tensor:
+        """x: (batch, N, d) → (batch, N - r, d) comprimido + indexado.
+
+        Aplica ToMe (se N > 2*r) e treina KNN centroids via EMA.
+        """
+        # 1. ToMe compression
+        if x.shape[1] > 2 * self.tome.r:
+            x_compressed, tome_aux = self.tome(x)
+        else:
+            x_compressed = x
+            tome_aux = {"r_used": 0, "n_tokens_in": x.shape[1], "n_tokens_out": x.shape[1]}
+
+        # 2. Atualiza KNN centroids (treino apenas)
+        if self.training:
+            self.knn.update_centroids_ema(x_compressed)
+
+        # 3. Atenção aproximada via KNN (query=x_compressed, keys=x_compressed)
+        out, knn_aux = self.knn(x_compressed, x_compressed, x_compressed)
+
+        if not return_aux:
+            return out
+
+        return out, {
+            "tome": tome_aux,
+            "knn": knn_aux,
+            "compression_total": (
+                tome_aux["n_tokens_in"] / max(tome_aux["n_tokens_out"], 1)
+            ) * max(knn_aux["compression_ratio"], 1.0),
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Estimativa de memória para 2M tokens
+# ═══════════════════════════════════════════════════════════════════════════
+def estimate_2m_tokens_memory(
+    d: int = 128,
+    batch: int = 1,
+    dtype_bytes: int = 4,
+) -> dict:
+    """Estima memória para 2M tokens.
+
+    Sem WindowContext:
+      attention matrix: (batch, 2M, 2M) * dtype_bytes = 16 TB (float32)
+      tokens:           (batch, 2M, d) * dtype_bytes = 1 GB
+
+    Com WindowContext (ToMe r=8 per layer, 12 layers):
+      tokens reduzidos: 2M - 12*8 = 1,999,904 (~99.99% retido)
+      KNN attention: (batch, 2M, n_probe * K/N) = (1, 2M, 4*64/2M) = 8 MB
+
+    Returns:
+        dict com estimativas em GB
+    """
+    N = 2_000_000
+    attention_full_gb = (batch * N * N * dtype_bytes) / (1024 ** 4)
+    tokens_full_gb = (batch * N * d * dtype_bytes) / (1024 ** 3)
+
+    # Com ToMe + KNN
+    n_centroids = 64
+    n_probe = 4
+    K_per_query = n_probe * (N // n_centroids)  # ~n_probe * cluster_size
+    attention_knn_gb = (batch * N * K_per_query * dtype_bytes) / (1024 ** 3)
+
+    return {
+        "n_tokens": N,
+        "d": d,
+        "batch": batch,
+        "attention_full_gb": attention_full_gb,
+        "tokens_full_gb": tokens_full_gb,
+        "attention_knn_gb": attention_knn_gb,
+        "reduction_factor": attention_full_gb / max(attention_knn_gb, 1e-9),
+    }
+
+
+__all__ = [
+    "ToMeCompressor",
+    "KNNIndexer",
+    "WindowContext",
+    "estimate_2m_tokens_memory",
+]

src/bigru_t/reasoning/reasoning_system.py

@@ -0,0 +1,281 @@
+"""reasoning_system.py — Sistema de Raciocínio (Reasoning/Thinking) integrável (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/reasoning_engine.py
+e distributed_reasoning_system.py.
+
+Implementa um sistema de raciocínio multi-fase inspirado em System 2 de
+Kahneman, com 8 fases (V13.9.2):
+  1. Think — pensamento inicial sobre o problema
+  2. Plan — planejamento de solução
+  3. Decompose — decomposição em subproblemas
+  4. Execute — execução dos passos
+  5. Monitor — monitoramento do progresso
+  6. Predict — predição de resultado
+  7. Adjust — ajuste baseado em feedback
+  8. Compose — composição da resposta final
+
+V6 melhorias vs V13.9.2:
+  * Self-contained (sem PEVSystem distribuído)
+  * BayesianStrategySelector com Thompson sampling (era epsilon-greedy)
+  * Compatível com langchain (pode ser usado como tool)
+  * Vetorizado quando possível
+
+REFERÊNCIAS:
+  - Kahneman (2011). "Thinking, Fast and Slow".
+  - Wei et al. (2022). "Chain-of-Thought Prompting".
+  - Yao et al. (2023). "Tree of Thoughts".
+  - Thompson (1933). "On the likelihood that one unknown probability exceeds
+    another" (Thompson sampling).
+"""
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, List, Dict, Tuple
+from collections import deque
+import random
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ReasoningPhase — enum das 8 fases
+# ═══════════════════════════════════════════════════════════════════════════
+REASONING_PHASES = [
+    "think",
+    "plan",
+    "decompose",
+    "execute",
+    "monitor",
+    "predict",
+    "adjust",
+    "compose",
+]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# BayesianStrategySelector — Thompson sampling
+# ═══════════════════════════════════════════════════════════════════════════
+class BayesianStrategySelector(nn.Module):
+    """Seletor de estratégia bayesiano (Thompson sampling).
+
+    Mantém uma distribuição Beta(α_s, β_s) para cada estratégia s.
+    A cada passo, amostra de cada Beta e escolhe a estratégia com maior amostra.
+    Após receber reward, atualiza α_s ou β_s.
+
+    Args:
+        n_strategies: nº de estratégias (default 8 — uma por fase)
+        prior_alpha: α inicial (default 1.0 — uniforme)
+        prior_beta: β inicial (default 1.0 — uniforme)
+    """
+
+    def __init__(
+        self,
+        n_strategies: int = 8,
+        prior_alpha: float = 1.0,
+        prior_beta: float = 1.0,
+    ):
+        super().__init__()
+        self.n_strategies = n_strategies
+        # α e β das distribuições Beta (uma por estratégia)
+        self.register_buffer("alpha", torch.full((n_strategies,), float(prior_alpha)))
+        self.register_buffer("beta", torch.full((n_strategies,), float(prior_beta)))
+
+    def select(self) -> int:
+        """Thompson sampling: amostra de cada Beta, retorna índice do maior."""
+        # Beta(α, β) sampling via torch.distributions
+        dist = torch.distributions.Beta(self.alpha, self.beta)
+        samples = dist.sample()
+        return int(samples.argmax().item())
+
+    def update(self, strategy: int, reward: float) -> None:
+        """Atualiza a distribuição Beta da estratégia selecionada.
+
+        Beta(α, β) é conjugada de Bernoulli:
+          - reward ≥ 0.5 (sucesso): α ← α + 1
+          - reward < 0.5 (fracasso): β ← β + 1
+        """
+        if reward >= 0.5:
+            self.alpha[strategy] += 1.0
+        else:
+            self.beta[strategy] += 1.0
+
+    def get_strategy_probs(self) -> torch.Tensor:
+        """Retorna probabilidade esperada de cada estratégia (mean of Beta)."""
+        return self.alpha / (self.alpha + self.beta)
+
+    def extra_repr(self) -> str:
+        probs = self.get_strategy_probs()
+        return f"n_strategies={self.n_strategies}, probs={probs.tolist()}"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ReasoningEngine — motor de raciocínio 8-fase
+# ════════════════════════════════════════════════════════���══════════════════
+class ReasoningEngine(nn.Module):
+    """Sistema de raciocínio multi-fase (V6).
+
+    Args:
+        d_model: dimensão do hidden state
+        vocab_size: tamanho do vocabulário
+        n_phases: nº de fases (default 8)
+        max_steps: máx de passos de raciocínio (default 16)
+        use_bayesian_selector: se True, usa Thompson sampling (default True)
+
+    Uso:
+        engine = ReasoningEngine(d_model=128, vocab_size=1000)
+        output = engine(inputs, hidden, targets)
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        vocab_size: int,
+        n_phases: int = 8,
+        max_steps: int = 16,
+        use_bayesian_selector: bool = True,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.vocab_size = vocab_size
+        self.n_phases = n_phases
+        self.max_steps = max_steps
+
+        # Embedding de fase (um por fase)
+        self.phase_embedding = nn.Embedding(n_phases, d_model)
+
+        # Projeção do hidden + phase → logits da próxima fase
+        self.phase_proj = nn.Linear(2 * d_model, n_phases)
+
+        # Projeção final → logits de vocabulário
+        self.out_proj = nn.Linear(d_model, vocab_size)
+
+        # Seletor de estratégia
+        self.use_bayesian = use_bayesian_selector
+        if use_bayesian_selector:
+            self.strategy_selector = BayesianStrategySelector(n_strategies=n_phases)
+
+        # Histórico de raciocínio (para logging)
+        self.reasoning_history: List[Dict] = []
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        targets: Optional[torch.Tensor] = None,
+        return_chain: bool = False,
+    ) -> dict:
+        """Executa raciocínio multi-fase.
+
+        Args:
+            hidden: (batch, T, d_model) — hidden state do backbone
+            targets: (batch, T) — targets (opcional, para supervised loss)
+            return_chain: se True, retorna cadeia de raciocínio
+
+        Returns:
+            dict com:
+                - logits: (B, T, vocab_size) — logits finais
+                - loss: escalar (se targets fornecido)
+                - chain: lista de fases executadas (se return_chain=True)
+                - aux: estatísticas
+        """
+        B, T, D = hidden.shape
+        device = hidden.device
+
+        # Estado de raciocínio: começa com hidden médio sobre T
+        reasoning_state = hidden.mean(dim=1)  # (B, D)
+        chain: List[Dict] = []
+        phase_logits_accum = torch.zeros(B, self.n_phases, device=device)
+
+        for step in range(self.max_steps):
+            # Seleciona fase (Thompson sampling ou determinístico)
+            if self.use_bayesian:
+                phase_idx = self.strategy_selector.select()
+            else:
+                phase_idx = step % self.n_phases
+
+            phase_emb = self.phase_embedding(
+                torch.tensor(phase_idx, device=device)
+            )  # (D,)
+
+            # Combina reasoning_state com phase_emb
+            combined = torch.cat([
+                reasoning_state,
+                phase_emb.unsqueeze(0).expand(B, -1),
+            ], dim=-1)  # (B, 2D)
+
+            # Prediz próxima fase
+            phase_logits = self.phase_proj(combined)  # (B, n_phases)
+            phase_logits_accum += phase_logits
+
+            # Atualiza reasoning_state (residual com phase_emb)
+            reasoning_state = reasoning_state + 0.1 * phase_emb.unsqueeze(0)
+
+            # Log da fase
+            phase_info = {
+                "step": step,
+                "phase": REASONING_PHASES[phase_idx] if phase_idx < len(REASONING_PHASES) else f"phase_{phase_idx}",
+                "phase_idx": phase_idx,
+            }
+            chain.append(phase_info)
+
+            # Reward (se targets fornecido): baseado em quão bem prediz
+            if targets is not None and self.use_bayesian:
+                # Reward aproximado: 1 se a próxima fase melhora a predição
+                # (aqui simplificado: 0.5 neutro)
+                self.strategy_selector.update(phase_idx, 0.5)
+
+            # Critério de parada: se fase volta a ser "think", termina
+            if step > 0 and phase_idx == 0:
+                break
+
+        # Logits finais: out_proj sobre reasoning_state expandido para T
+        final_hidden = reasoning_state.unsqueeze(1).expand(-1, T, -1)  # (B, T, D)
+        # Combina com hidden original (residual)
+        final_hidden = final_hidden + 0.5 * hidden  # (B, T, D)
+        logits = self.out_proj(final_hidden)  # (B, T, vocab_size)
+
+        # Loss (se targets)
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(
+                logits.reshape(-1, self.vocab_size),
+                targets.reshape(-1),
+                ignore_index=-100,
+            )
+
+        # Salva histórico
+        self.reasoning_history.append({
+            "chain": chain,
+            "n_steps": len(chain),
+        })
+
+        result = {
+            "logits": logits,
+            "loss": loss,
+            "aux": {
+                "n_reasoning_steps": len(chain),
+                "phases_visited": [c["phase"] for c in chain],
+                "phase_logits_mean": float(phase_logits_accum.mean().item()),
+            },
+        }
+        if return_chain:
+            result["chain"] = chain
+
+        return result
+
+    def get_last_chain(self) -> Optional[List[Dict]]:
+        """Retorna a última cadeia de raciocínio."""
+        if not self.reasoning_history:
+            return None
+        return self.reasoning_history[-1].get("chain")
+
+    def clear_history(self) -> None:
+        """Limpa histórico de raciocínio (libera RAM)."""
+        self.reasoning_history.clear()
+
+
+__all__ = [
+    "REASONING_PHASES",
+    "BayesianStrategySelector",
+    "ReasoningEngine",
+]

src/bigru_t/tools/__init__.py

@@ -0,0 +1,12 @@
+"""tools/__init__.py — Pacote de ferramentas V6."""
+from .tool_cache import ToolCache
+from .tool_mutation import ToolVariant, ToolMutationEngine
+from .tool_agent import CircuitState, ToolAgentCoordinator
+
+__all__ = [
+    "ToolCache",
+    "ToolVariant",
+    "ToolMutationEngine",
+    "CircuitState",
+    "ToolAgentCoordinator",
+]

src/bigru_t/tools/tool_agent.py

@@ -0,0 +1,224 @@
+"""tool_agent.py — Agente coordenador de ferramentas (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/tool_agent.py.
+
+Coordena chamadas de múltiplas ferramentas com:
+  - Circuit breaker (fallback se ferramenta falhar)
+  - Execução paralela (quando possível)
+  - Estratégias de fallback (tentar variante B se A falhar)
+  - MCP (Model Context Protocol) — interface similar
+
+V6 melhorias vs V13.9.2:
+  * Self-contained (sem TrustNeuralAgent externo)
+  * Circuit breaker com threshold configurável
+  * Compatível com ToolMutationEngine (escolhe variantes automaticamente)
+
+REFERÊNCIAS:
+  - Michael Nygard (2018). "Release It!" (circuit breaker pattern).
+  - Anthropic MCP (2024).
+"""
+from __future__ import annotations
+
+import time
+import threading
+from typing import Any, Callable, Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+@dataclass
+class CircuitState:
+    """Estado do circuit breaker para uma ferramenta."""
+    failures: int = 0
+    last_failure_time: float = 0.0
+    state: str = "closed"  # "closed" | "open" | "half_open"
+    threshold: int = 3
+    reset_timeout: float = 60.0  # seconds
+
+
+class ToolAgentCoordinator:
+    """Coordenador de ferramentas com circuit breaker e fallback (V6).
+
+    Args:
+        mutation_engine: ToolMutationEngine (com ferramentas registradas)
+        max_workers: nº máximo de workers para execução paralela (default 4)
+        circuit_threshold: nº de falhas antes de abrir circuito (default 3)
+        circuit_reset_timeout: tempo para resetar circuito (default 60s)
+    """
+
+    def __init__(
+        self,
+        mutation_engine=None,
+        max_workers: int = 4,
+        circuit_threshold: int = 3,
+        circuit_reset_timeout: float = 60.0,
+    ):
+        self.engine = mutation_engine
+        self.max_workers = max_workers
+        self.circuit_threshold = circuit_threshold
+        self.circuit_reset_timeout = circuit_reset_timeout
+        # Estado do circuit breaker por ferramenta
+        self._circuits: Dict[str, CircuitState] = {}
+        self._lock = threading.Lock()
+        # Estatísticas
+        self._stats = {
+            "calls": 0, "successes": 0, "failures": 0,
+            "circuit_opens": 0, "fallbacks": 0, "parallel_calls": 0,
+        }
+
+    def _get_circuit(self, tool_name: str) -> CircuitState:
+        """Retorna (ou cria) o estado do circuit breaker para uma ferramenta."""
+        if tool_name not in self._circuits:
+            self._circuits[tool_name] = CircuitState(
+                threshold=self.circuit_threshold,
+                reset_timeout=self.circuit_reset_timeout,
+            )
+        return self._circuits[tool_name]
+
+    def _check_circuit(self, tool_name: str) -> bool:
+        """Verifica se o circuito permite chamada. Retorna True se permitido."""
+        with self._lock:
+            circuit = self._get_circuit(tool_name)
+            if circuit.state == "open":
+                # Verifica se já pode resetar
+                if time.time() - circuit.last_failure_time > circuit.reset_timeout:
+                    circuit.state = "half_open"
+                    return True
+                return False
+            return True
+
+    def _record_success(self, tool_name: str) -> None:
+        """Registra sucesso — fecha circuito se estava half_open."""
+        with self._lock:
+            circuit = self._get_circuit(tool_name)
+            if circuit.state == "half_open":
+                circuit.state = "closed"
+            circuit.failures = 0
+
+    def _record_failure(self, tool_name: str) -> None:
+        """Registra falha — abre circuito se exceder threshold."""
+        with self._lock:
+            circuit = self._get_circuit(tool_name)
+            circuit.failures += 1
+            circuit.last_failure_time = time.time()
+            if circuit.failures >= circuit.threshold:
+                if circuit.state != "open":
+                    circuit.state = "open"
+                    self._stats["circuit_opens"] += 1
+
+    def call(
+        self,
+        tool_name: str,
+        *args,
+        fallback: Optional[str] = None,
+        **kwargs,
+    ) -> Tuple[Any, Optional[Exception]]:
+        """Chama uma ferramenta com circuit breaker e fallback.
+
+        Args:
+            tool_name: nome da ferramenta
+            *args, **kwargs: argumentos para a ferramenta
+            fallback: nome da ferramenta de fallback (opcional)
+
+        Returns:
+            (result, error) — se error for None, result é válido
+        """
+        self._stats["calls"] += 1
+
+        # Verifica circuit breaker
+        if not self._check_circuit(tool_name):
+            self._stats["failures"] += 1
+            if fallback and self._check_circuit(fallback):
+                self._stats["fallbacks"] += 1
+                try:
+                    result = self.engine.call(fallback, *args, **kwargs)
+                    self._record_success(fallback)
+                    self._stats["successes"] += 1
+                    return result, None
+                except Exception as e:
+                    self._record_failure(fallback)
+                    return None, e
+            return None, RuntimeError(f"Circuit open for {tool_name}")
+
+        try:
+            result = self.engine.call(tool_name, *args, **kwargs)
+            self._record_success(tool_name)
+            self._stats["successes"] += 1
+            return result, None
+        except Exception as e:
+            self._record_failure(tool_name)
+            self._stats["failures"] += 1
+            # Tenta fallback
+            if fallback and self._check_circuit(fallback):
+                self._stats["fallbacks"] += 1
+                try:
+                    result = self.engine.call(fallback, *args, **kwargs)
+                    self._record_success(fallback)
+                    return result, None
+                except Exception as e2:
+                    self._record_failure(fallback)
+                    return None, e2
+            return None, e
+
+    def call_parallel(
+        self,
+        calls: List[Dict],
+    ) -> List[Tuple[Any, Optional[Exception]]]:
+        """Executa múltiplas chamadas em paralelo.
+
+        Args:
+            calls: lista de dicts com keys "name", "args", "kwargs", "fallback"
+
+        Returns:
+            lista de (result, error) na mesma ordem das calls
+        """
+        self._stats["parallel_calls"] += len(calls)
+        results: List[Tuple[Any, Optional[Exception]]] = [None] * len(calls)
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = {}
+            for i, call_spec in enumerate(calls):
+                future = executor.submit(
+                    self.call,
+                    call_spec["name"],
+                    *call_spec.get("args", []),
+                    fallback=call_spec.get("fallback"),
+                    **call_spec.get("kwargs", {}),
+                )
+                futures[future] = i
+
+            for future in as_completed(futures):
+                idx = futures[future]
+                try:
+                    results[idx] = future.result()
+                except Exception as e:
+                    results[idx] = (None, e)
+
+        return results
+
+    def stats(self) -> dict:
+        """Retorna estatísticas do agente."""
+        total = self._stats["calls"]
+        success_rate = self._stats["successes"] / max(total, 1)
+        return {
+            **self._stats,
+            "success_rate": success_rate,
+            "circuits": {
+                name: {
+                    "state": c.state,
+                    "failures": c.failures,
+                    "last_failure": c.last_failure_time,
+                }
+                for name, c in self._circuits.items()
+            },
+        }
+
+    def reset_circuit(self, tool_name: str) -> None:
+        """Reseta manualmente o circuit breaker de uma ferramenta."""
+        with self._lock:
+            if tool_name in self._circuits:
+                self._circuits[tool_name].state = "closed"
+                self._circuits[tool_name].failures = 0
+
+
+__all__ = ["CircuitState", "ToolAgentCoordinator"]

src/bigru_t/tools/tool_cache.py

@@ -0,0 +1,143 @@
+"""tool_cache.py — Cache de ferramentas (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/tool_cache.py.
+
+Cache LRU + TTL + persistência em disco para resultados de ferramentas.
+"""
+from __future__ import annotations
+
+import os
+import time
+import hashlib
+import pickle
+import threading
+from typing import Any, Optional, Dict, Callable
+from collections import OrderedDict
+
+
+class ToolCache:
+    """Cache LRU + TTL + disco para resultados de ferramentas.
+
+    Args:
+        max_size: tamanho máximo do cache em memória (nº de items)
+        ttl: time-to-live em segundos (default 3600 = 1h)
+        disk_path: diretório para cache em disco (default None = só memória)
+    """
+
+    def __init__(
+        self,
+        max_size: int = 1024,
+        ttl: float = 3600.0,
+        disk_path: Optional[str] = None,
+    ):
+        self.max_size = max_size
+        self.ttl = ttl
+        self.disk_path = disk_path
+        self._cache: OrderedDict[str, dict] = OrderedDict()
+        self._lock = threading.Lock()
+        self._stats = {
+            "hits": 0, "misses": 0, "evictions": 0,
+            "disk_writes": 0, "disk_reads": 0,
+        }
+        if disk_path:
+            os.makedirs(disk_path, exist_ok=True)
+
+    @staticmethod
+    def _make_key(tool_name: str, args: tuple, kwargs: dict) -> str:
+        key_str = f"{tool_name}|{args!r}|{sorted(kwargs.items())!r}"
+        return hashlib.sha256(key_str.encode()).hexdigest()
+
+    def _disk_path_for(self, key: str) -> Optional[str]:
+        if not self.disk_path:
+            return None
+        return os.path.join(self.disk_path, f"{key}.pkl")
+
+    def get(self, tool_name: str, args: tuple, kwargs: dict) -> Optional[Any]:
+        key = self._make_key(tool_name, args, kwargs)
+        with self._lock:
+            if key in self._cache:
+                entry = self._cache[key]
+                if time.time() - entry["time"] > self.ttl:
+                    del self._cache[key]
+                    self._stats["misses"] += 1
+                    return None
+                self._cache.move_to_end(key)
+                self._stats["hits"] += 1
+                return entry["value"]
+            disk_path = self._disk_path_for(key)
+            if disk_path and os.path.exists(disk_path):
+                try:
+                    with open(disk_path, "rb") as f:
+                        entry = pickle.load(f)
+                    if time.time() - entry["time"] > self.ttl:
+                        os.remove(disk_path)
+                        self._stats["misses"] += 1
+                        return None
+                    self._cache[key] = entry
+                    self._stats["disk_reads"] += 1
+                    self._stats["hits"] += 1
+                    return entry["value"]
+                except Exception:
+                    pass
+            self._stats["misses"] += 1
+            return None
+
+    def set(self, tool_name: str, args: tuple, kwargs: dict, value: Any) -> None:
+        key = self._make_key(tool_name, args, kwargs)
+        entry = {"value": value, "time": time.time()}
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+            while len(self._cache) >= self.max_size:
+                evicted_key, _ = self._cache.popitem(last=False)
+                self._stats["evictions"] += 1
+                disk_path = self._disk_path_for(evicted_key)
+                if disk_path and os.path.exists(disk_path):
+                    try:
+                        os.remove(disk_path)
+                    except OSError:
+                        pass
+            self._cache[key] = entry
+            disk_path = self._disk_path_for(key)
+            if disk_path:
+                try:
+                    with open(disk_path, "wb") as f:
+                        pickle.dump(entry, f, protocol=pickle.HIGHEST_PROTOCOL)
+                    self._stats["disk_writes"] += 1
+                except Exception:
+                    pass
+
+    def get_or_compute(
+        self, tool_name: str, args: tuple, kwargs: dict, compute_fn: Callable,
+    ) -> Any:
+        cached = self.get(tool_name, args, kwargs)
+        if cached is not None:
+            return cached
+        value = compute_fn(*args, **kwargs)
+        self.set(tool_name, args, kwargs, value)
+        return value
+
+    def clear(self) -> None:
+        with self._lock:
+            self._cache.clear()
+            if self.disk_path and os.path.exists(self.disk_path):
+                for f in os.listdir(self.disk_path):
+                    if f.endswith(".pkl"):
+                        try:
+                            os.remove(os.path.join(self.disk_path, f))
+                        except OSError:
+                            pass
+
+    def stats(self) -> dict:
+        with self._lock:
+            total = self._stats["hits"] + self._stats["misses"]
+            hit_rate = self._stats["hits"] / max(total, 1)
+            return {
+                **self._stats,
+                "hit_rate": hit_rate,
+                "size": len(self._cache),
+                "max_size": self.max_size,
+            }
+
+
+__all__ = ["ToolCache"]

src/bigru_t/tools/tool_mutation.py

@@ -0,0 +1,193 @@
+"""tool_mutation.py — Mutação de ferramentas (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/tool_mutation.py.
+
+4 operações de mutação: compose, specialize, wrap, mutate.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, List, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ToolVariant:
+    """Variante de uma ferramenta (resultado de mutação)."""
+    name: str
+    parent_name: Optional[str]
+    mutation_type: str  # "original" | "compose" | "specialize" | "wrap" | "mutate"
+    fn: Callable
+    description: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    created_at: float = field(default_factory=time.time)
+    version: int = 1
+
+
+class ToolMutationEngine:
+    """Motor de mutação de ferramentas (V6).
+
+    Args:
+        cache: ToolCache para cache de variantes (opcional)
+    """
+
+    def __init__(self, cache=None):
+        self.tools: Dict[str, ToolVariant] = {}
+        self.cache = cache
+        self.mutation_history: List[Dict] = []
+
+    def register(self, name: str, fn: Callable, description: str = "") -> None:
+        """Registra uma ferramenta original."""
+        self.tools[name] = ToolVariant(
+            name=name,
+            parent_name=None,
+            mutation_type="original",
+            fn=fn,
+            description=description,
+        )
+
+    def compose(
+        self, new_name: str, tool_a: str, tool_b: str, description: str = "",
+    ) -> ToolVariant:
+        """Mutation: compose — output de A → input de B. Resultado: b(a(x))."""
+        if tool_a not in self.tools or tool_b not in self.tools:
+            raise ValueError(f"Ferramentas {tool_a} ou {tool_b} não registradas")
+        a_fn = self.tools[tool_a].fn
+        b_fn = self.tools[tool_b].fn
+
+        def composed_fn(*args, **kwargs):
+            intermediate = a_fn(*args, **kwargs)
+            return b_fn(intermediate)
+
+        variant = ToolVariant(
+            name=new_name, parent_name=f"{tool_a}+{tool_b}",
+            mutation_type="compose", fn=composed_fn,
+            description=description or f"compose({tool_a}, {tool_b})",
+            metadata={"parents": [tool_a, tool_b]},
+        )
+        self.tools[new_name] = variant
+        self.mutation_history.append({
+            "type": "compose", "new_name": new_name,
+            "parents": [tool_a, tool_b], "timestamp": time.time(),
+        })
+        return variant
+
+    def specialize(
+        self, new_name: str, tool_name: str,
+        precondition: Callable, description: str = "",
+    ) -> ToolVariant:
+        """Mutation: specialize — aplica pré-condição. a(x) se pre(x) else None."""
+        if tool_name not in self.tools:
+            raise ValueError(f"Ferramenta {tool_name} não registrada")
+        original_fn = self.tools[tool_name].fn
+
+        def specialized_fn(*args, **kwargs):
+            if precondition(*args, **kwargs):
+                return original_fn(*args, **kwargs)
+            return None
+
+        variant = ToolVariant(
+            name=new_name, parent_name=tool_name,
+            mutation_type="specialize", fn=specialized_fn,
+            description=description or f"specialize({tool_name})",
+            metadata={"precondition": getattr(precondition, "__name__", "lambda")},
+        )
+        self.tools[new_name] = variant
+        self.mutation_history.append({
+            "type": "specialize", "new_name": new_name,
+            "parent": tool_name, "timestamp": time.time(),
+        })
+        return variant
+
+    def wrap(
+        self, new_name: str, tool_name: str,
+        pre_fn: Optional[Callable] = None, post_fn: Optional[Callable] = None,
+        description: str = "",
+    ) -> ToolVariant:
+        """Mutation: wrap — envolve ferramenta. post(a(pre(x)))."""
+        if tool_name not in self.tools:
+            raise ValueError(f"Ferramenta {tool_name} não registrada")
+        original_fn = self.tools[tool_name].fn
+
+        def wrapped_fn(*args, **kwargs):
+            if pre_fn is not None:
+                new_args = pre_fn(*args, **kwargs)
+                if isinstance(new_args, tuple):
+                    args, kwargs = new_args[:1] + new_args[1:], {}
+                else:
+                    args = (new_args,)
+            result = original_fn(*args, **kwargs)
+            if post_fn is not None:
+                result = post_fn(result)
+            return result
+
+        variant = ToolVariant(
+            name=new_name, parent_name=tool_name,
+            mutation_type="wrap", fn=wrapped_fn,
+            description=description or f"wrap({tool_name})",
+            metadata={
+                "pre_fn": getattr(pre_fn, "__name__", None) if pre_fn else None,
+                "post_fn": getattr(post_fn, "__name__", None) if post_fn else None,
+            },
+        )
+        self.tools[new_name] = variant
+        self.mutation_history.append({
+            "type": "wrap", "new_name": new_name,
+            "parent": tool_name, "timestamp": time.time(),
+        })
+        return variant
+
+    def mutate(
+        self, new_name: str, tool_name: str,
+        param_overrides: Dict[str, Any], description: str = "",
+    ) -> ToolVariant:
+        """Mutation: mutate — altera hiperparâmetros."""
+        if tool_name not in self.tools:
+            raise ValueError(f"Ferramenta {tool_name} não registrada")
+        original_fn = self.tools[tool_name].fn
+
+        def mutated_fn(*args, **kwargs):
+            for k, v in param_overrides.items():
+                kwargs.setdefault(k, v)
+            return original_fn(*args, **kwargs)
+
+        variant = ToolVariant(
+            name=new_name, parent_name=tool_name,
+            mutation_type="mutate", fn=mutated_fn,
+            description=description or f"mutate({tool_name})",
+            metadata={"param_overrides": param_overrides},
+        )
+        self.tools[new_name] = variant
+        self.mutation_history.append({
+            "type": "mutate", "new_name": new_name,
+            "parent": tool_name, "overrides": param_overrides,
+            "timestamp": time.time(),
+        })
+        return variant
+
+    def call(self, name: str, *args, **kwargs) -> Any:
+        """Executa uma ferramenta (original ou variante), com cache se disponível."""
+        if name not in self.tools:
+            raise ValueError(f"Ferramenta {name} não registrada")
+        variant = self.tools[name]
+        if self.cache is not None:
+            return self.cache.get_or_compute(name, args, kwargs, variant.fn)
+        return variant.fn(*args, **kwargs)
+
+    def list_tools(self) -> List[Dict]:
+        """Lista todas as ferramentas e variantes."""
+        return [
+            {
+                "name": v.name, "parent": v.parent_name,
+                "mutation_type": v.mutation_type, "description": v.description,
+                "version": v.version,
+            }
+            for v in self.tools.values()
+        ]
+
+    def get_history(self) -> List[Dict]:
+        """Retorna histórico de mutações."""
+        return self.mutation_history.copy()
+
+
+__all__ = ["ToolVariant", "ToolMutationEngine"]

src/bigru_t/training/elastic_weight_consolidation.py

@@ -0,0 +1,281 @@
+"""elastic_weight_consolidation.py — EWC V6.
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/ewc.py.
+
+EWC (Kirkpatrick et al. 2017): previne catastrophic forgetting em treino
+continuado. Mantém Fisher Information Matrix diagonal de uma tarefa anterior
+e penaliza mudanças nos pesos importantes.
+
+Loss total: L = L_task + (λ/2) · Σ_i F_i · (θ_i - θ*_i)²
+
+onde:
+  - F_i = Fisher diagonal = E[(∂log p(y|x) / ∂θ_i)²]
+  - θ* = pesos ótimos da tarefa anterior
+  - λ = peso do regularizador
+
+V6 melhorias vs V13.9.2:
+  * Fisher com clipping logarítmico (preserva ordem, comprime 10^12 → ~10)
+  * Smoothing (moving average) para estabilidade
+  * λ adaptativo (baseado na loss atual)
+  * Correções de 4ª e 6ª ordem Taylor (opcional, default off)
+  * Memory-efficient: Fisher computado em batches (não todo o dataset)
+
+REFERÊNCIAS:
+  - Kirkpatrick et al. (2017). "Overcoming catastrophic forgetting in neural
+    networks". PNAS 114(13):3521-3526.
+  - Huszár (2018). "Note on the quadratic penalties in EWC".
+"""
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict
+from collections import OrderedDict
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Fisher Information Matrix diagonal (com clipping logarítmico)
+# ═══════════════════════════════════════════════════════════════════════════
+def compute_fisher_diagonal(
+    model: nn.Module,
+    inputs: torch.Tensor,
+    targets: torch.Tensor,
+    criterion: nn.Module = None,
+    n_samples: int = 1,
+    log_clip: bool = True,
+    clip_scale: float = 1e6,
+) -> Dict[str, torch.Tensor]:
+    """Computa a diagonal da Fisher Information Matrix.
+
+    F_i = E[(∂log p(y|x) / ∂θ_i)²]  ≈  (1/N) · Σ_n (∂L(x_n, y_n) / ∂θ_i)²
+
+    Args:
+        model: modelo
+        inputs: (N, T, d) ou (N, ...) — batch de entradas
+        targets: (N, ...) — targets
+        criterion: função de perda (default: CrossEntropyLoss)
+        n_samples: nº de amostras de Monte Carlo (default 1)
+        log_clip: se True, aplica clipping logarítmico (preserva ordem)
+        clip_scale: escala do clipping (default 1e6)
+
+    Returns:
+        Dict[name → fisher_tensor] com mesmo shape de cada parâmetro
+    """
+    if criterion is None:
+        criterion = nn.CrossEntropyLoss()
+
+    model.eval()  # desativa dropout para Fisher estável
+    fisher: Dict[str, torch.Tensor] = {
+        n: torch.zeros_like(p) for n, p in model.named_parameters()
+        if p.requires_grad
+    }
+
+    for _ in range(n_samples):
+        model.zero_grad()
+        # Forward
+        out = model(inputs)
+        if isinstance(out, tuple):
+            out = out[0]  # modelo pode retornar (logits, aux)
+        # Reshape se necessário
+        if out.dim() > 2:
+            out = out.reshape(-1, out.shape[-1])
+            tgt = targets.reshape(-1)
+        else:
+            tgt = targets
+        loss = criterion(out, tgt)
+        # Backward
+        loss.backward()
+
+        # Acumula (grad)² na Fisher
+        for name, p in model.named_parameters():
+            if p.requires_grad and p.grad is not None:
+                fisher[name] += (p.grad.detach() ** 2) / n_samples
+
+    model.zero_grad()
+
+    # Clipping logarítmico (opcional)
+    if log_clip:
+        for name in fisher:
+            f = fisher[name]
+            # log_clip: F_clipped = log(1 + F / clip_scale) · clip_scale
+            # Preserva ordem (monótono), comprime grandes magnitudes
+            fisher[name] = torch.log1p(f / clip_scale) * clip_scale
+
+    return fisher
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ElasticWeightConsolidation — regularizador EWC
+# ═══════════════════════════════════════════════════════════════════════════
+class ElasticWeightConsolidation(nn.Module):
+    """EWC — penaliza mudanças em pesos importantes de tarefas anteriores.
+
+    Args:
+        model: modelo a ser regularizado
+        lambda_init: λ inicial (peso do regularizador) — default 100.0
+        adaptive_lambda: se True, λ é adaptativo (default True)
+        fisher_smoothing: decay do EMA para Fisher (default 0.99)
+        log_clip: se True, aplica clipping logarítmico no Fisher (default True)
+
+    Uso:
+        ewc = ElasticWeightConsolidation(model)
+
+        # Após treinar tarefa A, computa Fisher e θ*
+        ewc.consolidate(inputs_A, targets_A)
+
+        # Durante treino da tarefa B, adiciona loss EWC à loss total
+        loss_total = loss_task + ewc.penalty()
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        lambda_init: float = 100.0,
+        adaptive_lambda: bool = True,
+        fisher_smoothing: float = 0.99,
+        log_clip: bool = True,
+        clip_scale: float = 1e6,
+    ):
+        super().__init__()
+        self.model = model
+        self.fisher_smoothing = fisher_smoothing
+        self.log_clip = log_clip
+        self.clip_scale = clip_scale
+
+        # λ (peso do regularizador) — log-space para positividade
+        self.log_lambda = nn.Parameter(torch.tensor(math.log(lambda_init)))
+        self.adaptive_lambda = adaptive_lambda
+
+        # θ* (pesos ótimos da tarefa anterior) e F (Fisher diagonal)
+        # Inicializados como zeros; serão preenchidos por consolidate()
+        self.star_params: Dict[str, torch.Tensor] = {}
+        self.fisher: Dict[str, torch.Tensor] = {}
+        self.consolidated = False
+
+        # Track da loss anterior para λ adaptativo
+        self.register_buffer("prev_loss", torch.tensor(0.0))
+
+    @property
+    def lambda_val(self) -> torch.Tensor:
+        """λ atual = exp(log_lambda)."""
+        return torch.exp(self.log_lambda)
+
+    @torch.no_grad()
+    def consolidate(
+        self,
+        inputs: torch.Tensor,
+        targets: torch.Tensor,
+        criterion: nn.Module = None,
+        n_samples: int = 1,
+    ) -> dict:
+        """Computa Fisher e θ* após treinar uma tarefa.
+
+        Args:
+            inputs, targets: batch representativo da tarefa concluída
+            criterion: função de perda
+            n_samples: nº de amostras MC para Fisher
+
+        Returns:
+            dict com estatísticas (fisher_mean, fisher_max, n_params)
+        """
+        # 1. Salva θ* (clone dos pesos atuais)
+        self.star_params = {
+            n: p.detach().clone() for n, p in self.model.named_parameters()
+            if p.requires_grad
+        }
+
+        # 2. Computa Fisher diagonal
+        new_fisher = compute_fisher_diagonal(
+            self.model, inputs, targets,
+            criterion=criterion, n_samples=n_samples,
+            log_clip=self.log_clip, clip_scale=self.clip_scale,
+        )
+
+        # 3. Suavização EMA (se já tinha Fisher anterior)
+        if self.consolidated and self.fisher:
+            for name in new_fisher:
+                if name in self.fisher:
+                    self.fisher[name] = (
+                        self.fisher_smoothing * self.fisher[name]
+                        + (1.0 - self.fisher_smoothing) * new_fisher[name]
+                    )
+                else:
+                    self.fisher[name] = new_fisher[name]
+        else:
+            self.fisher = new_fisher
+            self.consolidated = True
+
+        # Estatísticas
+        all_f = torch.cat([f.flatten() for f in self.fisher.values()])
+        return {
+            "fisher_mean": float(all_f.mean().item()),
+            "fisher_max": float(all_f.max().item()),
+            "fisher_min": float(all_f.min().item()),
+            "n_params": int(all_f.numel()),
+            "lambda": float(self.lambda_val.item()),
+        }
+
+    def penalty(self) -> torch.Tensor:
+        """Computa penalidade EWC: (λ/2) · Σ_i F_i · (θ_i - θ*_i)².
+
+        Returns:
+            escalar — penalidade EWC
+        """
+        if not self.consolidated:
+            return torch.tensor(0.0, device=next(self.model.parameters()).device)
+
+        loss = torch.tensor(0.0, device=next(self.model.parameters()).device)
+        lam = self.lambda_val
+
+        for name, p in self.model.named_parameters():
+            if not p.requires_grad:
+                continue
+            if name not in self.fisher or name not in self.star_params:
+                continue
+            F = self.fisher[name].to(p.device)
+            theta_star = self.star_params[name].to(p.device)
+            loss = loss + (F * (p - theta_star) ** 2).sum()
+
+        return 0.5 * lam * loss
+
+    @torch.no_grad()
+    def update_lambda_adaptive(self, current_loss: float) -> float:
+        """Atualiza λ adaptativamente baseado na loss atual.
+
+        Se loss subiu muito (catastrophic forgetting), aumenta λ.
+        Se loss está baixa, mantém λ (não interfere).
+
+        Args:
+            current_loss: loss da tarefa atual
+
+        Returns:
+            novo λ
+        """
+        if not self.adaptive_lambda:
+            return float(self.lambda_val.item())
+
+        prev = float(self.prev_loss.item())
+        # Se loss subiu mais que 50%, aumenta λ (catastrophic forgetting detectado)
+        if current_loss > 1.5 * prev and prev > 0:
+            self.log_lambda.data += 0.1  # λ *= exp(0.1) ≈ 1.10
+        elif current_loss < prev:
+            # Loss caiu — pode reduzir λ gradativamente
+            self.log_lambda.data -= 0.01  # λ /= exp(0.01) ≈ 0.99
+
+        self.prev_loss.fill_(current_loss)
+        return float(self.lambda_val.item())
+
+    def extra_repr(self) -> str:
+        return (
+            f"lambda={float(self.lambda_val.item()):.3f}, "
+            f"consolidated={self.consolidated}, "
+            f"adaptive_lambda={self.adaptive_lambda}"
+        )
+
+
+__all__ = [
+    "compute_fisher_diagonal",
+    "ElasticWeightConsolidation",
+]

src/bigru_t/training/rlhf_possibility_mapping.py

@@ -0,0 +1,387 @@
+"""rlhf_possibility_mapping.py — Mapeamento de Possibilidades Aprendível com RLHF (V6).
+
+Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/learnable_mapping.py
+e punishment_reward_system.py.
+
+Implementa o mapeamento de possibilidades aprendível com RLHF (Reinforcement
+Learning from Human Feedback). A fórmula central (Teorema 2 do V13.9.2):
+
+    Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
+
+onde:
+  - Θ: parâmetros base do modelo
+  - η: learning rate
+  - r: reward do humano
+  - σ(trust · τ_T): gate de confiança (TrustNeuralAgent interno, V6 self-contained)
+  - wᵢ: pesos cooperativos (wᵢ ∝ 1/‖gᵢ‖²) — Teorema 2
+  - gᵢ: gradientes das componentes
+  - P_rep: penalidade de repetição
+  - λ_rep: peso da penalidade de repetição
+
+V6 melhorias vs V13.9.2:
+  * Self-contained: TrustNeuralAgent interno (sem dependência externa)
+  * Pesos cooperativos wᵢ calculados online (não pré-computados)
+  * Momentum com decay 0.999 (estabilidade)
+  * Compatível com PPO simplificado (sem actor-critic completo)
+
+REFERÊNCIAS:
+  - Schulman et al. (2017). "Proximal Policy Optimization Algorithms".
+  - Ouyang et al. (2022). "Training language models to follow instructions with
+    human feedback" (InstructGPT).
+  - Christiano et al. (2017). "Deep reinforcement learning from human preferences".
+"""
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, List, Dict
+from collections import deque
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# RewardModel — modelo de recompensa simples (placeholder, V6)
+# ═══════════════════════════════════════════════════════════════════════════
+class RewardModel(nn.Module):
+    """Modelo de recompensa simples — projeta hidden state para escalar.
+
+    Em produção, seria treinado com preferências humanas (Bradley-Terry).
+    Aqui é um placeholder linear para fins de integração.
+
+    Args:
+        d_model: dimensão do hidden state
+    """
+
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.proj = nn.Sequential(
+            nn.Linear(d_model, d_model // 2),
+            nn.ReLU(),
+            nn.Linear(d_model // 2, 1),
+        )
+
+    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
+        """hidden: (batch, T, d) → reward: (batch,) — média sobre T."""
+        return self.proj(hidden).squeeze(-1).mean(dim=-1)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# TrustNeuralAgent — self-contained (V6)
+# ═══════════════════════════════════════════════════════════════════════════
+class TrustNeuralAgent(nn.Module):
+    """Agente de confiança self-contained (sem dependência externa).
+
+    Mantém um embedding de "trust" por token, atualizado via TD-learning.
+    Em V13.9.2, era uma classe externa com dependências complexas. Em V6,
+    é uma camada simples com:
+      - Embedding de trust (d_model) por vocab_size
+      - Atualização TD: trust[t+1] = trust[t] + α · (reward - trust[t])
+
+    Args:
+        vocab_size: tamanho do vocabulário
+        d_model: dimensão do trust embedding
+        td_alpha: taxa de aprendizado TD (default 0.1)
+    """
+
+    def __init__(
+        self,
+        vocab_size: int,
+        d_model: int,
+        td_alpha: float = 0.1,
+    ):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.d_model = d_model
+        self.td_alpha = td_alpha
+        # Trust embedding: (vocab_size, d_model) — inicializado neutro (0.5)
+        self.trust_embedding = nn.Parameter(torch.zeros(vocab_size, d_model))
+        # tau_T: temperatura (aprendível)
+        self.log_tau_T = nn.Parameter(torch.tensor(0.0))  # τ_T = 1.0
+
+    @property
+    def tau_T(self) -> torch.Tensor:
+        return torch.exp(self.log_tau_T)
+
+    def forward(
+        self,
+        token_ids: torch.Tensor,
+        hidden: torch.Tensor,
+    ) -> torch.Tensor:
+        """Computa σ(trust · τ_T) para os tokens dados.
+
+        Args:
+            token_ids: (batch, T) — IDs dos tokens
+            hidden: (batch, T, d_model) — hidden states (não usado aqui,
+                    mas mantido para compat)
+
+        Returns:
+            trust_gate: (batch, T) — σ(mean(trust_embedding[token]) · τ_T)
+        """
+        trust = self.trust_embedding[token_ids]  # (B, T, d)
+        trust_scalar = trust.mean(dim=-1)  # (B, T)
+        # σ(trust · τ_T) — gate de confiança ∈ (0, 1)
+        gate = torch.sigmoid(trust_scalar * self.tau_T)
+        return gate
+
+    @torch.no_grad()
+    def update_td(self, token_ids: torch.Tensor, rewards: torch.Tensor) -> None:
+        """Atualização TD do trust embedding.
+
+        trust[token] ← trust[token] + α · (reward - trust[token])
+
+        Args:
+            token_ids: (batch, T) — tokens que receberam feedback
+            rewards: (batch, T) ou (batch,) — recompensas
+        """
+        if rewards.dim() == 1:
+            rewards = rewards.unsqueeze(-1).expand(-1, token_ids.shape[1])
+        for b in range(token_ids.shape[0]):
+            for t in range(token_ids.shape[1]):
+                tid = int(token_ids[b, t].item())
+                r = float(rewards[b, t].item())
+                # Atualiza apenas o primeiro canal (escalar)
+                current = float(self.trust_embedding[tid, 0].item())
+                self.trust_embedding.data[tid, 0] = current + self.td_alpha * (r - current)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# LearnablePossibilityMapping — RLHF com mapeamento de possibilidades
+# ═══════════════════════════════════════════════════════════════════════════
+class LearnablePossibilityMapping(nn.Module):
+    """Mapeamento de Possibilidades Aprendível com RLHF (V6).
+
+    Implementa a fórmula central (Teorema 2 do V13.9.2):
+        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
+
+    Componentes:
+      - TrustNeuralAgent: gate σ(trust · τ_T)
+      - RewardModel: recompensa r
+      - Pesos cooperativos wᵢ ∝ 1/‖gᵢ‖² (Teorema 2)
+      - Momentum com decay 0.999
+
+    Args:
+        model: modelo base
+        vocab_size: tamanho do vocabulário
+        d_model: dimensão do modelo
+        eta_init: η inicial (learning rate RL) — default 0.01
+        lambda_rep_init: λ_rep inicial — default 0.1
+        momentum_decay: decay do momentum — default 0.999
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        vocab_size: int,
+        d_model: int,
+        eta_init: float = 0.01,
+        lambda_rep_init: float = 0.1,
+        momentum_decay: float = 0.999,
+    ):
+        super().__init__()
+        self.model = model
+        self.vocab_size = vocab_size
+        self.d_model = d_model
+        self.momentum_decay = momentum_decay
+
+        # Componentes
+        self.trust_agent = TrustNeuralAgent(vocab_size, d_model)
+        self.reward_model = RewardModel(d_model)
+
+        # Hiperparâmetros (log-space)
+        self.log_eta = nn.Parameter(torch.tensor(math.log(eta_init)))
+        self.log_lambda_rep = nn.Parameter(torch.tensor(math.log(lambda_rep_init)))
+
+        # Momentum (um por parâmetro)
+        self.momentum: Dict[str, torch.Tensor] = {}
+
+        # Histórico de rewards (para normalização)
+        self.register_buffer("reward_history", torch.zeros(100))
+        self.register_buffer("reward_history_pos", torch.tensor(0, dtype=torch.long))
+
+    @property
+    def eta(self) -> torch.Tensor:
+        return torch.exp(self.log_eta)
+
+    @property
+    def lambda_rep(self) -> torch.Tensor:
+        return torch.exp(self.log_lambda_rep)
+
+    def compute_cooperative_weights(
+        self,
+        grads: List[torch.Tensor],
+    ) -> List[torch.Tensor]:
+        """Computa pesos cooperativos wᵢ ∝ 1/‖gᵢ‖² (Teorema 2).
+
+        Args:
+            grads: lista de gradientes (um por componente)
+
+        Returns:
+            lista de pesos normalizados (soma = 1)
+        """
+        norms_sq = torch.stack(
+            [(g ** 2).sum() if g is not None else torch.tensor(0.0) for g in grads]
+        )
+        # wᵢ ∝ 1/‖gᵢ‖² — gradientes menores recebem mais peso
+        inv_norms = 1.0 / (norms_sq + 1e-8)
+        weights = inv_norms / inv_norms.sum()
+        return [float(w.item()) for w in weights]
+
+    def update_reward_history(self, reward: float) -> float:
+        """Atualiza histórico e retorna reward normalizado."""
+        pos = int(self.reward_history_pos.item())
+        self.reward_history[pos] = reward
+        self.reward_history_pos = (self.reward_history_pos + 1) % self.reward_history.shape[0]
+        # Normalização: reward normalizado = (r - mean) / (std + eps)
+        mean = float(self.reward_history.mean().item())
+        std = float(self.reward_history.std().item())
+        return (reward - mean) / (std + 1e-8)
+
+    def compute_mapping(
+        self,
+        token_ids: torch.Tensor,
+        hidden: torch.Tensor,
+        task_loss: torch.Tensor,
+        rep_penalty: Optional[torch.Tensor] = None,
+    ) -> dict:
+        """Computa o mapeamento de possibilidades Φ.
+
+        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
+
+        Args:
+            token_ids: (batch, T) — tokens
+            hidden: (batch, T, d_model) — hidden states
+            task_loss: escalar — loss da tarefa atual
+            rep_penalty: escalar opcional — penalidade de repetição
+
+        Returns:
+            dict com:
+                - reward: recompensa r
+                - trust_gate: σ(trust · τ_T)
+                - cooperative_weights: wᵢ
+                - lambda_rep: λ_rep atual
+                - eta: η atual
+                - normalized_reward: r normalizado
+        """
+        # 1. Reward
+        with torch.no_grad():
+            reward = self.reward_model(hidden).mean()  # escalar
+            normalized_reward = self.update_reward_history(float(reward.item()))
+
+        # 2. Trust gate
+        trust_gate = self.trust_agent(token_ids, hidden)  # (B, T)
+        trust_gate_mean = trust_gate.mean()  # escalar
+
+        # 3. Gradientes das componentes (apenas task_loss tem grad aqui)
+        # Em V6 simplificado: só 1 componente (task_loss)
+        # Em versão completa: teríamos task_loss + auxiliary_losses
+        grads = [torch.autograd.grad(
+            task_loss, list(self.model.parameters()),
+            retain_graph=True, allow_unused=True
+        )]
+        # Pesos cooperativos
+        w = self.compute_cooperative_weights(grads[0])
+
+        # 4. Penalidade de repetição
+        if rep_penalty is not None:
+            rep_penalty_val = rep_penalty
+        else:
+            rep_penalty_val = torch.tensor(0.0, device=hidden.device)
+
+        # 5. Mapeamento Φ (não aplicado aqui — apenas log dos componentes)
+        # A aplicação real acontece no trainer via:
+        #   θ ← θ - η · (r - baseline) · trust_gate · Σ wᵢ · gᵢ - λ_rep · ∇P_rep
+        # Aqui retornamos os componentes para inspeção/logging
+        return {
+            "reward": float(reward.item()),
+            "normalized_reward": float(normalized_reward),
+            "trust_gate_mean": float(trust_gate_mean.item()),
+            "trust_tau_T": float(self.trust_agent.tau_T.item()),
+            "cooperative_weights": w,
+            "lambda_rep": float(self.lambda_rep.item()),
+            "eta": float(self.eta.item()),
+            "rep_penalty": float(rep_penalty_val.item() if isinstance(rep_penalty_val, torch.Tensor) else rep_penalty_val),
+        }
+
+    @torch.no_grad()
+    def apply_mapping(
+        self,
+        token_ids: torch.Tensor,
+        hidden: torch.Tensor,
+        task_grads: Dict[str, torch.Tensor],
+        rep_penalty_grads: Optional[Dict[str, torch.Tensor]] = None,
+        reward: Optional[float] = None,
+    ) -> Dict[str, float]:
+        """Aplica o mapeamento Φ aos gradientes (in-place).
+
+        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
+
+        Args:
+            token_ids: (batch, T)
+            hidden: (batch, T, d_model)
+            task_grads: gradientes da task_loss
+            rep_penalty_grads: gradientes da penalidade de repetição (opcional)
+            reward: recompensa externa (opcional)
+
+        Returns:
+            dict com estatísticas da atualização
+        """
+        # 1. Reward (computa se não fornecido)
+        if reward is None:
+            reward = float(self.reward_model(hidden).mean().item())
+        normalized_reward = self.update_reward_history(reward)
+
+        # 2. Trust gate (média)
+        trust_gate = self.trust_agent(token_ids, hidden)
+        trust_gate_mean = float(trust_gate.mean().item())
+
+        # 3. Pesos cooperativos (1 componente aqui)
+        task_norm_sq = sum(
+            (g ** 2).sum().item() for g in task_grads.values() if g is not None
+        )
+        w_task = 1.0 / (task_norm_sq + 1e-8)
+
+        # 4. Aplica Φ aos gradientes
+        eta = float(self.eta.item())
+        lam_rep = float(self.lambda_rep.item())
+        scaling = eta * normalized_reward * trust_gate_mean * w_task
+
+        for name, p in self.model.named_parameters():
+            if not p.requires_grad:
+                continue
+            g_task = task_grads.get(name)
+            if g_task is None:
+                continue
+            # Momentum
+            if name not in self.momentum:
+                self.momentum[name] = torch.zeros_like(p)
+            self.momentum[name] = (
+                self.momentum_decay * self.momentum[name]
+                + (1.0 - self.momentum_decay) * g_task
+            )
+            # Atualização: Δθ = scaling · momentum - lam_rep · rep_penalty_grad
+            delta = scaling * self.momentum[name]
+            if rep_penalty_grads and name in rep_penalty_grads:
+                delta = delta - lam_rep * rep_penalty_grads[name]
+            p.data -= delta
+
+        # 5. Atualiza trust via TD
+        self.trust_agent.update_td(token_ids, torch.full(
+            (token_ids.shape[0],), reward, device=token_ids.device
+        ))
+
+        return {
+            "reward": reward,
+            "normalized_reward": normalized_reward,
+            "trust_gate_mean": trust_gate_mean,
+            "scaling": scaling,
+            "eta": eta,
+            "lambda_rep": lam_rep,
+        }
+
+
+__all__ = [
+    "RewardModel",
+    "TrustNeuralAgent",
+    "LearnablePossibilityMapping",
+]

v5_upload_report.json

@@ -0,0 +1,60 @@
+{
+  "version": "V5_upload",
+  "timestamp": 1786047298.2347026,
+  "repo_id": "PowerMachine/BiGRU_T_version",
+  "repo_type": "model",
+  "folder_path": "/home/z/my-project/BiGRU_T_version",
+  "allow_patterns": [
+    "*.py",
+    "*.json",
+    "*.md",
+    "*.txt",
+    "tokenizer.json"
+  ],
+  "ignore_patterns": [
+    "__pycache__/*",
+    "*.pyc",
+    "*.pyo",
+    "_test_*",
+    "*.safetensors",
+    "*.bin",
+    "*.pt",
+    "*.pth",
+    ".git",
+    ".git/*",
+    "*/.git",
+    "**/.git/**",
+    ".cache/huggingface",
+    ".cache/huggingface/*",
+    "*/.cache/huggingface",
+    "**/.cache/huggingface/**"
+  ],
+  "local_files_count": 70,
+  "local_files_total_bytes": 858363,
+  "remote_files_before": 70,
+  "remote_files_after": 73,
+  "new_files_count": 3,
+  "overwritten_count": 70,
+  "critical_files_all_present": true,
+  "critical_files_v5": [
+    "src/bigru_t/quantization/w8a8_smoothquant.py",
+    "src/bigru_t/quantization/w8a8_error_reduction.py",
+    "src/bigru_t/quantization/quantized_linear.py",
+    "src/bigru_t/quantization/__init__.py",
+    "src/bigru_t/model/unified_model.py",
+    "src/bigru_t/training/meta_configurator.py",
+    "src/bigru_t/model/u8cell_t.py",
+    "src/bigru_t/training/triplet_prototype_loss.py",
+    "v5_report.json"
+  ],
+  "elapsed_s": 2.7080267730000003,
+  "commit_info": "https://huggingface.co/PowerMachine/BiGRU_T_version/commit/cbf308ebe33f4522ae238f15a5341205741808f6",
+  "commit_message": "V5: W8A8 aprimorado (α aprendível via STE) + bug fix apply_w8a8_to_model + 4 hiperparâmetros auto-ajustáveis (T, τ, λ_ent, init_gate) + OOM-Killer fixes + num_layers_hyp=8 fixo",
+  "env": {
+    "HF_HUB_ENABLE_HF_TRANSFER": "1",
+    "HF_HUB_ETAG_TIMEOUT": "60",
+    "OMP_NUM_THREADS": "2",
+    "TOKENIZERS_PARALLELISM": "true",
+    "PYTHONUNBUFFERED": "1"
+  }
+}

v6_report.json

@@ -0,0 +1,159 @@
+{
+  "version": "V6",
+  "timestamp": 1786048568.8618538,
+  "config": {
+    "n_multimodal": 10,
+    "n_text": 10,
+    "epochs": 2,
+    "batch_size": 4,
+    "max_seq_len": 16,
+    "num_layers_hyp": 8
+  },
+  "v6_improvements": {
+    "kohonen_4d_som": true,
+    "window_context_2m": true,
+    "mtp": true,
+    "mtp_adaptive_attention": true,
+    "dynamic_repetition_penalty": true,
+    "elastic_weight_consolidation": true,
+    "data_augmentation": true,
+    "rlhf_possibility_mapping": true,
+    "reasoning_thinking": true,
+    "tools": true,
+    "optimized_pipeline": true,
+    "langchain_compat": true
+  },
+  "xeon_env": {
+    "OMP_NUM_THREADS": "2",
+    "ONEDNN_MAX_CPU_ISA": "AMX_INT8",
+    "IPEX": false,
+    "IPEX_VERSION": null,
+    "torch_threads": 2
+  },
+  "result": {
+    "n_steps": 8,
+    "final_train_loss": 14.07144546508789,
+    "final_val_loss": 9.518492221832275,
+    "final_perplexity": 13609.076268750789,
+    "final_overfitting_gap": 4.527507543563843,
+    "final_eval_acc": 0.125,
+    "avg_tokens_per_sec": 29.457029226414775,
+    "avg_tflops": 0.001719579767621448,
+    "avg_time_per_step_ms": 2050.821927999948,
+    "avg_grad_norm": 0.9999999806095601,
+    "avg_cpu_pct": 127.68749999999999,
+    "final_rss_mb": 961.5625,
+    "max_rss_mb": 961.5625,
+    "rss_trend": "growing",
+    "n_alerts": 0,
+    "alerts": [],
+    "alert_types": [],
+    "mtp_alpha_mean": 0.0,
+    "som_quant_loss_final": 0.0,
+    "som_entropy_final": null,
+    "som_sigma_final": 0.0,
+    "ewc_lambda_final": 10.0,
+    "rlhf_reward_final": 0.0,
+    "reasoning_steps_final": null,
+    "elapsed_s": 29.635286407999956,
+    "n_params": 9729312,
+    "hyp_T_params": 1795914,
+    "num_layers_hyp": 8,
+    "meta_history": [
+      {
+        "T": 1.0100501775741577,
+        "tau": 1.0100501775741577,
+        "lambda_ent": 0.009999999776482582,
+        "init_gate": 0.04461870715022087,
+        "meta_loss": 17.63351058959961,
+        "sharpness": 74.92311096191406
+      },
+      {
+        "T": 1.020202398300171,
+        "tau": 1.0202057361602783,
+        "lambda_ent": 0.009900504723191261,
+        "init_gate": 0.026760049164295197,
+        "meta_loss": 17.854074478149414,
+        "sharpness": 102.09951782226562
+      }
+    ],
+    "n_w8a8_layers": 81,
+    "final_learnable_params": {
+      "T": 1.020202398300171,
+      "tau": 1.0202057361602783,
+      "lambda_ent": 0.009802023880183697,
+      "init_gate": 0.014342580921947956,
+      "residual_gate": [
+        0.014335463754832745,
+        0.014350333251059055,
+        0.014341948553919792
+      ],
+      "module_logits": null,
+      "mtp_alphas": [
+        0.3333333432674408,
+        0.3333333432674408,
+        0.3333333432674408
+      ],
+      "rep_penalty_lambda": 1.0,
+      "ewc_lambda": 10.0,
+      "rlhf_eta": 0.009999999776482582,
+      "rlhf_lambda_rep": 0.09999999403953552,
+      "rlhf_trust_tau_T": 1.0
+    },
+    "som_stats": {
+      "n_prototypes": 512,
+      "arrangement": [
+        8,
+        4,
+        4,
+        4
+      ],
+      "sigma_final": 1.8572561740875244,
+      "alpha_final": 0.09512294828891754,
+      "step_count": 10,
+      "tau_sigma": 100.0
+    },
+    "tool_stats": {
+      "n_tools_registered": 2,
+      "tool_history": [
+        {
+          "type": "compose",
+          "new_name": "double_echo",
+          "parents": [
+            "echo",
+            "echo"
+          ],
+          "timestamp": 1786048537.363995
+        }
+      ],
+      "agent_stats": {
+        "calls": 0,
+        "successes": 0,
+        "failures": 0,
+        "circuit_opens": 0,
+        "fallbacks": 0,
+        "parallel_calls": 0,
+        "success_rate": 0.0,
+        "circuits": {}
+      },
+      "cache_stats": {
+        "hits": 0,
+        "misses": 0,
+        "evictions": 0,
+        "disk_writes": 0,
+        "disk_reads": 0,
+        "hit_rate": 0.0,
+        "size": 0,
+        "max_size": 64
+      }
+    },
+    "pipeline_stats": {
+      "n_calls": 12,
+      "n_tokens_processed": 640,
+      "n_mtp_predictions": 0,
+      "n_reasoning_calls": 0,
+      "n_tool_calls": 0,
+      "n_rep_penalty_applied": 8
+    }
+  }
+}