V6.5-7ds cleanup: remove legacy scripts/train_v6_5_final.py

scripts/train_v6_5_final.py

@@ -1,1567 +0,0 @@
-"""train_v6_5_final.py — V6.5 FINAL (real streaming, 864 neurons, SmoothQuant W8A8, tool_coordinator workers reactivated).
-
-═══════════════════════════════════════════════════════════════════════════════
-V6.5 FINAL — REAL STREAMING + 864 NEURONS + SMOOTHQUANT W8A8 + TOOL_COORDINATOR WORKERS
-═══════════════════════════════════════════════════════════════════════════════
-
-User requirements (V6.5 final, latest user message):
-    1. HF_TOKEN (provided by user via env var, deleted after use)
-    2. streaming_datasets.py + xeon_runtime.py ativo
-    3. Verificar toda a lógica e correções de bugs
-    4. Esgotar 4 datasets:
-       - dominguesm/restore-punctuation-ptbr-dataset
-       - carolina-c4ai/corpus-carolina
-       - CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1
-       - dominguesm/Canarim-Instruct-PTBR-Dataset
-    5. Após verificar métricas do modelo, raciocínio e capacidade de responder
-       (qualidade da resposta)
-    6. V65_ENABLE_STREAMING=1 (REAL streaming, no synthetic fallback)
-    7. Integrar SmoothQuantCompressor ao KLS para compressão W8A8 REAL
-       dos pesos do SOM
-    8. Limpeza agressiva de memória RAM e de armazenamento
-    9. Aumentar SOM grid para (6,6,6,4)=864 neurônios
-   10. Aumentar MTP head size  (K=6 instead of K=4)
-   11. Reativar reasoning_engine's tool_coordinator workers
-   12. Não reduzir tempo e NÃO gerar dados sintéticos
-       (causam erro na interpretação do resultado)
-   13. Streaming com pausas para dar tempo de processar e salvar arquivos
-   14. Parar se o Armazenamento for crítico
-
-Diferenças críticas vs train_v6_5.py (anterior):
-    - SOM_GRID: (6,6,6,4)=864  ←  era (4,4,4,2)=128  (USER EXIGE 864)
-    - HIDDEN_DIM: 1024         ←  era 256
-    - VOCAB_SIZE: 16384        ←  era 4096
-    - MTP_K: 6                 ←  era 4  (aumento MTP head size)
-    - V65_ENABLE_STREAMING=1 FORÇADO (real streaming, sem fallback sintético)
-    - SmoothQuantCompressor integrado ao KLS (chamado em cada train_som_on_buffer)
-    - tool_coordinator workers exercitados via execute_parallel()
-    - Pausas de 0.3s entre batches para dar tempo de salvar arquivos
-    - Verificação de armazenamento a cada 5 steps (parar se > 90% cheio)
-    - gc.collect() + torch.cuda.empty_cache() a cada 10 steps
-    - 4 datasets (não 6): Canarim-Instruct-PTBR substitui OpenMath + Dexavator
-
-Saídas:
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_report.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_training_metrics.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_module_analysis.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_script_activity.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_ewc_w8a8_benchmark.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_reasoning_eval.json
-    - /home/z/my-project/BiGRU_T_version/v6_5_final_w8a8_compression.json
-═══════════════════════════════════════════════════════════════════════════════
-"""
-from __future__ import annotations
-
-import gc
-import json
-import logging
-import math
-import os
-import shutil
-import sys
-import time
-import traceback
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-# ============================================================================
-# 0. Paths e logging
-# ============================================================================
-PROJECT_ROOT = Path("/home/z/my-project")
-BIGRU_ROOT = PROJECT_ROOT / "BiGRU_T_version"
-SRC_ROOT = BIGRU_ROOT / "src"
-REPORT_PATH = BIGRU_ROOT / "v6_5_final_report.json"
-METRICS_PATH = BIGRU_ROOT / "v6_5_final_training_metrics.json"
-MODULE_ANALYSIS_PATH = BIGRU_ROOT / "v6_5_final_module_analysis.json"
-SCRIPT_ACTIVITY_PATH = BIGRU_ROOT / "v6_5_final_script_activity.json"
-EWC_W8A8_BENCH_PATH = BIGRU_ROOT / "v6_5_final_ewc_w8a8_benchmark.json"
-REASONING_EVAL_PATH = BIGRU_ROOT / "v6_5_final_reasoning_eval.json"
-W8A8_COMPRESSION_PATH = BIGRU_ROOT / "v6_5_final_w8a8_compression.json"
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] [%(levelname)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("train_v6_5_final")
-
-# ============================================================================
-# 1. ATIVAR xeon_runtime.py + FORÇAR V65_ENABLE_STREAMING=1
-# ============================================================================
-# User requirement: "fazer V65_ENABLE_STREAMING=1"
-# Forçamos a env var ANTES de qualquer import para garantir streaming real.
-os.environ["V65_ENABLE_STREAMING"] = "1"
-logger.info(f"[V6.5-FINAL] V65_ENABLE_STREAMING={os.environ['V65_ENABLE_STREAMING']} (forced)")
-
-sys.path.insert(0, str(SRC_ROOT))
-
-from bigru_t.utils.xeon_runtime import (  # noqa: E402
-    optimize_xeon_environment,
-    benchmark_fp16_matmul,
-    get_xeon_status,
-)
-
-N_CORES = optimize_xeon_environment(verbose=True)
-XEON_STATUS = get_xeon_status()
-FP16_BENCH = benchmark_fp16_matmul(size=4000, warmup=1, iters=2)
-logger.info(f"[V6.5-FINAL] Xeon FP16 benchmark: {FP16_BENCH}")
-
-# ============================================================================
-# 2. Configurações V6.5 FINAL (NO REDUCTIONS — 864 neurons, 1024 hidden)
-# ============================================================================
-BATCH_SIZE = 16
-MAX_SEQ_LEN = 8
-
-# User requirement: "Aumentar SOM grid para (6,6,6,4)=864 neurônios"
-# V6.5-final: VOLTA para 864 (igual V6.4 — sem redução por memória)
-HIDDEN_DIM = 1024
-VOCAB_SIZE = 16384
-SOM_GRID = (6, 6, 6, 4)  # 864 neurons (V6.5-final: VOLTA para 864, era (4,4,4,2)=128)
-T_MAX = 10000
-N_START = 10
-LAMBDA_EWC = 0.02
-ALPHA0 = 0.1
-SIGMA0 = 1.5
-DIM_CHOICE = "y"
-
-# User requirement: "aumentar MTP head size"
-# V6.5-final: K=6 (era 4) — prediz 6 tokens futuros em vez de 4
-MTP_K = 6
-MTP_ENTROPY_BETA = 0.01
-MTP_ACTIVE_IN_VAL = True
-
-# User requirement: "esgotar 'dominguesm/restore-punctuation-ptbr-dataset' e
-# 'carolina-c4ai/corpus-carolina' e 'CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1'
-# e 'dominguesm/Canarim-Instruct-PTBR-Dataset'"
-# V6.5-final: 4 datasets (substitui OpenMath + Dexavator por Canarim-Instruct)
-V65_DATASETS_TO_EXHAUST = [
-    "dominguesm/restore-punctuation-ptbr-dataset",
-    "carolina-c4ai/corpus-carolina",
-    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
-    "dominguesm/Canarim-Instruct-PTBR-Dataset",
-]
-
-# User requirement: "streaming com pausas para dar tempo de processar e salvar arquivos"
-# V6.5-final: pausa de 0.3s entre batches + 1.5s entre datasets
-INTER_BATCH_PAUSE_S = 0.3
-INTER_DATASET_PAUSE_S = 1.5
-
-# User requirement: "parar se o Armazenamento for crítico"
-# V6.5-final: para se uso de disco > 90%
-STORAGE_CRITICAL_PCT = 90
-STORAGE_CHECK_INTERVAL_STEPS = 5
-
-# Limite por dataset por fase — "esgotar" dentro de um budget viável.
-# 50 samples/dataset/fase × 4 datasets × 2 fases × 2 epochs = 800 samples
-SAMPLES_PER_DATASET_PHASE = 50
-N_PHASES = 2
-TOTAL_SAMPLES = SAMPLES_PER_DATASET_PHASE * len(V65_DATASETS_TO_EXHAUST) * N_PHASES
-EPOCHS = 2
-
-# ============================================================================
-# 3. Import KohonenLearningSystem (V6.5-final — com W8A8 + tool_coordinator)
-# ============================================================================
-from bigru_t.model.kohonen_learning_system import (  # noqa: E402
-    KohonenLearningSystem,
-    SimpleBBPETokenizer,
-    positional_encoding,
-    text_to_4d_vector,
-    KohonenSOM4D,
-    HypothesisClassifier,
-)
-from bigru_t.model.hyp_t import HypT  # noqa: E402
-from bigru_t.training.mtp import (  # noqa: E402
-    MTPHead, MTPConfig, mtp_loss, mtp_entropy_regularizer,
-)
-from bigru_t.training.ewc import EWCV6, EWCConfigV6  # noqa: E402
-from bigru_t.quantization.smoothquant_compressor import SmoothQuantCompressor  # noqa: E402
-from bigru_t.model.vqvae2_hierarchical_flexnet import HierarchicalVQVAE2  # noqa: E402
-
-logger.info(
-    f"[V6.5-FINAL] All modules imported. "
-    f"Grid={SOM_GRID} ({SOM_GRID[0]*SOM_GRID[1]*SOM_GRID[2]*SOM_GRID[3]} neurons) | "
-    f"Hidden={HIDDEN_DIM} | Vocab={VOCAB_SIZE} | MTP_K={MTP_K} | "
-    f"Datasets={len(V65_DATASETS_TO_EXHAUST)} | Streaming=REAL"
-)
-
-
-# ============================================================================
-# 4. Module Access Analysis (mantido do V6.5 anterior)
-# ============================================================================
-def analyze_module_access() -> Dict[str, Any]:
-    """V6.5-final — Análise de acesso aos módulos."""
-    removed_modules = [
-        "src/bigru_t/model/bigru4.py",
-        "src/bigru_t/model/gru_hierarchy.py",
-        "src/bigru_t/model/orq_cell.py",
-        "src/bigru_t/model/train_t.py",
-        "src/bigru_t/model/transformer_unit.py",
-        "src/bigru_t/model/u8cell_t.py",
-        "src/bigru_t/model/unified_model.py",
-        "src/bigru_t/model/module_selector.py",
-        "src/bigru_t/training/trainer.py",
-    ]
-    removed_folders = [
-        "src/bigru_t/model/kohonen_refactored/",
-    ]
-    active_modules = [
-        "src/bigru_t/model/kohonen_learning_system.py",
-        "src/bigru_t/model/hyp_t.py",
-        "src/bigru_t/model/vqvae2_hierarchical.py",
-        "src/bigru_t/model/vqvae2_hierarchical_flexnet.py",
-        "src/bigru_t/model/token_compress.py",
-        "src/bigru_t/model/embedding_reconfig.py",
-        "src/bigru_t/model/attention_multimodal.py",
-        "src/bigru_t/training/mtp.py",
-        "src/bigru_t/training/ewc.py",
-        "src/bigru_t/quantization/smoothquant_compressor.py",
-        "src/bigru_t/quantization/w8a8_smoothquant.py",
-        "src/bigru_t/quantization/quantized_linear.py",
-        "src/bigru_t/reasoning/reasoning_engine.py",
-        "src/bigru_t/reasoning/thinking.py",
-        "src/bigru_t/reasoning/circular_orchestration.py",
-        "src/bigru_t/reasoning/tool_agent.py",
-        "src/bigru_t/reasoning/distributed_reasoning_system.py",
-        "src/bigru_t/reasoning/cyclic_reasoning.py",
-        "src/bigru_t/reasoning/consensus_sampling.py",
-        "src/bigru_t/data/streaming_datasets.py",
-        "src/bigru_t/utils/xeon_runtime.py",
-    ]
-    analysis = {
-        "removed_modules": {},
-        "removed_folders": {},
-        "active_modules": {},
-        "v65_final_features": {
-            "vqvae2_active_in_pipeline": True,
-            "reasoning_engine_integrated": True,
-            "smoothquant_w8a8_integrated_to_kls": True,
-            "tool_coordinator_workers_reactivated": True,
-            "ewc_w8a8_dequant_benchmark": True,
-            "kohonen_moved_up": True,
-            "real_streaming_forced": True,
-            "som_grid_864_neurons": True,
-            "mtp_head_size_increased_K6": True,
-        },
-    }
-    for m in removed_modules:
-        p = BIGRU_ROOT / m
-        analysis["removed_modules"][m] = {
-            "exists_after_v65": p.exists(),
-            "status": "REMOVED" if not p.exists() else "STILL_EXISTS",
-        }
-    for f in removed_folders:
-        p = BIGRU_ROOT / f
-        analysis["removed_folders"][f] = {
-            "exists_after_v65": p.exists(),
-            "status": "REMOVED" if not p.exists() else "STILL_EXISTS",
-        }
-    for m in active_modules:
-        p = BIGRU_ROOT / m
-        exists = p.exists()
-        size = p.stat().st_size if exists else 0
-        analysis["active_modules"][m] = {
-            "exists": exists,
-            "size_bytes": size,
-            "activity": "active" if exists else "MISSING",
-        }
-    return analysis
-
-
-# ============================================================================
-# 5. Script Activity Monitor
-# ============================================================================
-def monitor_script_activity() -> Dict[str, Any]:
-    """Monitora atividade de todos os scripts em scripts/."""
-    scripts_dir = BIGRU_ROOT / "scripts"
-    activity = {}
-    for script_path in sorted(scripts_dir.glob("*.py")):
-        name = script_path.name
-        stat = script_path.stat()
-        if "v6_5_final" in name:
-            cls = "active_v65_final"
-            activity_label = "active"
-        elif "v6_5" in name:
-            cls = "active_v65"
-            activity_label = "superseded"
-        elif "v6_4" in name:
-            cls = "active_v64"
-            activity_label = "recent"
-        elif name.startswith("upload"):
-            cls = "upload_utility"
-            activity_label = "active"
-        else:
-            cls = "other"
-            activity_label = "legacy"
-        activity[name] = {
-            "path": str(script_path.relative_to(BIGRU_ROOT)),
-            "size_bytes": stat.st_size,
-            "mtime": datetime.fromtimestamp(stat.st_mtime).isoformat(),
-            "classification": cls,
-            "activity": activity_label,
-        }
-    return activity
-
-
-# ============================================================================
-# 6. Storage Monitor (NEW V6.5-final)
-# ============================================================================
-def get_disk_usage_pct() -> float:
-    """Retorna percentual de uso do disco onde /home/z está montado."""
-    try:
-        total, used, free = shutil.disk_usage("/home/z")
-        return (used / total) * 100.0
-    except Exception:
-        return 0.0
-
-
-def aggressive_memory_cleanup() -> Dict[str, Any]:
-    """V6.5-final — Limpeza agressiva de memória RAM.
-
-    User requirement: "limpeza agressiva de memória RAM e de armazenamento"
-
-    Executa:
-    1. gc.collect() — força coleta de lixo Python
-    2. gc.collect() segunda vez — para ciclos resurrected
-    3. torch.cuda.empty_cache() — libera cache CUDA (no-op em CPU, mas seguro)
-    4. torch.cuda.synchronize() — aguarda operações pendentes
-    """
-    import torch
-    gc.collect()
-    gc.collect()  # segunda passada para resurrected cycles
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-    except Exception:
-        pass
-    return {
-        "gc_collected": True,
-        "timestamp": datetime.now().isoformat(),
-    }
-
-
-def aggressive_storage_cleanup() -> Dict[str, Any]:
-    """V6.5-final — Limpeza agressiva de armazenamento.
-
-    User requirement: "limpeza agressiva de memória RAM e de armazenamento"
-
-    Remove:
-    1. ~/.cache/huggingface/datasets temporários antigos (>1h)
-    2. Arquivos .lock órfãos em /tmp
-    3. Cache torch antigo
-    """
-    cleaned = []
-    bytes_freed = 0
-
-    # 1. HF datasets cache (apenas arquivos .lock e .incomplete)
-    try:
-        hf_cache = Path.home() / ".cache" / "huggingface" / "datasets"
-        if hf_cache.exists():
-            for lock_file in hf_cache.rglob("*.lock"):
-                try:
-                    sz = lock_file.stat().st_size
-                    lock_file.unlink()
-                    bytes_freed += sz
-                    cleaned.append(str(lock_file))
-                except Exception:
-                    pass
-            for inc_file in hf_cache.rglob("*.incomplete"):
-                try:
-                    sz = inc_file.stat().st_size
-                    inc_file.unlink()
-                    bytes_freed += sz
-                    cleaned.append(str(inc_file))
-                except Exception:
-                    pass
-    except Exception:
-        pass
-
-    # 2. /tmp bigru_*.tmp files older than 1h
-    try:
-        tmp_dir = Path("/tmp")
-        cutoff = time.time() - 3600
-        for tmp_file in tmp_dir.glob("bigru_*.tmp"):
-            try:
-                if tmp_file.stat().st_mtime < cutoff:
-                    sz = tmp_file.stat().st_size
-                    tmp_file.unlink()
-                    bytes_freed += sz
-                    cleaned.append(str(tmp_file))
-            except Exception:
-                pass
-    except Exception:
-        pass
-
-    return {
-        "n_files_removed": len(cleaned),
-        "bytes_freed": bytes_freed,
-        "mb_freed": bytes_freed / (1024 * 1024),
-        "files_removed_sample": cleaned[:10],
-    }
-
-
-# ============================================================================
-# 7. Verify logic and bug fixes (V6.5-final — adiciona W8A8 + tool_coordinator checks)
-# ============================================================================
-def verify_logic_and_bugfixes() -> Dict[str, Any]:
-    """V6.5-final — Verifica toda a lógica e correções de bugs.
-
-    Checagens:
-    1. KLS instantiation with VQ-VAE-2 + reasoning_engine + W8A8
-    2. find_bmu: no premature return (V6.3 bug fixed in V6.4)
-    3. activate_hypothesis: detach+clone to avoid backward-through-graph
-    4. pgvector_lookup: removed (V6.4)
-    5. kohonen_refactored/: removed (V6.5)
-    6. trainer.py: removed (V6.5 — depended on deleted unified_model)
-    7. VQ-VAE-2: produces valid output (no NaN/Inf)
-    8. reasoning_engine: produces <think> tags
-    9. NEW V6.5-final: SmoothQuant W8A8 compresses SOM weights (relative_error < 5%)
-   10. NEW V6.5-final: tool_coordinator workers exercised via execute_parallel
-    """
-    import torch
-    checks = {}
-
-    # Check 1: KLS instantiation with all V6.5-final features
-    try:
-        kls = KohonenLearningSystem(
-            vocab_size=512, hidden_dim=32, seq_len=8,
-            som_grid=(3, 3, 3, 2),
-            enable_vqvae2=True, enable_reasoning=True, enable_w8a8=True,
-        )
-        checks["kls_instantiation"] = {
-            "status": "PASS",
-            "details": (
-                f"vqvae2={kls.enable_vqvae2}, reasoning={kls.enable_reasoning}, "
-                f"w8a8={kls.enable_w8a8}, workers_active={kls._tool_coordinator_workers_active}"
-            ),
-        }
-    except Exception as e:
-        checks["kls_instantiation"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 2: find_bmu no premature return
-    try:
-        som = KohonenSOM4D((3, 3, 3, 2), alpha0=0.1, sigma0=1.5, lambda_ewc=0.02)
-        x = torch.randn(4)
-        bmu = som.find_bmu(x)
-        assert isinstance(bmu, tuple) and len(bmu) == 4
-        for idx, dim in zip(bmu, (3, 3, 3, 2)):
-            assert 0 <= idx < dim, f"BMU index {idx} out of range for dim {dim}"
-        checks["find_bmu_no_premature_return"] = {
-            "status": "PASS",
-            "details": f"bmu={bmu} valid",
-        }
-    except Exception as e:
-        checks["find_bmu_no_premature_return"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 3: activate_hypothesis detach+clone
-    try:
-        samples = ["o gato dorme", "o cachorro corre", "a menina brinca", "o pássaro voa"]
-        labels = [0, 1, 0, 1]
-        kls.tokenizer.fit(samples)
-        for _ in range(3):
-            kls.add_data(samples, labels)
-        kls.check_training_start()
-        kls.train_som_on_buffer()
-        kls.punishment_count = 1
-        kls.activate_hypothesis()
-        checks["activate_hypothesis_detach"] = {
-            "status": "PASS" if kls.classifier_trained else "FAIL",
-            "details": f"classifier_trained={kls.classifier_trained}",
-        }
-    except Exception as e:
-        checks["activate_hypothesis_detach"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 4: pgvector_lookup removed
-    try:
-        from bigru_t.model.hyp_t import HypT
-        hyp = HypT(d_input=32, d_model=64, nhead=2, d_ff=128, output_dim=32, num_layers=1)
-        assert not hasattr(hyp, "pgvector_lookup_before_punishment"), \
-            "pgvector_lookup should be removed"
-        checks["pgvector_lookup_removed"] = {"status": "PASS"}
-    except Exception as e:
-        checks["pgvector_lookup_removed"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 5: kohonen_refactored/ removed
-    kr_path = BIGRU_ROOT / "src" / "bigru_t" / "model" / "kohonen_refactored"
-    new_kls_path = BIGRU_ROOT / "src" / "bigru_t" / "model" / "kohonen_learning_system.py"
-    checks["kohonen_refactored_removed"] = {
-        "status": "PASS" if not kr_path.exists() and new_kls_path.exists() else "FAIL",
-        "details": f"old_folder={kr_path.exists()}, new_file={new_kls_path.exists()}",
-    }
-
-    # Check 6: trainer.py removed
-    trainer_path = BIGRU_ROOT / "src" / "bigru_t" / "training" / "trainer.py"
-    checks["trainer_removed"] = {
-        "status": "PASS" if not trainer_path.exists() else "FAIL",
-    }
-
-    # Check 7: VQ-VAE-2 produces valid output
-    try:
-        vq_metrics = kls.get_vqvae2_metrics()
-        if vq_metrics.get("active") and vq_metrics.get("n_calls", 0) > 0:
-            latest = vq_metrics.get("latest", {})
-            total_loss = latest.get("total_loss", 0.0)
-            assert not math.isnan(total_loss), "VQ-VAE-2 loss is NaN"
-            assert not math.isinf(total_loss), "VQ-VAE-2 loss is Inf"
-            checks["vqvae2_valid_output"] = {
-                "status": "PASS",
-                "details": f"n_calls={vq_metrics['n_calls']}, total_loss={total_loss:.4f}",
-            }
-        else:
-            checks["vqvae2_valid_output"] = {
-                "status": "PASS",
-                "details": "VQ-VAE-2 active but no calls yet (expected if no training)",
-            }
-    except Exception as e:
-        checks["vqvae2_valid_output"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 8: reasoning_engine produces <think> tags
-    try:
-        reasoning = kls.reason_sync("test query")
-        assert "<think>" in reasoning and "</think>" in reasoning, "Missing <think> tags"
-        assert "<answer>" in reasoning and "</answer>" in reasoning, "Missing <answer> tags"
-        checks["reasoning_engine_tags"] = {
-            "status": "PASS",
-            "details": f"reasoning length={len(reasoning)} chars",
-        }
-    except Exception as e:
-        checks["reasoning_engine_tags"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 9 (NEW V6.5-final): SmoothQuant W8A8 compresses SOM weights
-    try:
-        w8a8_result = kls.compress_som_weights_w8a8()
-        assert w8a8_result.get("active") is True, "W8A8 not active"
-        rel_err = w8a8_result.get("relative_error", 1.0)
-        # Tolerance: < 10% on tiny test (3,3,3,2)=54 neurons (real 864 has lower error)
-        assert rel_err < 0.20, f"W8A8 relative error too high: {rel_err:.4f}"
-        checks["smoothquant_w8a8_som_weights"] = {
-            "status": "PASS",
-            "details": (
-                f"relative_error={rel_err:.6f}, compression_ratio="
-                f"{w8a8_result.get('compression_ratio', 0):.1f}x, "
-                f"n_neurons={w8a8_result.get('n_neurons', 0)}"
-            ),
-        }
-    except Exception as e:
-        checks["smoothquant_w8a8_som_weights"] = {"status": "FAIL", "error": str(e)}
-
-    # Check 10 (NEW V6.5-final): tool_coordinator workers exercised
-    try:
-        tc_result = kls._exercise_tool_coordinator_workers()
-        assert tc_result.get("active") is True, "tool_coordinator not active"
-        assert tc_result.get("workers_exercised") is True, "workers not exercised"
-        assert tc_result.get("n_workers", 0) >= 2, f"too few workers: {tc_result.get('n_workers')}"
-        checks["tool_coordinator_workers_reactivated"] = {
-            "status": "PASS",
-            "details": (
-                f"n_workers={tc_result['n_workers']}, n_tools={tc_result['n_tools']}, "
-                f"n_results={tc_result['n_results']}, elapsed_ms={tc_result['elapsed_ms']:.2f}"
-            ),
-        }
-    except Exception as e:
-        checks["tool_coordinator_workers_reactivated"] = {"status": "FAIL", "error": str(e)}
-
-    # Summary
-    n_pass = sum(1 for c in checks.values() if c.get("status") == "PASS")
-    n_fail = sum(1 for c in checks.values() if c.get("status") == "FAIL")
-    return {
-        "checks": checks,
-        "n_pass": n_pass,
-        "n_fail": n_fail,
-        "all_pass": n_fail == 0,
-    }
-
-
-# ============================================================================
-# 8. EWC+W8A8 eval benchmark with active dequantization (mantido do V6.5 anterior)
-# ============================================================================
-def benchmark_ewc_w8a8_dequant() -> Dict[str, Any]:
-    """V6.5-final — Benchmark EWC+W8A8 eval com dequantização ativa.
-
-    User requirement: "benchmarkar EWC+W8A8 eval com dequantização ativa"
-    """
-    import torch
-    import torch.nn as nn
-    import time
-
-    torch.manual_seed(42)
-
-    class TestModel(nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.fc1 = nn.Linear(64, 128)
-            self.fc2 = nn.Linear(128, 32)
-        def forward(self, x):
-            return self.fc2(torch.relu(self.fc1(x)))
-
-    model = TestModel()
-    model.eval()
-
-    w_star = {name: p.detach().clone() for name, p in model.named_parameters()}
-
-    with torch.no_grad():
-        for p in model.parameters():
-            p.add_(torch.randn_like(p) * 0.1)
-
-    compressors = {}
-    for name, module in model.named_modules():
-        if isinstance(module, nn.Linear):
-            sq = SmoothQuantCompressor(alpha=0.5, n_bits=8, calibration_samples=32)
-            activation_samples = torch.randn(32, module.in_features)
-            sq.calibrate(module.weight.data, activation_samples)
-            compressors[name] = sq
-
-    fisher = {name: torch.rand_like(p) * 0.1 + 0.01 for name, p in model.named_parameters()}
-
-    def compute_ewc_penalty(weights_dict):
-        total = 0.0
-        for name, p in weights_dict.items():
-            if name in fisher and name in w_star:
-                total += float((fisher[name] * (p - w_star[name]).pow(2)).sum().item())
-        return total
-
-    # Modo A: Baseline
-    t0 = time.time()
-    for _ in range(100):
-        penalty_float = compute_ewc_penalty({n: p for n, p in model.named_parameters()})
-    t_float = (time.time() - t0) / 100 * 1000
-
-    # Modo B: W8A8 com dequantização ativa
-    t0 = time.time()
-    for _ in range(100):
-        dequant_weights = {}
-        for name, module in model.named_modules():
-            if isinstance(module, nn.Linear):
-                sq = compressors[name]
-                w_smooth = sq.smooth_weight(module.weight.data)
-                w_int8 = sq.quantize_per_tensor_symmetric(w_smooth)
-                w_dequant = sq.dequantize(w_int8, w_smooth)
-                w_dequant_unsmooth = w_dequant / sq.smooth_scale.unsqueeze(0)
-                dequant_weights[f"{name}.weight"] = w_dequant_unsmooth
-                if module.bias is not None:
-                    dequant_weights[f"{name}.bias"] = module.bias.data
-        penalty_dequant = compute_ewc_penalty(dequant_weights)
-    t_dequant = (time.time() - t0) / 100 * 1000
-
-    # Modo C: W8A8 sem dequant (broken)
-    t0 = time.time()
-    for _ in range(100):
-        int8_weights = {}
-        for name, module in model.named_modules():
-            if isinstance(module, nn.Linear):
-                sq = compressors[name]
-                w_smooth = sq.smooth_weight(module.weight.data)
-                w_int8 = sq.quantize_per_tensor_symmetric(w_smooth).float()
-                int8_weights[f"{name}.weight"] = w_int8
-                if module.bias is not None:
-                    int8_weights[f"{name}.bias"] = module.bias.data
-        penalty_int8 = compute_ewc_penalty(int8_weights)
-    t_int8 = (time.time() - t0) / 100 * 1000
-
-    error_dequant = abs(penalty_dequant - penalty_float) / max(abs(penalty_float), 1e-8)
-    error_int8 = abs(penalty_int8 - penalty_float) / max(abs(penalty_float), 1e-8)
-
-    return {
-        "benchmark": "EWC+W8A8 eval with active dequantization (V6.5-final)",
-        "config": {
-            "model": "TestModel(64-128-32)",
-            "n_linears": 2,
-            "n_bits": 8,
-            "alpha_smoothquant": 0.5,
-            "calibration_samples": 32,
-            "n_iterations": 100,
-        },
-        "results": {
-            "baseline_float": {
-                "penalty": float(penalty_float),
-                "time_ms_per_call": float(t_float),
-            },
-            "w8a8_with_dequant": {
-                "penalty": float(penalty_dequant),
-                "time_ms_per_call": float(t_dequant),
-                "relative_error": float(error_dequant),
-            },
-            "w8a8_no_dequant_broken": {
-                "penalty": float(penalty_int8),
-                "time_ms_per_call": float(t_int8),
-                "relative_error": float(error_int8),
-            },
-        },
-        "analysis": {
-            "dequant_preserves_accuracy": bool(error_dequant < 0.1),
-            "dequant_relative_error": float(error_dequant),
-            "int8_relative_error": float(error_int8),
-            "dequant_overhead_ms": float(t_dequant - t_float),
-            "dequant_overhead_pct": float((t_dequant - t_float) / t_float * 100),
-            "conclusion": (
-                f"V6.5-final EWC+W8A8 eval com dequant: "
-                f"erro dequant={error_dequant:.6f} (< 0.1 = OK), "
-                f"erro int8 direto={error_int8:.6f}."
-            ),
-        },
-        "ewc_config": {
-            "eval_mode_penalty": bool(EWCConfigV6().eval_mode_penalty),
-            "skip_som_filled_neurons": bool(EWCConfigV6().skip_som_filled_neurons),
-            "lambda_ewc": float(EWCConfigV6().lambda_ewc),
-            "fisher_n_samples": int(EWCConfigV6().fisher_n_samples),
-        },
-    }
-
-
-# ============================================================================
-# 9. Streaming dataset loader — REAL STREAMING ONLY (no synthetic fallback)
-# ============================================================================
-def load_real_streaming_samples(
-    dataset_name: str,
-    n_samples: int,
-    hf_token: Optional[str] = None,
-    timeout_s: int = 30,
-    seed_offset: int = 0,
-) -> Tuple[List[str], bool]:
-    """V6.5-final — Carrega amostras REAIS via streaming.
-
-    User requirement: "não gerar dados sintéticos (causam erro na interpretação
-    do resultado)"
-
-    Esta função NÃO gera dados sintéticos. Se o streaming falhar, retorna
-    lista vazia e flag success=False. O chamador decide como lidar.
-
-    Args:
-        dataset_name: nome do dataset HF.
-        n_samples: número desejado de amostras.
-        hf_token: token HF para datasets gated.
-        timeout_s: timeout em segundos.
-        seed_offset: offset para pular primeiras N amostras (diversidade entre fases).
-
-    Returns:
-        Tuple (samples, success). Se success=False, samples pode ser parcial.
-    """
-    samples: List[str] = []
-    success = False
-
-    try:
-        from bigru_t.data.streaming_datasets import stream_dataset
-        count = 0
-        collected = 0
-        t_start = time.time()
-        for sample in stream_dataset(dataset_name, max_samples=n_samples + seed_offset + 5, hf_token=hf_token):
-            if time.time() - t_start > timeout_s:
-                logger.warning(
-                    f"[V6.5-FINAL] Streaming {dataset_name} timeout after {timeout_s}s "
-                    f"(collected {collected}/{n_samples})"
-                )
-                break
-            if sample.raw_text and len(sample.raw_text.strip()) > 0:
-                if count < seed_offset:
-                    count += 1
-                    continue
-                samples.append(sample.raw_text.strip()[:200])
-                collected += 1
-                count += 1
-            if collected >= n_samples:
-                break
-        success = len(samples) > 0
-        if success:
-            logger.info(
-                f"[V6.5-FINAL] Real streaming OK: {len(samples)}/{n_samples} samples "
-                f"from {dataset_name} (elapsed {time.time()-t_start:.1f}s)"
-            )
-        else:
-            logger.warning(
-                f"[V6.5-FINAL] Real streaming returned 0 samples for {dataset_name}"
-            )
-    except Exception as e:
-        logger.warning(f"[V6.5-FINAL] Streaming {dataset_name} error: {e}")
-        success = False
-
-    return samples[:n_samples], success
-
-
-def make_label(text: str) -> int:
-    """Gera label binário determinístico baseado no texto."""
-    text_lower = text.lower()
-    if any(w in text_lower for w in ["gato", "mia", "dorme", "brinca", "menina", "boneca", "olá", "ola", "hello", "help", "instru", "pergunta"]):
-        return 0
-    return 1
-
-
-# ============================================================================
-# 10. MTP helper
-# ============================================================================
-def compute_mtp_loss_for_batch(
-    mtp_head: MTPHead,
-    hidden_states,
-    target_ids,
-) -> Dict[str, Any]:
-    """Computa MTP loss com entropy regularizer."""
-    import torch
-    logits, alphas = mtp_head(hidden_states)
-    loss, metrics = mtp_loss(logits, target_ids, alphas, entropy_beta=MTP_ENTROPY_BETA)
-    metrics["total_loss"] = float(loss.item())
-    return metrics
-
-
-# ============================================================================
-# 11. Reasoning evaluation (qualidade da resposta)
-# ============================================================================
-def evaluate_reasoning_and_response(kls: KohonenLearningSystem) -> Dict[str, Any]:
-    """V6.5-final — Avalia raciocínio e qualidade de resposta do KLS.
-
-    User requirement: "verificar métricas do modelo, raciocínio e capacidade
-    de responder (qualidade da resposta)"
-    """
-    test_queries = [
-        "o gato dorme na cama",
-        "calcule dois mais dois",
-        "olá como você está",
-        "translate hello to portuguese",
-        "prove que a soma de pares é par",
-        "qual é a capital do brasil",
-        "explique o que é uma rede neural",
-    ]
-
-    eval_results = []
-    for query in test_queries:
-        som_pred = kls.predict(query)
-        reasoning_text = kls.reason_sync(query)
-        import re
-        think_match = re.search(r"<think>(.*?)</think>", reasoning_text, re.DOTALL)
-        plan_match = re.search(r"<plan>(.*?)</plan>", reasoning_text, re.DOTALL)
-        answer_match = re.search(r"<answer>(.*?)</answer>", reasoning_text, re.DOTALL)
-        decompose_match = re.search(r"<decompose>(.*?)</decompose>", reasoning_text, re.DOTALL)
-
-        eval_results.append({
-            "query": query,
-            "som_prediction": som_pred,
-            "reasoning_length": len(reasoning_text),
-            "has_think": think_match is not None,
-            "has_plan": plan_match is not None,
-            "has_answer": answer_match is not None,
-            "has_decompose": decompose_match is not None,
-            "think_preview": (think_match.group(1).strip()[:120] + "...") if think_match else "",
-            "answer_preview": (answer_match.group(1).strip()[:120] + "...") if answer_match else "",
-            "n_tags": sum(1 for tag in ["<think>", "<plan>", "<decompose>", "<answer>"] if tag in reasoning_text),
-        })
-
-    n_with_answer = sum(1 for r in eval_results if r["has_answer"])
-    n_with_think = sum(1 for r in eval_results if r["has_think"])
-    avg_length = sum(r["reasoning_length"] for r in eval_results) / len(eval_results)
-    reasoning_stats = kls.get_reasoning_stats()
-
-    return {
-        "evaluation": "reasoning_and_response_quality_v65_final",
-        "n_test_queries": len(test_queries),
-        "results": eval_results,
-        "summary": {
-            "n_with_answer": n_with_answer,
-            "n_with_think": n_with_think,
-            "answer_rate": n_with_answer / len(eval_results),
-            "think_rate": n_with_think / len(eval_results),
-            "avg_reasoning_length": avg_length,
-            "reasoning_engine_active": reasoning_stats.get("active", False),
-            "reasoning_engine_n_history": reasoning_stats.get("n_history", 0),
-        },
-        "quality_assessment": {
-            "response_quality": "GOOD" if n_with_answer == len(eval_results) else "PARTIAL",
-            "reasoning_quality": "GOOD" if n_with_think == len(eval_results) else "PARTIAL",
-            "tags_present": ["<think>", "<plan>", "<decompose>", "<answer>"],
-            "compatible_with": ["Ollama", "LangChain", "vLLM"],
-        },
-    }
-
-
-# ============================================================================
-# 12. Metrics Monitor V6.5-final (12/12 + Kohonen + Hyp + MTP + EWC + VQVAE2 + W8A8 + Reasoning)
-# ============================================================================
-class MetricsMonitorV65Final:
-    """Monitor V6.5-final — inclui W8A8 compression metrics."""
-
-    def __init__(self) -> None:
-        self.steps: List[Dict[str, Any]] = []
-        self.alerts: List[Dict[str, Any]] = []
-        self.start_time = time.time()
-        self._prev_loss: Optional[float] = None
-
-    def record_step(
-        self,
-        step: int,
-        phase: int,
-        epoch: int,
-        dataset_name: str,
-        batch_loss: float,
-        batch_acc: float,
-        kls: KohonenLearningSystem,
-        mtp_metrics: Optional[Dict[str, Any]] = None,
-        rss_mb: float = 0.0,
-        disk_pct: float = 0.0,
-    ) -> None:
-        som_metrics = kls.som.get_metrics()
-        quality = {
-            "1.1_train_loss": float(batch_loss),
-            "1.2_train_acc": float(batch_acc),
-            "1.3_val_loss": float(batch_loss),
-            "1.4_val_acc": float(batch_acc),
-            "1.5_perplexity": float(2.718281828 ** min(batch_loss, 20)),
-        }
-        elapsed = time.time() - self.start_time
-        speed = {
-            "2.1_throughput_sps": float((step + 1) * BATCH_SIZE / max(elapsed, 1e-6)),
-            "2.2_step_time_ms": float(elapsed * 1000 / max(step + 1, 1)),
-            "2.3_epoch_progress": float(epoch + 1) / EPOCHS,
-            "2.4_rss_mb": float(rss_mb),
-            "2.5_xeon_tflops": float(FP16_BENCH.get("best_tflops", 0.0)),
-            "2.6_disk_pct": float(disk_pct),
-        }
-        kohonen = {
-            "sigma_t": float(som_metrics["sigma_t"]),
-            "alpha_t": float(som_metrics["alpha_t"]),
-            "t": int(som_metrics["t"]),
-            "n_neurons": int(som_metrics["n_neurons"]),
-            "fisher_w_mean": float(som_metrics["fisher_w_mean"]),
-            "fisher_w_max": float(som_metrics["fisher_w_max"]),
-            "fisher_accum_count": int(som_metrics["fisher_accum_count"]),
-            "has_ewc_reference": bool(som_metrics["has_ewc_reference"]),
-            "weights_norm": float(som_metrics["weights_norm"]),
-            "weights_w_mean": float(som_metrics["weights_w_mean"]),
-        }
-        hyp = {
-            "classifier_trained": bool(kls.classifier_trained),
-            "punishment_count": int(kls.punishment_count),
-            "success_count": int(kls.success_count),
-            "training_ready": bool(kls.training_ready),
-            "buffer_size": int(len(kls.buffer_4d)),
-            "required_new_samples": int(kls.required_new_samples),
-            "histogram_max": int(max(kls.histogram.values(), default=0)),
-            "time_counter": int(kls.time_counter),
-        }
-        mtp_block = {
-            "active": mtp_metrics is not None,
-            "mtp_total_loss": float(mtp_metrics.get("total_loss", 0.0)) if mtp_metrics else 0.0,
-            "mtp_weighted_loss": float(mtp_metrics.get("weighted_loss", 0.0)) if mtp_metrics else 0.0,
-            "mtp_entropy_reg": float(mtp_metrics.get("entropy_reg", 0.0)) if mtp_metrics else 0.0,
-            "mtp_alphas": mtp_metrics.get("alphas", []) if mtp_metrics else [],
-            "mtp_per_k_loss": mtp_metrics.get("per_k_loss", []) if mtp_metrics else [],
-            "active_in_val": bool(MTP_ACTIVE_IN_VAL),
-            "entropy_beta": float(MTP_ENTROPY_BETA),
-            "K": int(MTP_K),
-        }
-        vq_metrics = kls.get_vqvae2_metrics()
-        vqvae2_block = {
-            "active": bool(vq_metrics.get("active", False)),
-            "n_calls": int(vq_metrics.get("n_calls", 0)),
-            "latest_total_loss": float(vq_metrics.get("latest", {}).get("total_loss", 0.0)),
-            "latest_recon_loss": float(vq_metrics.get("latest", {}).get("recon_loss", 0.0)),
-            "latest_vq_loss": float(vq_metrics.get("latest", {}).get("vq_loss", 0.0)),
-            "mean_total_loss": float(vq_metrics.get("mean_total_loss", 0.0)),
-        }
-        # NEW V6.5-final: W8A8 compression metrics
-        w8a8_metrics = kls.get_w8a8_metrics()
-        w8a8_block = {
-            "active": bool(w8a8_metrics.get("active", False)),
-            "n_calls": int(w8a8_metrics.get("n_calls", 0)),
-            "latest_relative_error": float(w8a8_metrics.get("latest", {}).get("relative_error", 0.0)),
-            "latest_compression_ratio": float(w8a8_metrics.get("latest", {}).get("compression_ratio", 0.0)),
-            "latest_preserves_topology": bool(w8a8_metrics.get("latest", {}).get("preserves_topology", False)),
-            "mean_relative_error": float(w8a8_metrics.get("mean_relative_error", 0.0)),
-            "all_preserve_topology": bool(w8a8_metrics.get("all_preserve_topology", False)),
-        }
-        reasoning_stats = kls.get_reasoning_stats()
-        reasoning_block = {
-            "active": bool(reasoning_stats.get("active", False)),
-            "n_history": int(reasoning_stats.get("n_history", 0)),
-            "n_steps_last": int(reasoning_stats.get("stats", {}).get("n_steps", 0)),
-            "phases_used": reasoning_stats.get("stats", {}).get("phases_used", []),
-            "tool_coordinator_workers_active": bool(
-                getattr(kls, "_tool_coordinator_workers_active", False)
-            ),
-        }
-        ewc_block = {
-            "active": bool(som_metrics["has_ewc_reference"]),
-            "ewc_eval_mode_penalty": bool(EWCConfigV6().eval_mode_penalty),
-            "w8a8_dequant_active": True,
-            "fisher_w_mean": float(som_metrics["fisher_w_mean"]),
-            "fisher_w_max": float(som_metrics["fisher_w_max"]),
-            "fisher_accum_count": int(som_metrics["fisher_accum_count"]),
-        }
-
-        # Alerts
-        if self._prev_loss is not None:
-            delta = abs(batch_loss - self._prev_loss)
-            if delta > 5.0:
-                self.alerts.append({"type": "3.1_loss_spike", "step": step, "delta": float(delta)})
-            if batch_loss > 30.0:
-                self.alerts.append({"type": "3.2_loss_explosion", "step": step, "value": float(batch_loss)})
-            if batch_loss < 0.001:
-                self.alerts.append({"type": "3.3_loss_vanishing", "step": step, "value": float(batch_loss)})
-        self._prev_loss = float(batch_loss)
-        if rss_mb > 3500:  # V6.5-final: alerta se RSS > 3.5GB (limite 4GB cgroup)
-            self.alerts.append({"type": "3.4_rss_high", "step": step, "rss_mb": float(rss_mb)})
-        if disk_pct > STORAGE_CRITICAL_PCT:
-            self.alerts.append({
-                "type": "3.5_storage_critical",
-                "step": step,
-                "disk_pct": float(disk_pct),
-                "threshold": STORAGE_CRITICAL_PCT,
-            })
-
-        self.steps.append({
-            "step": step,
-            "phase": phase,
-            "epoch": epoch,
-            "dataset": dataset_name,
-            "quality": quality,
-            "speed": speed,
-            "kohonen": kohonen,
-            "hypothesis": hyp,
-            "mtp": mtp_block,
-            "vqvae2": vqvae2_block,
-            "w8a8": w8a8_block,
-            "reasoning": reasoning_block,
-            "ewc": ewc_block,
-        })
-
-    def summary(self) -> Dict[str, Any]:
-        if not self.steps:
-            return {}
-        final = self.steps[-1]
-        losses = [s["quality"]["1.1_train_loss"] for s in self.steps]
-        accs = [s["quality"]["1.2_train_acc"] for s in self.steps]
-        sigmas = [s["kohonen"]["sigma_t"] for s in self.steps]
-        alphas = [s["kohonen"]["alpha_t"] for s in self.steps]
-        vq_losses = [s["vqvae2"]["latest_total_loss"] for s in self.steps
-                     if s["vqvae2"]["active"] and not math.isnan(s["vqvae2"]["latest_total_loss"])]
-        w8a8_errors = [s["w8a8"]["latest_relative_error"] for s in self.steps
-                       if s["w8a8"]["active"] and not math.isnan(s["w8a8"]["latest_relative_error"])]
-        rss_max = max(s["speed"]["2.4_rss_mb"] for s in self.steps)
-        disk_max = max(s["speed"]["2.6_disk_pct"] for s in self.steps)
-        return {
-            "n_steps": len(self.steps),
-            "final_loss": float(losses[-1]),
-            "mean_loss": float(sum(losses) / len(losses)),
-            "min_loss": float(min(losses)),
-            "max_loss": float(max(losses)),
-            "final_acc": float(accs[-1]),
-            "mean_acc": float(sum(accs) / len(accs)),
-            "sigma_start": float(sigmas[0]),
-            "sigma_end": float(sigmas[-1]),
-            "alpha_start": float(alphas[0]),
-            "alpha_end": float(alphas[-1]),
-            "vqvae2_mean_total_loss": float(sum(vq_losses) / max(1, len(vq_losses))) if vq_losses else 0.0,
-            "vqvae2_final_total_loss": float(vq_losses[-1]) if vq_losses else 0.0,
-            "w8a8_mean_relative_error": float(sum(w8a8_errors) / max(1, len(w8a8_errors))) if w8a8_errors else 0.0,
-            "w8a8_final_relative_error": float(w8a8_errors[-1]) if w8a8_errors else 0.0,
-            "rss_max_mb": float(rss_max),
-            "rss_final_mb": float(final["speed"]["2.4_rss_mb"]),
-            "disk_max_pct": float(disk_max),
-            "disk_final_pct": float(final["speed"]["2.6_disk_pct"]),
-            "n_alerts": len(self.alerts),
-            "alerts": self.alerts[:30],
-            "kohonen_final": final["kohonen"],
-            "hypothesis_final": final["hypothesis"],
-            "mtp_final": final["mtp"],
-            "vqvae2_final": final["vqvae2"],
-            "w8a8_final": final["w8a8"],
-            "reasoning_final": final["reasoning"],
-            "ewc_final": final["ewc"],
-        }
-
-
-# ============================================================================
-# 13. Função principal de treino
-# ============================================================================
-def main() -> int:
-    import torch
-
-    n_neurons = SOM_GRID[0] * SOM_GRID[1] * SOM_GRID[2] * SOM_GRID[3]
-    print("\n" + "=" * 80)
-    print("V6.5 FINAL — REAL STREAMING + 864 NEURONS + SMOOTHQUANT W8A8 + WORKERS")
-    print("=" * 80)
-    print(f"  BATCH_SIZE           : {BATCH_SIZE}")
-    print(f"  Datasets to exhaust  : {len(V65_DATASETS_TO_EXHAUST)}")
-    print(f"  Samples/dataset/phase: {SAMPLES_PER_DATASET_PHASE}")
-    print(f"  Phases               : {N_PHASES}")
-    print(f"  Total samples target : {TOTAL_SAMPLES}")
-    print(f"  Epochs               : {EPOCHS}")
-    print(f"  SOM grid             : {SOM_GRID} ({n_neurons} neurons)")
-    print(f"  HIDDEN_DIM           : {HIDDEN_DIM}  (NO reduction)")
-    print(f"  VOCAB_SIZE           : {VOCAB_SIZE}  (NO reduction)")
-    print(f"  MTP K                : {MTP_K}  (increased from 4)")
-    print(f"  V65_ENABLE_STREAMING : {os.environ.get('V65_ENABLE_STREAMING')} (REAL)")
-    print(f"  SmoothQuant W8A8     : True (integrated to KLS, compresses SOM weights)")
-    print(f"  Tool coordinator     : True (4 workers, exercised via execute_parallel)")
-    print(f"  Inter-batch pause    : {INTER_BATCH_PAUSE_S}s")
-    print(f"  Storage critical     : {STORAGE_CRITICAL_PCT}% (stop if exceeded)")
-    print(f"  Xeon cores           : {N_CORES}")
-    print(f"  FP16 best TFLOPS     : {FP16_BENCH.get('best_tflops', 0.0):.3f}")
-    print("=" * 80 + "\n")
-
-    # ------------------------------------------------------------------
-    # 13.1 Module Access Analysis
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Running module access analysis...")
-    module_analysis = analyze_module_access()
-    MODULE_ANALYSIS_PATH.write_text(json.dumps(module_analysis, indent=2, ensure_ascii=False))
-    logger.info(f"[V6.5-FINAL] Module analysis saved: {MODULE_ANALYSIS_PATH}")
-
-    # ------------------------------------------------------------------
-    # 13.2 Script Activity Monitor
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Monitoring script activity...")
-    script_activity = monitor_script_activity()
-    SCRIPT_ACTIVITY_PATH.write_text(json.dumps(script_activity, indent=2, ensure_ascii=False))
-
-    # ------------------------------------------------------------------
-    # 13.3 Verify logic and bug fixes
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Verifying logic and bug fixes (10 checks)...")
-    verification = verify_logic_and_bugfixes()
-    print(f"\n--- Logic & Bug Fix Verification ---")
-    print(f"  PASS: {verification['n_pass']}/{verification['n_pass'] + verification['n_fail']}")
-    for check_name, check_info in verification["checks"].items():
-        status = check_info.get("status", "?")
-        details = check_info.get("details", check_info.get("error", ""))
-        print(f"    [{status}] {check_name}: {details[:80]}")
-
-    # ------------------------------------------------------------------
-    # 13.4 EWC+W8A8 benchmark with active dequantization
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Benchmarking EWC+W8A8 eval with active dequantization...")
-    ewc_w8a8_benchmark = benchmark_ewc_w8a8_dequant()
-    EWC_W8A8_BENCH_PATH.write_text(json.dumps(ewc_w8a8_benchmark, indent=2, ensure_ascii=False))
-    print(f"\n--- EWC+W8A8 Benchmark (dequant active) ---")
-    print(f"  Baseline float penalty : {ewc_w8a8_benchmark['results']['baseline_float']['penalty']:.6f}")
-    print(f"  W8A8+dequant penalty   : {ewc_w8a8_benchmark['results']['w8a8_with_dequant']['penalty']:.6f}")
-    print(f"  W8A8 no-dequant penalty: {ewc_w8a8_benchmark['results']['w8a8_no_dequant_broken']['penalty']:.6f}")
-    print(f"  Dequant relative error : {ewc_w8a8_benchmark['analysis']['dequant_relative_error']:.6f}")
-
-    # ------------------------------------------------------------------
-    # 13.5 Initialize KohonenLearningSystem (864 neurons + W8A8 + reasoning)
-    # ------------------------------------------------------------------
-    kls = KohonenLearningSystem(
-        vocab_size=VOCAB_SIZE,
-        hidden_dim=HIDDEN_DIM,
-        seq_len=MAX_SEQ_LEN,
-        som_grid=SOM_GRID,
-        alpha0=ALPHA0,
-        sigma0=SIGMA0,
-        lambda_ewc=LAMBDA_EWC,
-        N_start=N_START,
-        dim_choice=DIM_CHOICE,
-        hypothesis_hidden=[512, 256, 128, 64, 32, 16, 8],
-        T_max=T_MAX,
-        enable_vqvae2=True,        # VQ-VAE-2 ativo no pipeline
-        enable_reasoning=True,     # reasoning_engine integrado + tool_coordinator workers
-        enable_w8a8=True,          # V6.5-final: SmoothQuant W8A8 of SOM weights
-        vqvae2_code_dim=16,
-        vqvae2_num_codes_top=64,
-        vqvae2_num_codes_bot=128,
-        w8a8_alpha=0.5,
-        w8a8_n_bits=8,
-        w8a8_calibration_samples=128,
-    )
-    logger.info(
-        f"[V6.5-FINAL] KLS initialized: {n_neurons} neurons, hidden={HIDDEN_DIM}, "
-        f"vocab={VOCAB_SIZE}, w8a8={kls.enable_w8a8}, "
-        f"workers_active={kls._tool_coordinator_workers_active}"
-    )
-
-    # Treina tokenizer com corpus básico PT-BR
-    corpus_inicial = [
-        "o gato dorme na cama", "a casa eh azul", "ele corre rapido",
-        "ela canta uma musica", "o sol nasceu hoje", "nos vamos viajar",
-        "o livro esta na mesa", "a menina brinca no parque",
-        "ola como voce esta", "qual e o seu nome",
-        "calcule dois mais dois", "traduza hello para portugues",
-        "instrucao para resolver o problema", "resposta para a pergunta",
-    ]
-    kls.tokenizer.fit(corpus_inicial)
-    logger.info(f"[V6.5-FINAL] Tokenizer fitted with {len(corpus_inicial)} corpus words")
-
-    # Initialize MTP head — K=6 (aumentado de 4)
-    mtp_head = MTPHead(
-        hidden_size=HIDDEN_DIM,
-        vocab_size=VOCAB_SIZE,
-        K=MTP_K,
-        dropout=0.0,
-    )
-    logger.info(f"[V6.5-FINAL] MTPHead initialized (K={MTP_K}, hidden={HIDDEN_DIM}, vocab={VOCAB_SIZE})")
-
-    # Monitor
-    monitor = MetricsMonitorV65Final()
-
-    # HF_TOKEN
-    hf_token = os.environ.get("HF_TOKEN")
-    if not hf_token:
-        logger.warning("[V6.5-FINAL] HF_TOKEN not set — streaming may fail for gated datasets")
-    else:
-        logger.info(f"[V6.5-FINAL] HF_TOKEN set: {hf_token[:8]}...")
-
-    # ------------------------------------------------------------------
-    # 13.6 Aggressive storage cleanup before training starts
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Aggressive storage cleanup (pre-training)...")
-    storage_cleanup_pre = aggressive_storage_cleanup()
-    aggressive_memory_cleanup()
-    logger.info(
-        f"[V6.5-FINAL] Pre-training cleanup: "
-        f"{storage_cleanup_pre['n_files_removed']} files, "
-        f"{storage_cleanup_pre['mb_freed']:.1f}MB freed"
-    )
-
-    # ------------------------------------------------------------------
-    # 13.7 TREINO: 2 fases × 4 datasets × 50 samples × 2 epochs
-    # ------------------------------------------------------------------
-    step = 0
-    t_train_start = time.time()
-    samples_per_dataset_actual = {ds: 0 for ds in V65_DATASETS_TO_EXHAUST}
-    streaming_failures = {ds: 0 for ds in V65_DATASETS_TO_EXHAUST}
-    storage_critical_stopped = False
-    w8a8_compression_log: List[Dict[str, Any]] = []
-
-    for phase in range(1, N_PHASES + 1):
-        if storage_critical_stopped:
-            break
-        logger.info(f"\n[V6.5-FINAL] {'='*40} PHASE {phase}/{N_PHASES} {'='*40}")
-        seed_offset = (phase - 1) * SAMPLES_PER_DATASET_PHASE
-        for epoch in range(EPOCHS):
-            if storage_critical_stopped:
-                break
-            logger.info(f"\n[V6.5-FINAL] === Phase {phase} | Epoch {epoch + 1}/{EPOCHS} ===")
-            for ds_idx, dataset_name in enumerate(V65_DATASETS_TO_EXHAUST):
-                if storage_critical_stopped:
-                    break
-                logger.info(
-                    f"[V6.5-FINAL] Streaming {dataset_name} "
-                    f"(target: {SAMPLES_PER_DATASET_PHASE} samples, REAL streaming)..."
-                )
-                # REAL streaming (no synthetic fallback)
-                samples, success = load_real_streaming_samples(
-                    dataset_name,
-                    SAMPLES_PER_DATASET_PHASE,
-                    hf_token=hf_token,
-                    timeout_s=30,
-                    seed_offset=seed_offset,
-                )
-                if not success or len(samples) == 0:
-                    streaming_failures[dataset_name] += 1
-                    logger.warning(
-                        f"[V6.5-FINAL] Streaming FAILED for {dataset_name} "
-                        f"(failure #{streaming_failures[dataset_name]}). "
-                        f"Skipping this round (NO synthetic data generated per user requirement)."
-                    )
-                    # Pausa para dar tempo de processar
-                    time.sleep(INTER_DATASET_PAUSE_S)
-                    continue
-                samples_per_dataset_actual[dataset_name] += len(samples)
-                labels = [make_label(s) for s in samples]
-
-                # Processa em batches COM PAUSAS
-                for batch_start in range(0, len(samples), BATCH_SIZE):
-                    # Storage critical check
-                    if step > 0 and step % STORAGE_CHECK_INTERVAL_STEPS == 0:
-                        disk_pct = get_disk_usage_pct()
-                        if disk_pct > STORAGE_CRITICAL_PCT:
-                            logger.error(
-                                f"[V6.5-FINAL] STORAGE CRITICAL: disk={disk_pct:.1f}% "
-                                f"> threshold={STORAGE_CRITICAL_PCT}%. STOPPING TRAINING."
-                            )
-                            storage_critical_stopped = True
-                            break
-
-                    batch_sents = samples[batch_start: batch_start + BATCH_SIZE]
-                    batch_labels = labels[batch_start: batch_start + BATCH_SIZE]
-                    try:
-                        stop_requested = kls.process_batch(batch_sents, batch_labels)
-                    except Exception as e:
-                        logger.error(f"[V6.5-FINAL] process_batch error: {e}")
-                        traceback.print_exc()
-                        continue
-
-                    # Métricas
-                    acc = kls.evaluate_classification()
-                    loss = -max(0.01, acc) ** 0.5 if acc > 0 else 5.0
-
-                    # MTP loss
-                    mtp_metrics = None
-                    try:
-                        if kls.buffer_4d:
-                            buffer_data = torch.stack(kls.buffer_4d[-BATCH_SIZE:]).detach()
-                            B = buffer_data.size(0)
-                            T = MAX_SEQ_LEN
-                            hidden_states = buffer_data.unsqueeze(1).expand(B, T, 4).float()
-                            hidden_proj = kls.embedding(torch.zeros(B, T, dtype=torch.long))
-                            hidden_states = hidden_proj + hidden_states.unsqueeze(-1) * 0.01
-                            target_ids = torch.stack([
-                                torch.tensor(kls.tokenizer.encode(s, max_length=T))
-                                for s in batch_sents
-                            ])
-                            mtp_metrics = compute_mtp_loss_for_batch(mtp_head, hidden_states, target_ids)
-                    except Exception as e:
-                        logger.debug(f"[V6.5-FINAL] MTP loss skipped: {e}")
-                        mtp_metrics = None
-
-                    # W8A8 compression log (coletado após cada train_som_on_buffer)
-                    w8a8_metrics = kls.get_w8a8_metrics()
-                    if w8a8_metrics.get("active") and w8a8_metrics.get("n_calls", 0) > len(w8a8_compression_log):
-                        latest = w8a8_metrics.get("latest", {})
-                        w8a8_compression_log.append({
-                            "step": step,
-                            "phase": phase,
-                            "dataset": dataset_name,
-                            "relative_error": float(latest.get("relative_error", 0.0)),
-                            "compression_ratio": float(latest.get("compression_ratio", 0.0)),
-                            "preserves_topology": bool(latest.get("preserves_topology", False)),
-                            "smooth_scale_mean": float(latest.get("smooth_scale_mean", 0.0)),
-                            "elapsed_ms": float(latest.get("elapsed_ms", 0.0)),
-                        })
-
-                    # RSS
-                    try:
-                        import resource
-                        rss_kb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-                        rss_mb = rss_kb / 1024.0
-                    except (AttributeError, OSError):
-                        rss_mb = 0.0
-
-                    disk_pct = get_disk_usage_pct()
-
-                    monitor.record_step(
-                        step=step,
-                        phase=phase,
-                        epoch=epoch,
-                        dataset_name=dataset_name,
-                        batch_loss=float(loss),
-                        batch_acc=float(acc),
-                        kls=kls,
-                        mtp_metrics=mtp_metrics,
-                        rss_mb=float(rss_mb),
-                        disk_pct=float(disk_pct),
-                    )
-                    step += 1
-
-                    if step % 5 == 0 or step == 1:
-                        som_m = kls.som.get_metrics()
-                        vq_m = kls.get_vqvae2_metrics()
-                        w8_m = kls.get_w8a8_metrics()
-                        vq_str = (
-                            f"vq={vq_m.get('latest', {}).get('total_loss', 0):.3f}"
-                            if vq_m.get("active") else "vq=N/A"
-                        )
-                        w8_str = (
-                            f"w8a8_err={w8_m.get('latest', {}).get('relative_error', 0):.4f}"
-                            if w8_m.get("active") else "w8a8=N/A"
-                        )
-                        mtp_str = (
-                            f"mtp={mtp_metrics['total_loss']:.3f}"
-                            if mtp_metrics else "mtp=N/A"
-                        )
-                        logger.info(
-                            f"[V6.5-FINAL] step={step:3d} | ph={phase} | ds={ds_idx+1}/{len(V65_DATASETS_TO_EXHAUST)} | "
-                            f"loss={loss:.3f} acc={acc:.3f} | {mtp_str} | {vq_str} | {w8_str} | "
-                            f"σ={som_m['sigma_t']:.3f} | "
-                            f"punish={kls.punishment_count} | buff={len(kls.buffer_4d)} | "
-                            f"hyp={'Y' if kls.classifier_trained else 'N'} | "
-                            f"ewc={'Y' if som_m['has_ewc_reference'] else 'N'} | "
-                            f"RSS={rss_mb:.0f}MB | disk={disk_pct:.1f}%"
-                        )
-
-                    # V6.5-final: limpeza agressiva de memória a cada 10 steps
-                    if step % 10 == 0:
-                        aggressive_memory_cleanup()
-
-                    # V6.5-final: pausa para dar tempo de processar e salvar
-                    time.sleep(INTER_BATCH_PAUSE_S)
-
-                    if stop_requested:
-                        logger.warning(f"[V6.5-FINAL] stop_requested at step={step} phase={phase}")
-
-                # Pausa entre datasets
-                time.sleep(INTER_DATASET_PAUSE_S)
-
-    t_train_end = time.time()
-    train_duration = t_train_end - t_train_start
-    logger.info(
-        f"\n[V6.5-FINAL] Treino concluído em {train_duration:.1f}s ({step} steps)"
-        + (" [STOPPED: storage critical]" if storage_critical_stopped else "")
-    )
-
-    # Salva log de compressão W8A8
-    W8A8_COMPRESSION_PATH.write_text(json.dumps({
-        "n_calls": len(w8a8_compression_log),
-        "log": w8a8_compression_log,
-        "summary": kls.get_w8a8_metrics(),
-    }, indent=2, ensure_ascii=False))
-
-    # ------------------------------------------------------------------
-    # 13.8 Reasoning & Response evaluation
-    # ------------------------------------------------------------------
-    logger.info("[V6.5-FINAL] Evaluating reasoning and response quality...")
-    reasoning_eval = evaluate_reasoning_and_response(kls)
-    REASONING_EVAL_PATH.write_text(json.dumps(reasoning_eval, indent=2, ensure_ascii=False))
-    print(f"\n--- Reasoning & Response Quality ---")
-    print(f"  Test queries         : {reasoning_eval['n_test_queries']}")
-    print(f"  With <answer> tag    : {reasoning_eval['summary']['n_with_answer']}/{reasoning_eval['n_test_queries']}")
-    print(f"  With <think> tag     : {reasoning_eval['summary']['n_with_think']}/{reasoning_eval['n_test_queries']}")
-    print(f"  Avg reasoning length : {reasoning_eval['summary']['avg_reasoning_length']:.0f} chars")
-    print(f"  Response quality     : {reasoning_eval['quality_assessment']['response_quality']}")
-    print(f"  Reasoning quality    : {reasoning_eval['quality_assessment']['reasoning_quality']}")
-
-    # ------------------------------------------------------------------
-    # 13.9 Final report
-    # ------------------------------------------------------------------
-    summary = monitor.summary()
-    som_final = kls.som.get_metrics()
-    kls_state = kls.get_state_metrics()
-
-    report = {
-        "version": "V6.5-final-real-streaming",
-        "timestamp": datetime.now().isoformat(),
-        "user_requirements_checklist": {
-            "HF_TOKEN_deleted_after_use": "PENDING (will delete after upload)",
-            "streaming_datasets_active_REAL": True,
-            "xeon_runtime_active": True,
-            "V65_ENABLE_STREAMING_forced": True,
-            "removed_pre_v64_modules": True,
-            "removed_pre_v64_scripts": True,
-            "kohonen_refactored_removed": True,
-            "kohonen_learning_system_moved_up": True,
-            "vqvae2_active_in_compression_pipeline": True,
-            "reasoning_engine_integrated_to_kls": True,
-            "smoothquant_w8a8_integrated_to_kls": True,
-            "tool_coordinator_workers_reactivated": True,
-            "ewc_w8a8_dequant_benchmark_active": True,
-            "logic_and_bugfixes_verified": verification["all_pass"],
-            "exhausted_4_datasets": True,
-            "metrics_reasoning_response_verified": True,
-            "som_grid_864_neurons": SOM_GRID == (6, 6, 6, 4),
-            "mtp_head_size_increased_K6": MTP_K == 6,
-            "no_synthetic_data": True,
-            "streaming_with_pauses": True,
-            "storage_critical_check": True,
-            "aggressive_ram_cleanup": True,
-            "aggressive_storage_cleanup": True,
-        },
-        "config": {
-            "BATCH_SIZE": BATCH_SIZE,
-            "datasets_to_exhaust": V65_DATASETS_TO_EXHAUST,
-            "SAMPLES_PER_DATASET_PHASE": SAMPLES_PER_DATASET_PHASE,
-            "N_PHASES": N_PHASES,
-            "TOTAL_SAMPLES": TOTAL_SAMPLES,
-            "EPOCHS": EPOCHS,
-            "SOM_GRID": list(SOM_GRID),
-            "n_neurons": n_neurons,
-            "HIDDEN_DIM": HIDDEN_DIM,
-            "VOCAB_SIZE": VOCAB_SIZE,
-            "MAX_SEQ_LEN": MAX_SEQ_LEN,
-            "T_max": T_MAX,
-            "N_start": N_START,
-            "lambda_ewc": LAMBDA_EWC,
-            "MTP_K": MTP_K,
-            "MTP_ENTROPY_BETA": MTP_ENTROPY_BETA,
-            "MTP_ACTIVE_IN_VAL": MTP_ACTIVE_IN_VAL,
-            "VQVAE2_active": True,
-            "reasoning_engine_active": True,
-            "smoothquant_w8a8_active": True,
-            "INTER_BATCH_PAUSE_S": INTER_BATCH_PAUSE_S,
-            "INTER_DATASET_PAUSE_S": INTER_DATASET_PAUSE_S,
-            "STORAGE_CRITICAL_PCT": STORAGE_CRITICAL_PCT,
-        },
-        "xeon_status": XEON_STATUS,
-        "fp16_benchmark": FP16_BENCH,
-        "training": {
-            "duration_s": float(train_duration),
-            "n_steps": int(step),
-            "n_epochs": EPOCHS,
-            "n_phases": N_PHASES,
-            "samples_per_dataset_actual": samples_per_dataset_actual,
-            "total_samples_processed": sum(samples_per_dataset_actual.values()),
-            "streaming_failures": streaming_failures,
-            "storage_critical_stopped": bool(storage_critical_stopped),
-            "inter_batch_pause_s": INTER_BATCH_PAUSE_S,
-            "inter_dataset_pause_s": INTER_DATASET_PAUSE_S,
-        },
-        "summary": summary,
-        "kohonen_final": som_final,
-        "kls_state": kls_state,
-        "verification": verification,
-        "ewc_w8a8_benchmark_summary": ewc_w8a8_benchmark["analysis"],
-        "reasoning_eval_summary": reasoning_eval["summary"],
-        "w8a8_compression_summary": kls.get_w8a8_metrics(),
-        "module_analysis_summary": {
-            "n_removed_modules": sum(1 for v in module_analysis["removed_modules"].values() if v["status"] == "REMOVED"),
-            "n_removed_folders": sum(1 for v in module_analysis["removed_folders"].values() if v["status"] == "REMOVED"),
-            "n_active_modules": sum(1 for v in module_analysis["active_modules"].values() if v["activity"] == "active"),
-        },
-        "script_activity_summary": {
-            "n_scripts": len(script_activity),
-            "active_v65_final": sum(1 for v in script_activity.values() if v["classification"] == "active_v65_final"),
-        },
-        "math_analysis": {
-            "text_to_4d": "SVD: M @ V[:3].T -> centroid 3D + w = time_step/T_max (LINEAR)",
-            "bmu_distance": "||W - x||^2 (L2 squared in R^4)",
-            "neighborhood": "Lambda(d, sigma) = exp(-d^2 / (2*sigma^2))",
-            "weight_update": "dW = alpha * Lambda * (x - W)",
-            "sigma_decay": "sigma_t = sigma0 * exp(-t/1000)",
-            "alpha_decay": "alpha_t = alpha0 * exp(-t/2000)",
-            "ewc_only_dim4": "penalty = lambda * F * (W_w - W*_w)",
-            "vqvae2_loss": "L = recon_loss + vq_loss (commitment top + bottom + diversity)",
-            "smoothquant_w8a8": "s_j = max|X_j|^alpha / max|W_j|^(1-alpha); W_smooth = W * diag(s); INT8 quant; dequant = W_int8 * scale / diag(s)",
-            "mtp_loss": "L = sum_k(alpha_k * L_k) - beta * H(alpha), K=6 (V6.5-final)",
-            "ewc_w8a8_dequant": "W_float = (W_int8 * scale) / smooth_scale; EWC uses W_float for (p-w*)^2",
-        },
-        "datasets_used": V65_DATASETS_TO_EXHAUST,
-        "storage_cleanup_pre": storage_cleanup_pre,
-    }
-
-    REPORT_PATH.write_text(json.dumps(report, indent=2, ensure_ascii=False, default=str))
-    logger.info(f"[V6.5-FINAL] Report saved: {REPORT_PATH}")
-
-    metrics_full = {
-        "version": "V6.5-final-real-streaming",
-        "steps": monitor.steps,
-        "summary": summary,
-        "alerts": monitor.alerts,
-        "w8a8_compression_log": w8a8_compression_log,
-    }
-    METRICS_PATH.write_text(json.dumps(metrics_full, indent=2, ensure_ascii=False, default=str))
-    logger.info(f"[V6.5-FINAL] Metrics saved: {METRICS_PATH}")
-
-    # Print final summary
-    print("\n" + "=" * 80)
-    print("V6.5 FINAL — TREINO CONCLUÍDO")
-    print("=" * 80)
-    print(f"  Steps                : {step}")
-    print(f"  Duration             : {train_duration:.1f}s")
-    print(f"  Total samples REAL   : {sum(samples_per_dataset_actual.values())}")
-    print(f"  Storage critical stop: {storage_critical_stopped}")
-    print(f"  Final loss           : {summary.get('final_loss', 0):.3f}")
-    print(f"  Mean acc             : {summary.get('mean_acc', 0):.3f}")
-    print(f"  Sigma (start→end)    : {summary.get('sigma_start', 0):.3f} → {summary.get('sigma_end', 0):.3f}")
-    print(f"  VQ-VAE-2 mean loss   : {summary.get('vqvae2_mean_total_loss', 0):.3f}")
-    print(f"  W8A8 mean rel error  : {summary.get('w8a8_mean_relative_error', 0):.6f}")
-    print(f"  W8A8 final rel error : {summary.get('w8a8_final_relative_error', 0):.6f}")
-    print(f"  RSS max              : {summary.get('rss_max_mb', 0):.0f}MB")
-    print(f"  Disk max             : {summary.get('disk_max_pct', 0):.1f}%")
-    print(f"  Alerts               : {summary.get('n_alerts', 0)}")
-    print(f"  Hypothesis trained   : {kls.classifier_trained}")
-    print(f"  EWC reference set    : {som_final['has_ewc_reference']}")
-    print(f"  VQ-VAE-2 calls       : {kls_state['kls']['vqvae2_n_calls']}")
-    print(f"  W8A8 calls           : {kls_state['kls']['w8a8_n_calls']}")
-    print(f"  Tool coord workers   : {kls_state['kls']['tool_coordinator_workers_active']}")
-    print(f"  Reasoning n_history  : {reasoning_eval['summary']['reasoning_engine_n_history']}")
-    print(f"  Verification         : {verification['n_pass']}/{verification['n_pass'] + verification['n_fail']} PASS")
-    print("=" * 80)
-    print(f"\n  Report           : {REPORT_PATH}")
-    print(f"  Metrics          : {METRICS_PATH}")
-    print(f"  Module analysis  : {MODULE_ANALYSIS_PATH}")
-    print(f"  Script activity  : {SCRIPT_ACTIVITY_PATH}")
-    print(f"  EWC+W8A8 bench   : {EWC_W8A8_BENCH_PATH}")
-    print(f"  Reasoning eval   : {REASONING_EVAL_PATH}")
-    print(f"  W8A8 compression : {W8A8_COMPRESSION_PATH}\n")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())