Pin Rio v4 as standalone Modal module

Replace the v4 import wrapper with a standalone Modal module whose variant constants are pinned to v4. The wrapper approach let Modal execute the shared v3 module remotely, so the first attempt accepted v3-only teacher categories and wrote a partial teacher file to the v3 data volume.\n\nAdd a separate one-shot restore app that repopulates the v3 data volume from the published Hugging Face v3 dataset package. The runlog records the stopped app, the root cause, and the repair path so the failed attempt is auditable.

finetune/reports/minicpm5_vivamais_text_runlog.md

@@ -2495,3 +2495,32 @@ Because v4 intentionally drops the generic/WhatsApp bucket, the v4 acceptance
 gate keeps the dashboard requirements strict (average improvement, unknown
 failures no worse, leakage failures no worse) and treats generic PT-BR as a
 minimum sanity check instead of requiring an overall generic win.
+
+### Aborted v4 wrapper attempt
+
+```text
+run: https://modal.com/apps/marinaleitecabrera/main/ap-5Z9IbspvamaWKsCF1C6ePt
+status: stopped manually
+reason: the import-wrapper v4 launcher resolved the shared module as v3 remotely
+```
+
+The first v4 attempt was stopped during teacher generation after the logs showed
+v3-only categories such as `customer_service`, `whatsapp_style`, and `open_chat`
+being accepted. The cause was the small v4 wrapper setting `VIVAMAIS_TEXT_VARIANT`
+only in the local launcher module; Modal mounted and executed the shared v3
+module remotely, so the constants fell back to v3 and wrote a partial teacher
+file to the v3 data volume.
+
+Corrective action:
+
+- Replace the v4 wrapper with a standalone v4 module whose constants are pinned
+  to `TEXT_VARIANT = "v4"` and `IS_V4 = True`.
+- Restore the v3 data volume from the already-published HF dataset using a
+  separate one-shot app:
+
+```text
+script: modal/restore_vivamais_v3_dataset_volume.py
+app: vivamais-v3-dataset-volume-restore
+source dataset: marinarosa/minicpm5-vivamais-text-sft-v3
+target volume: minicpm5-vivamais-v3-rio-data
+```

modal/minicpm5_vivamais_v4_rio_pipeline.py

@@ -1,9 +1,1700 @@
-"""Ephemeral Modal launcher for the Viva Mais MiniCPM5 text v4 Rio run."""
+"""Ephemeral Modal pipeline for Viva Mais MiniCPM5 text v4 with Rio distillation."""
 
 from __future__ import annotations
 
+import json
 import os
+import re
+from pathlib import Path
+from typing import Any
 
-os.environ.setdefault("VIVAMAIS_TEXT_VARIANT", "v4")
+import modal
 
-from minicpm5_vivamais_v3_rio_pipeline import *  # noqa: F401,F403,E402
+TEXT_VARIANT = "v4"
+IS_V4 = True
+
+APP_NAME = "minicpm5-vivamais-v4-rio-safety" if IS_V4 else "minicpm5-vivamais-v3-rio"
+DATA_VOLUME_NAME = (
+    "minicpm5-vivamais-v4-rio-safety-data"
+    if IS_V4
+    else "minicpm5-vivamais-v3-rio-data"
+)
+RESULTS_VOLUME_NAME = (
+    "minicpm5-vivamais-v4-rio-safety-results"
+    if IS_V4
+    else "minicpm5-vivamais-v3-rio-results"
+)
+V1_MODEL = "marinarosa/minicpm5-1b-vivamais-v1"
+V3_MODEL_REPO = (
+    "marinarosa/minicpm5-1b-vivamais-v4"
+    if IS_V4
+    else "marinarosa/minicpm5-1b-vivamais-v3"
+)
+V3_GGUF_REPO = (
+    "marinarosa/minicpm5-1b-vivamais-v4-GGUF"
+    if IS_V4
+    else "marinarosa/minicpm5-1b-vivamais-v3-GGUF"
+)
+RIO_TEACHER_MODEL = "prefeitura-rio/Rio-3.1-Open-4B-Instruct"
+TRAIN_REMOTE = (
+    "/data/minicpm5_v4_rio_sft.jsonl"
+    if IS_V4
+    else "/data/minicpm5_v3_rio_sft.jsonl"
+)
+EVAL_REMOTE = "/data/vivamais_qa_eval.jsonl"
+TEACHER_REMOTE = (
+    "/data/teacher_distill_v4_rio.jsonl"
+    if IS_V4
+    else "/data/teacher_distill_v3_rio.jsonl"
+)
+LORA_DIR = "/data/text-v4-rio-lora-out" if IS_V4 else "/data/text-v3-rio-lora-out"
+MERGED_DIR = "/data/text-v4-rio-merged-out" if IS_V4 else "/data/text-v3-rio-merged-out"
+GGUF_DIR = "/data/text-v4-rio-gguf" if IS_V4 else "/data/text-v3-rio-gguf"
+DEFAULT_CONTEXT_LENGTH = 8192
+NO_THINKING_RESPONSE_PREFIX = "<|im_start|>assistant\n<think>\n\n</think>\n\n"
+DEFAULT_V3_ROWS = 4_000 if IS_V4 else 3_500
+DEFAULT_TEACHER_ROWS = 80 if IS_V4 else 140
+DEFAULT_TEACHER_SEED_LIMIT = 0
+DEFAULT_LEARNING_RATE = 1.0e-5 if IS_V4 else 1.2e-5
+DEFAULT_EPOCHS = 2.0 if IS_V4 else 1.2
+V3_MIN_DASHBOARD_DELTA = 0.03
+V3_MIN_GENERIC_SCORE = 0.55 if IS_V4 else 0.70
+DEFAULT_PUBLIC_WEIGHT = 0.0
+DEFAULT_GENERIC_WEIGHT = 0.0 if IS_V4 else 0.35
+DEFAULT_DOMAIN_WEIGHT = 0.38 if IS_V4 else 0.25
+DEFAULT_NEGATIVE_WEIGHT = 0.60 if IS_V4 else 0.36
+DEFAULT_DISTILL_WEIGHT = 0.02 if IS_V4 else 0.04
+DEFAULT_RUN_NAME = "v4_rio_001" if IS_V4 else "v3_rio_001"
+TRAIN_GPU = "A100" if IS_V4 else "A10G"
+GENERATION_GPU = "A100" if IS_V4 else "A10G"
+V4_TEACHER_CATEGORIES = {
+    "entity_isolation",
+    "grounded_qa",
+    "grounded_refusal",
+    "grounded_unknown",
+    "payment_math",
+    "summary_rewrite",
+    "summarization",
+    "travel_qa",
+}
+
+app = modal.App(APP_NAME)
+data_volume = modal.Volume.from_name(DATA_VOLUME_NAME, create_if_missing=True)
+results_volume = modal.Volume.from_name(RESULTS_VOLUME_NAME, create_if_missing=True)
+
+image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .apt_install("git", "cmake", "build-essential", "curl", "libcurl4-openssl-dev", "libssl-dev")
+    .pip_install(
+        "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git",
+        "trl",
+        "transformers>=4.51.0",
+        "datasets",
+        "accelerate",
+        "peft",
+        "huggingface_hub",
+        "sentencepiece",
+        "protobuf",
+        "bitsandbytes",
+    )
+    .add_local_file(
+        local_path="finetune/build_vivamais_qa_eval.py",
+        remote_path="/opt/vivamais/finetune/build_vivamais_qa_eval.py",
+    )
+    .add_local_file(
+        local_path="finetune/prepare_minicpm5_text_sft.py",
+        remote_path="/opt/vivamais/finetune/prepare_minicpm5_text_sft.py",
+    )
+    .add_local_file(
+        local_path="finetune/prepare_minicpm5_v2_distill_sft.py",
+        remote_path="/opt/vivamais/finetune/prepare_minicpm5_v2_distill_sft.py",
+    )
+    .add_local_file(
+        local_path="finetune/redact.py",
+        remote_path="/opt/vivamais/finetune/redact.py",
+    )
+    .add_local_file(
+        local_path="evals/vivamais_qa_scoring.py",
+        remote_path="/opt/vivamais/evals/vivamais_qa_scoring.py",
+    )
+    .add_local_file(
+        local_path="evals/ptbr_conversation_eval.py",
+        remote_path="/opt/vivamais/evals/ptbr_conversation_eval.py",
+    )
+    .add_local_dir(local_path="src", remote_path="/opt/vivamais/src")
+)
+
+inspect_image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install("pytest")
+    .add_local_file(
+        local_path="finetune/build_vivamais_qa_eval.py",
+        remote_path="/opt/vivamais/finetune/build_vivamais_qa_eval.py",
+    )
+    .add_local_file(
+        local_path="evals/vivamais_qa_scoring.py",
+        remote_path="/opt/vivamais/evals/vivamais_qa_scoring.py",
+    )
+    .add_local_file(
+        local_path="evals/ptbr_conversation_eval.py",
+        remote_path="/opt/vivamais/evals/ptbr_conversation_eval.py",
+    )
+    .add_local_file(
+        local_path="tests/unit/finetune/test_build_vivamais_qa_eval.py",
+        remote_path="/opt/vivamais/tests/unit/finetune/test_build_vivamais_qa_eval.py",
+    )
+    .add_local_file(
+        local_path="tests/unit/evals/test_vivamais_qa_scoring.py",
+        remote_path="/opt/vivamais/tests/unit/evals/test_vivamais_qa_scoring.py",
+    )
+    .add_local_file(
+        local_path="tests/unit/evals/test_ptbr_conversation_eval.py",
+        remote_path="/opt/vivamais/tests/unit/evals/test_ptbr_conversation_eval.py",
+    )
+    .add_local_dir(local_path="src", remote_path="/opt/vivamais/src")
+)
+
+
+def _ensure_paths() -> None:
+    import sys
+
+    for path in (
+        "/opt/vivamais",
+        "/opt/vivamais/src",
+        "/opt/vivamais/finetune",
+        "/opt/vivamais/evals",
+    ):
+        if path not in sys.path:
+            sys.path.insert(0, path)
+
+
+def _load_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    if not path.is_file():
+        return rows
+    with path.open(encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                row = json.loads(line)
+                if isinstance(row, dict):
+                    rows.append(row)
+    return rows
+
+
+def _write_jsonl(path: Path, row: dict[str, Any]) -> None:
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def _preview(text: str, limit: int = 500) -> str:
+    text = text.strip()
+    if len(text) <= limit:
+        return text
+    return f"{text[:limit].rstrip()}..."
+
+
+ACCENT_REPLACEMENTS = (
+    (r"\b[Nn]ao\b", "não"),
+    (r"\b[Nn]a\b", "na"),
+    (r"\binformacao\b", "informação"),
+    (r"\binformacoes\b", "informações"),
+    (r"\borcamento\b", "orçamento"),
+    (r"\btransacao\b", "transação"),
+    (r"\btransacoes\b", "transações"),
+    (r"\bcartao\b", "cartão"),
+    (r"\bcodigo\b", "código"),
+    (r"\bportao\b", "portão"),
+    (r"\baereo\b", "aéreo"),
+    (r"\baerea\b", "aérea"),
+    (r"\bate\b", "até"),
+    (r"\bvoce\b", "você"),
+)
+
+ACCENTLESS_MARKERS = (
+    " nao",
+    "nao ",
+    "informacao",
+    "informacoes",
+    "orcamento",
+    "transacao",
+    "transacoes",
+    "cartao",
+    "codigo",
+    "portao",
+)
+
+INSTRUCTION_ECHO_PREFIXES = (
+    "avise ",
+    "avise que",
+    "confirme ",
+    "diga ",
+    "diga que",
+    "escreva ",
+    "explique ",
+    "informe ",
+    "peça ",
+    "peca ",
+    "pergunte ",
+    "responda ",
+    "resposta:",
+)
+
+
+def _normalize_ptbr_accents(text: str) -> str:
+    normalized = text
+    for pattern, replacement in ACCENT_REPLACEMENTS:
+        normalized = re.sub(pattern, replacement, normalized, flags=re.IGNORECASE)
+    return normalized
+
+
+def _configure_tokenizer_for_generation(tokenizer: Any, model: Any | None = None) -> None:
+    if getattr(tokenizer, "pad_token_id", None) is None:
+        tokenizer.pad_token = getattr(tokenizer, "eos_token", None)
+    pad_token_id = getattr(tokenizer, "pad_token_id", None)
+    if model is None or pad_token_id is None:
+        return
+    if getattr(model, "config", None) is not None:
+        model.config.pad_token_id = pad_token_id
+    if getattr(model, "generation_config", None) is not None:
+        model.generation_config.pad_token_id = pad_token_id
+
+
+@app.function(image=inspect_image, timeout=10 * 60, cpu=2, memory=4096)
+def inspect_eval_suites() -> dict[str, Any]:
+    from collections import Counter
+
+    _ensure_paths()
+    from build_vivamais_qa_eval import build_eval_cases
+    from ptbr_conversation_eval import GENERIC_EVAL_CASES
+    from vivamais_qa_scoring import score_case
+
+    dashboard_cases = build_eval_cases()
+    dashboard_ids = [str(case["id"]) for case in dashboard_cases]
+    generic_ids = [str(case["id"]) for case in GENERIC_EVAL_CASES]
+    unknown_probe = score_case(
+        {
+            "id": "unknown_probe",
+            "category": "not_enough_information",
+            "answer_type": "unknown",
+            "expected_answer": "Não há informação suficiente no contexto.",
+            "expected_contains": [],
+            "forbidden": ["[HOTEL_1]"],
+        },
+        "Não consta hospedagem no contexto informado.",
+    )
+    summary = {
+        "dashboard_cases": len(dashboard_cases),
+        "dashboard_categories": dict(Counter(str(case["category"]) for case in dashboard_cases)),
+        "dashboard_long_context_cases": sum(1 for case in dashboard_cases if case["long_context"]),
+        "dashboard_duplicate_ids": len(dashboard_ids) - len(set(dashboard_ids)),
+        "generic_cases": len(GENERIC_EVAL_CASES),
+        "generic_categories": dict(Counter(str(case["category"]) for case in GENERIC_EVAL_CASES)),
+        "generic_duplicate_ids": len(generic_ids) - len(set(generic_ids)),
+        "unknown_probe_passed": bool(unknown_probe["passed"]),
+    }
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    return summary
+
+
+@app.function(image=inspect_image, timeout=10 * 60, cpu=2, memory=4096)
+def run_eval_unit_subset() -> dict[str, Any]:
+    import os
+    import subprocess
+
+    env = os.environ.copy()
+    env["PYTHONPATH"] = "/opt/vivamais:/opt/vivamais/src:/opt/vivamais/evals"
+    command = [
+        "python",
+        "-m",
+        "pytest",
+        "/opt/vivamais/tests/unit/finetune/test_build_vivamais_qa_eval.py",
+        "/opt/vivamais/tests/unit/evals/test_vivamais_qa_scoring.py",
+        "/opt/vivamais/tests/unit/evals/test_ptbr_conversation_eval.py",
+    ]
+    completed = subprocess.run(command, capture_output=True, text=True, env=env, check=False)
+    if completed.stdout:
+        print(completed.stdout)
+    if completed.stderr:
+        print(completed.stderr)
+    if completed.returncode != 0:
+        raise RuntimeError(f"Eval unit subset failed with exit code {completed.returncode}")
+    return {"command": command, "returncode": completed.returncode}
+
+
+CURATED_TEACHER_PROMPTS = (
+    (
+        "open_chat",
+        "Escreva uma legenda curta e natural para Instagram sobre uma viagem em família.",
+    ),
+    (
+        "customer_service",
+        (
+            "Responda com educação: o cliente achou o pacote caro e pediu uma "
+            "alternativa mais barata."
+        ),
+    ),
+    (
+        "travel_qa",
+        "Explique a diferença entre bagagem de mão, item pessoal e bagagem despachada.",
+    ),
+    (
+        "travel_qa",
+        "Quando vale a pena contratar seguro viagem? Responda de forma simples.",
+    ),
+    (
+        "summarization",
+        (
+            "Resuma em duas frases: cliente quer viajar em julho, prefere praia, "
+            "tem duas crianças e quer parcelar."
+        ),
+    ),
+    (
+        "grounded_qa",
+        "Contexto: Total R$3.000,00. Pago R$1.250,00. Pergunta: Quanto falta pagar?",
+    ),
+    (
+        "grounded_qa",
+        "Contexto: Reserva LA 3456 em 12/07 às 08:30, assento 12A. Pergunta: Qual é o assento?",
+    ),
+    (
+        "grounded_unknown",
+        (
+            "Contexto: A reserva informa voo LA 3456 e pagamento de R$1.250,00. "
+            "Pergunta: Qual é o hotel?"
+        ),
+    ),
+    (
+        "whatsapp_style",
+        "Transforme em uma mensagem curta de WhatsApp: precisamos do RG para emitir os bilhetes.",
+    ),
+    (
+        "informal_ptbr",
+        "O cliente escreveu 'tá caro demais'. Responda de forma profissional e natural.",
+    ),
+)
+
+
+def _synthetic_vivamais_teacher_prompts() -> list[tuple[str, str]]:
+    prompts: list[tuple[str, str]] = []
+    balances = (
+        ("R$3.000,00", "R$1.250,00"),
+        ("R$4.800,00", "R$1.950,00"),
+        ("R$2.200,00", "R$2.200,00"),
+        ("R$5.400,00", "R$2.100,00"),
+        ("R$980,00", "R$300,00"),
+        ("R$3.600,00", "R$900,00"),
+        ("R$1.870,00", "R$870,00"),
+        ("R$6.250,00", "R$2.500,00"),
+    )
+    for total, paid in balances:
+        prompts.append(
+            (
+                f"Contexto: total {total}; pago {paid}. Pergunta: quanto falta pagar?",
+                "payment_math",
+            )
+        )
+        prompts.append(
+            (
+                f"Escreva uma resposta curta de WhatsApp avisando que já entrou {paid} "
+                f"de um pacote de {total}.",
+                "whatsapp_payment",
+            )
+        )
+
+    missing_fields = (
+        ("hotel", "voo LA 3456 e pagamento de R$1.250,00"),
+        ("assento", "localizador ABC123 e data 12/07"),
+        ("bagagem despachada", "valor R$2.700,00 e prazo até sexta"),
+        ("validade do orçamento", "destino Recife e total R$4.800,00"),
+        ("pagamento", "cliente pediu cotação, mas não enviou comprovante"),
+        ("documento do acompanhante", "passageiro titular enviou RG"),
+    )
+    for field, context in missing_fields:
+        prompts.append(
+            (
+                f"Contexto: {context}. Pergunta: qual é {field}? Responda sem inventar.",
+                "grounded_refusal",
+            )
+        )
+        prompts.append(
+            (
+                f"Reescreva de forma natural: não consta no contexto a informação sobre {field}.",
+                "grounded_refusal",
+            )
+        )
+
+    customer_prompts = (
+        "O cliente disse: 'tá caro demais'. Responda de forma curta e profissional.",
+        "O cliente pediu uma opção mais barata. Responda com empatia e proponha revisar datas.",
+        "Peça o RG do acompanhante de forma natural para WhatsApp.",
+        "Avise que a companhia ainda não confirmou a emissão e que você vai acompanhar.",
+        "Ofereça seguro viagem de forma consultiva, sem dizer que é obrigatório.",
+        "Peça flexibilidade de datas em uma frase curta.",
+        "Faça follow-up perguntando se o cliente conseguiu olhar a proposta.",
+        "Avise que a tarifa pode mudar sem soar alarmista.",
+        "Peça desculpas pelo atraso na resposta e retome o atendimento.",
+        "Pergunte destino, datas e quantidade de passageiros para iniciar uma cotação.",
+    )
+    prompts.extend(
+        (
+            f"Responda somente com a mensagem final para WhatsApp: {prompt}",
+            "customer_service",
+        )
+        for prompt in customer_prompts
+    )
+
+    travel_prompts = (
+        "Explique em poucas frases a diferença entre bagagem de mão e bagagem despachada.",
+        "Quando normalmente abre o check-in online de voo doméstico?",
+        "O que significa conexão em um voo?",
+        "Para que serve o localizador da reserva?",
+        "Qual é a diferença entre check-in e check-out no hotel?",
+        "O que o seguro viagem costuma cobrir? Responda de forma simples.",
+        "Como explicar franquia de bagagem para um cliente leigo?",
+        "O que o cliente precisa conferir antes da emissão da passagem?",
+        "Explique por que tarifa aérea pode mudar antes da emissão.",
+        "Diga quando faz sentido reservar hotel próximo ao aeroporto.",
+    )
+    prompts.extend(
+        (f"Responda em até duas frases, sem lista: {prompt}", "travel_qa")
+        for prompt in travel_prompts
+    )
+
+    entity_cases = (
+        (
+            "[CLIENTE_A] tem voo AD 2210, localizador AAA111 e embarque 14/09.",
+            "[CLIENTE_B] tem voo LA 9090, localizador BBB222 e embarque 20/10.",
+            "[CLIENTE_A]",
+            "qual é o localizador?",
+        ),
+        (
+            "[CLIENTE_A] pagou R$1.200,00 e ainda falta R$800,00.",
+            "[CLIENTE_B] pagou R$900,00 e ainda falta R$1.100,00.",
+            "[CLIENTE_B]",
+            "quanto falta pagar?",
+        ),
+        (
+            "[CLIENTE_A] já enviou RG e comprovante.",
+            "[CLIENTE_B] enviou apenas o RG.",
+            "[CLIENTE_B]",
+            "qual documento ainda falta?",
+        ),
+        (
+            "[CLIENTE_A] viaja para Recife em 08/08 com hotel confirmado.",
+            "[CLIENTE_B] viaja para Salvador em 19/08 e aguarda hotel.",
+            "[CLIENTE_A]",
+            "qual é o destino?",
+        ),
+        (
+            "[CLIENTE_A] tem assento 12A e bagagem despachada inclusa.",
+            "[CLIENTE_B] tem assento 18C e apenas bagagem de mão.",
+            "[CLIENTE_B]",
+            "qual é o assento?",
+        ),
+        (
+            "[CLIENTE_A] recebeu orçamento válido até 18:00.",
+            "[CLIENTE_B] recebeu orçamento válido até 21:00.",
+            "[CLIENTE_A]",
+            "até que hora vale o orçamento?",
+        ),
+        (
+            "[CLIENTE_A] pediu seguro viagem e traslado.",
+            "[CLIENTE_B] recusou seguro viagem e pediu só hospedagem.",
+            "[CLIENTE_A]",
+            "quais extras foram solicitados?",
+        ),
+        (
+            "[CLIENTE_A] tem reserva no [HOTEL_1].",
+            "[CLIENTE_B] tem reserva no [HOTEL_2].",
+            "[CLIENTE_B]",
+            "qual hotel está reservado?",
+        ),
+        (
+            "[CLIENTE_A] parcelou em 6 vezes sem entrada.",
+            "[CLIENTE_B] deu entrada de R$500,00 e parcelou o restante.",
+            "[CLIENTE_B]",
+            "qual foi a entrada?",
+        ),
+        (
+            "[CLIENTE_A] está em cotação.",
+            "[CLIENTE_B] está aguardando emissão.",
+            "[CLIENTE_A]",
+            "em que etapa está o atendimento?",
+        ),
+        (
+            "[CLIENTE_A] vai embarcar no aeroporto SDU.",
+            "[CLIENTE_B] vai embarcar no aeroporto GIG.",
+            "[CLIENTE_B]",
+            "qual é o aeroporto de embarque?",
+        ),
+        (
+            "[CLIENTE_A] confirmou duas crianças.",
+            "[CLIENTE_B] confirmou um adulto e uma criança.",
+            "[CLIENTE_A]",
+            "quantas crianças foram confirmadas?",
+        ),
+        (
+            "[CLIENTE_A] pediu quarto triplo.",
+            "[CLIENTE_B] pediu quarto duplo.",
+            "[CLIENTE_A]",
+            "qual tipo de quarto foi pedido?",
+        ),
+        (
+            "[CLIENTE_A] precisa enviar CPF.",
+            "[CLIENTE_B] precisa enviar comprovante de residência.",
+            "[CLIENTE_B]",
+            "o que ainda precisa enviar?",
+        ),
+        (
+            "[CLIENTE_A] vai retornar em 25/11.",
+            "[CLIENTE_B] vai retornar em 28/11.",
+            "[CLIENTE_A]",
+            "qual é a data de retorno?",
+        ),
+        (
+            "[CLIENTE_A] aprovou a proposta de R$3.400,00.",
+            "[CLIENTE_B] ainda está comparando proposta de R$2.900,00.",
+            "[CLIENTE_A]",
+            "qual proposta foi aprovada?",
+        ),
+        (
+            "[CLIENTE_A] solicitou nota fiscal.",
+            "[CLIENTE_B] solicitou recibo simples.",
+            "[CLIENTE_B]",
+            "qual comprovante foi solicitado?",
+        ),
+        (
+            "[CLIENTE_A] vai levar bebê de colo.",
+            "[CLIENTE_B] vai viajar sem criança.",
+            "[CLIENTE_A]",
+            "há bebê de colo?",
+        ),
+    )
+    for first, second, client, question in entity_cases:
+        prompts.append(
+            (
+                f"Contexto: {first} {second} Pergunta: sobre {client}, {question}",
+                "entity_isolation",
+            )
+        )
+
+    summary_cases = (
+        "cliente quer viajar em setembro, prefere praia, pediu parcelamento e falta RG",
+        "família de quatro pessoas quer Natal, precisa de hotel com café e traslado",
+        "casal pediu lua de mel em Gramado, orçamento alto e datas flexíveis",
+        "cliente aprovou voo, falta escolher hotel e enviar comprovante",
+        "passageira pediu remarcação, informou doença e aguarda regras da tarifa",
+        "grupo quer Buenos Aires, pediu bagagem despachada e pagamento no cartão",
+        "cliente quer economizar, aceita voo com conexão e hotel simples",
+        "cliente pediu pacote para Porto Seguro, duas crianças e saída em julho",
+        "cliente enviou comprovante, falta validar valor e confirmar emissão",
+        "cliente perguntou seguro viagem, bagagem e possibilidade de parcelar",
+        "cliente recusou primeira proposta e pediu opção com datas alternativas",
+        "cliente confirmou dados dos passageiros, mas falta documento do bebê",
+        "cliente quer viajar no feriado, prefere voo direto e hotel perto da praia",
+        "cliente pediu cancelamento, quer saber multa e prazo de reembolso",
+        "cliente recebeu orçamento, achou caro e pediu algo até R$3.000,00",
+        "cliente quer réveillon, não definiu destino e informou orçamento aberto",
+        "cliente pediu recibo, nota fiscal e confirmação do valor pago",
+        "cliente perguntou se o pacote inclui ingresso, traslado e café da manhã",
+    )
+    for details in summary_cases:
+        prompts.append(
+            (
+                f"Resuma em dois bullets para uma agente de viagens: {details}.",
+                "summary_rewrite",
+            )
+        )
+
+    service_prompts = (
+        "Responda ao cliente que pediu desconto, mantendo tom humano e sem prometer valor.",
+        "Avise que você vai conferir disponibilidade antes de confirmar a tarifa.",
+        "Peça os dados completos dos passageiros para emissão em uma mensagem curta.",
+        "Diga que a proposta foi atualizada com uma opção mais econômica.",
+        "Explique que a reserva só fica garantida depois da emissão.",
+        "Pergunte se o cliente prefere voo direto ou aceita conexão para economizar.",
+        "Avise que recebeu o comprovante e vai conferir com o financeiro.",
+        "Informe que falta apenas o documento do acompanhante para seguir.",
+        "Diga que encontrou uma opção com hotel melhor, mas valor mais alto.",
+        "Peça autorização final antes de emitir a passagem.",
+        "Responda a um cliente ansioso sem inventar prazo da companhia.",
+        "Avise que vai mandar duas opções: uma econômica e uma mais confortável.",
+        "Explique que parcelamento pode depender da forma de pagamento.",
+        "Confirme que os nomes precisam estar iguais aos documentos.",
+        "Peça desculpas pelo atraso e retome a conversa com a próxima ação.",
+        "Diga que a tarifa mudou e ofereça revisar datas para baixar o valor.",
+        "Pergunte se o cliente deseja incluir bagagem despachada.",
+        "Avise que o hotel solicitado não tem disponibilidade nas datas.",
+        "Confirme que vai salvar o orçamento e acompanhar a decisão do cliente.",
+        "Diga que precisa do comprovante legível para conciliar o pagamento.",
+    )
+    prompts.extend(
+        (
+            f"Responda somente com a mensagem final para WhatsApp: {prompt}",
+            "customer_service",
+        )
+        for prompt in service_prompts
+    )
+
+    workflow_prompts = (
+        "Escreva uma mensagem curta pedindo confirmação dos nomes antes da emissão.",
+        "Escreva uma mensagem curta avisando que a cotação vence hoje às 18:00.",
+        "Escreva uma resposta natural para cliente que perguntou se pode parcelar.",
+        "Escreva uma resposta curta dizendo que o comprovante ficou ilegível.",
+        "Escreva uma mensagem pedindo o CPF sem expor dados sensíveis.",
+        "Escreva uma resposta explicando que a tarifa depende de disponibilidade.",
+        "Escreva uma mensagem avisando que falta escolher o horário do voo.",
+        "Escreva uma resposta para cliente que pediu hotel com café da manhã.",
+        "Escreva uma mensagem confirmando recebimento do RG do passageiro.",
+        "Escreva uma resposta dizendo que você vai conferir regras de remarcação.",
+        "Escreva uma mensagem avisando que a opção mais barata tem conexão.",
+        "Escreva uma resposta explicando que voo direto ficou mais caro.",
+        "Escreva uma mensagem curta pedindo autorização para emitir.",
+        "Escreva uma resposta dizendo que o seguro viagem é opcional.",
+        "Escreva uma mensagem pedindo o comprovante de pagamento.",
+        "Escreva uma resposta para cliente que ainda não decidiu o destino.",
+        "Escreva uma mensagem oferecendo revisar as datas para reduzir o preço.",
+        "Escreva uma resposta dizendo que a hospedagem ainda não foi confirmada.",
+        "Escreva uma mensagem curta avisando que o pagamento foi localizado.",
+        "Escreva uma resposta explicando que crianças precisam de documento.",
+        "Escreva uma mensagem pedindo confirmação de ida e volta.",
+        "Escreva uma resposta dizendo que bagagem despachada muda o valor.",
+        "Escreva uma mensagem informando que a reserva está aguardando pagamento.",
+        "Escreva uma resposta educada para cliente que pediu retorno urgente.",
+        "Escreva uma mensagem dizendo que vai enviar duas alternativas de hotel.",
+        "Escreva uma resposta para cliente que pediu recibo após pagar.",
+        "Escreva uma mensagem curta pedindo telefone de contato atualizado.",
+        "Escreva uma resposta dizendo que a emissão depende da aprovação final.",
+        "Escreva uma mensagem avisando que o orçamento foi salvo no atendimento.",
+        "Escreva uma resposta para cliente que quer incluir mais um passageiro.",
+    )
+    prompts.extend(
+        (
+            f"Responda somente com a mensagem final para WhatsApp: {prompt}",
+            "whatsapp_style",
+        )
+        for prompt in workflow_prompts
+    )
+
+    grounded_cases = (
+        ("Total R$3.400,00; pago R$1.000,00.", "quanto falta pagar?"),
+        ("Total R$5.200,00; pago R$5.200,00.", "a viagem está quitada?"),
+        ("Reserva informa voo AD 2210 e localizador VMA123.", "qual é o voo?"),
+        ("Reserva informa voo AD 2210 e localizador VMA123.", "qual é o hotel?"),
+        ("Cotação válida até 14/06 às 18:00.", "até quando vale?"),
+        ("Cotação válida até 14/06 às 18:00.", "qual é a política de cancelamento?"),
+        ("Passageira Ana enviou RG; Bruno ainda não enviou documento.", "quem está pendente?"),
+        ("Pagamento recebido em PIX no valor de R$870,00.", "qual foi a forma de pagamento?"),
+        ("Cliente pediu Recife, julho, duas crianças.", "qual é o destino?"),
+        ("Cliente pediu Recife, julho, duas crianças.", "qual é o número do voo?"),
+        ("Hotel confirmado com café da manhã, sem traslado.", "inclui traslado?"),
+        ("Pacote inclui bagagem de mão e item pessoal.", "inclui bagagem despachada?"),
+        ("Localizador ABC123, assento 12A, embarque 08:30.", "qual é o assento?"),
+        ("Orçamento de R$2.980,00 em até 6 vezes.", "qual é o valor total?"),
+        ("Cliente recusou seguro viagem e pediu só passagem.", "inclui seguro viagem?"),
+        ("Cliente aprovou emissão após confirmar nomes.", "qual é a próxima etapa?"),
+        ("Falta enviar CPF do acompanhante.", "qual documento está pendente?"),
+        ("A tarifa mudou de R$2.400,00 para R$2.650,00.", "qual é o novo valor?"),
+        ("Cliente quer voo direto, mas só há opção com conexão.", "há voo direto?"),
+        ("Pagamento de entrada venceu ontem e não há comprovante.", "o pagamento foi confirmado?"),
+    )
+    for context, question in grounded_cases:
+        prompts.append(
+            (
+                f"Contexto: {context} Pergunta: {question} Responda sem inventar.",
+                "grounded_qa",
+            )
+        )
+    return prompts
+
+
+def _collect_gigaverbo_prompts(*, limit: int, seed: int) -> list[tuple[str, str]]:
+    from datasets import load_dataset
+
+    subsets = ("general", "retrieval", "summarization", "rewriting", "system_prompts")
+    rng = __import__("random").Random(seed)
+    prompts: list[tuple[str, str]] = []
+    per_subset = max(1, limit // len(subsets))
+    for subset in subsets:
+        if len(prompts) >= limit:
+            break
+        try:
+            ds = load_dataset("Polygl0t/gigaverbo-v2-sft", subset, split="train", streaming=True)
+        except Exception as exc:
+            print(f"Skipping GigaVerbo subset {subset}: {exc}")
+            continue
+        seen = 0
+        for row in ds:
+            messages = row.get("messages")
+            if not isinstance(messages, list):
+                continue
+            users = [
+                str(message.get("content", "")).strip()
+                for message in messages
+                if isinstance(message, dict)
+                and message.get("role") == "user"
+                and str(message.get("content", "")).strip()
+            ]
+            if not users:
+                continue
+            if rng.random() < 0.35:
+                prompts.append((users[-1], f"gigaverbo_{subset}"))
+                seen += 1
+            if seen >= per_subset or len(prompts) >= limit:
+                break
+    return prompts[:limit]
+
+
+def _teacher_prompt_pool(*, gigaverbo_limit: int, seed: int) -> list[tuple[str, str]]:
+    prompts = [(prompt, category) for category, prompt in CURATED_TEACHER_PROMPTS]
+    prompts.extend(_synthetic_vivamais_teacher_prompts())
+    if gigaverbo_limit > 0:
+        prompts.extend(_collect_gigaverbo_prompts(limit=gigaverbo_limit, seed=seed))
+    if IS_V4:
+        prompts = [
+            (prompt, category)
+            for prompt, category in prompts
+            if category in V4_TEACHER_CATEGORIES
+        ]
+    return prompts
+
+
+def _teacher_system_prompt() -> str:
+    if IS_V4:
+        return (
+            "Você é a assistente de atendimento da Viva Mais. Responda somente com a "
+            "resposta final, em português brasileiro natural e com acentos. Não copie "
+            "nem transforme a instrução do usuário em uma frase como 'Avise que', "
+            "'Pergunte', 'Peça', 'Diga' ou 'Escreva'. Não use preâmbulos como "
+            "'Claro' ou 'Aqui está'. Quando houver contexto, use apenas o contexto; "
+            "se a informação não aparecer, diga que não consta no contexto e não use "
+            "dados de outro cliente."
+        )
+    return (
+        "Você é a assistente de atendimento da Viva Mais. Responda de forma "
+        "direta, natural e objetiva em português brasileiro. Não use preâmbulos "
+        "como 'Claro, aqui está'. Quando a pergunta trouxer contexto, use apenas "
+        "esse contexto e diga quando a informação não estiver presente. Entregue "
+        "somente a resposta final, sem explicar estratégia, critérios ou rótulos "
+        "como 'Resposta:'."
+    )
+
+
+def _usable_teacher_answer(text: str) -> bool:
+    cleaned = text.strip()
+    lowered = cleaned.lower()
+    if not cleaned or len(cleaned) > 800:
+        return False
+    if IS_V4 and lowered.startswith(INSTRUCTION_ECHO_PREFIXES):
+        return False
+    if IS_V4 and any(marker in lowered for marker in ACCENTLESS_MARKERS):
+        return False
+    if lowered.startswith(("claro:", "claro.", "claro,", "claro!", "vai ", "pode ser que")):
+        return False
+    blocked = (
+        "<think",
+        "</think",
+        "```",
+        "###",
+        "---",
+        "**",
+        "😊",
+        "✈",
+        "claro! aqui",
+        "aqui está",
+        "aqui vai",
+        "posso adaptar",
+        "se quiser",
+        "como se fosse",
+        "vamos ",
+        "por exemplo:",
+        "a pergunta pede",
+        "a frase original",
+        "a melhor resposta",
+        "a resposta deve",
+        "contexto fornecido",
+        "não há evidência",
+        "o contexto indica",
+        "por favor, forneça",
+        "resposta:",
+        "[seu nome]",
+        "[nome da agência]",
+    )
+    return not any(marker in lowered for marker in blocked)
+
+
+def _normalize_assistant_accents_in_jsonl(path: Path) -> int:
+    if not IS_V4:
+        return 0
+    rows = _load_jsonl(path)
+    changed = 0
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            messages = row.get("messages")
+            if isinstance(messages, list):
+                for message in messages:
+                    if (
+                        not isinstance(message, dict)
+                        or message.get("role") != "assistant"
+                    ):
+                        continue
+                    content = str(message.get("content", ""))
+                    normalized = _normalize_ptbr_accents(content)
+                    if normalized != content:
+                        message["content"] = normalized
+                        changed += 1
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+    return changed
+
+
+@app.function(
+    gpu=GENERATION_GPU,
+    image=image,
+    volumes={"/data": data_volume},
+    timeout=8 * 3600,
+)
+def distill_teacher_rows(
+    *,
+    teacher_model: str = RIO_TEACHER_MODEL,
+    output_path: str = TEACHER_REMOTE,
+    target_rows: int = DEFAULT_TEACHER_ROWS,
+    gigaverbo_seed_limit: int = DEFAULT_TEACHER_SEED_LIMIT,
+    seed: int = 42,
+    max_new_tokens: int = 220,
+) -> dict[str, Any]:
+    import random
+
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+    _ensure_paths()
+    tokenizer = AutoTokenizer.from_pretrained(teacher_model, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        teacher_model,
+        trust_remote_code=True,
+        quantization_config=BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+        ),
+        device_map={"": 0},
+    )
+    _configure_tokenizer_for_generation(tokenizer, model)
+    model.eval()
+    prompts = _teacher_prompt_pool(gigaverbo_limit=gigaverbo_seed_limit, seed=seed)
+    random.Random(seed).shuffle(prompts)
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("", encoding="utf-8")
+    rows: list[dict[str, Any]] = []
+    rejected = 0
+    for user_prompt, category in prompts:
+        if len(rows) >= target_rows:
+            break
+        messages = [
+            {
+                "role": "system",
+                "content": _teacher_system_prompt(),
+            },
+            {"role": "user", "content": user_prompt},
+        ]
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+        inputs = tokenizer(text, return_tensors="pt").to(model.device)
+        with torch.no_grad():
+            output_ids = model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                do_sample=False,
+                pad_token_id=tokenizer.pad_token_id,
+            )
+        answer = tokenizer.decode(
+            output_ids[0][inputs["input_ids"].shape[1] :],
+            skip_special_tokens=True,
+        ).strip()
+        if IS_V4:
+            answer = _normalize_ptbr_accents(answer)
+        accepted = _usable_teacher_answer(answer)
+        print(
+            json.dumps(
+                {
+                    "event": "teacher_output",
+                    "category": category,
+                    "accepted": accepted,
+                    "accepted_count": len(rows),
+                    "rejected_count": rejected,
+                    "prompt_preview": _preview(user_prompt, 240),
+                    "answer_preview": _preview(answer, 500),
+                },
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+        if not accepted:
+            rejected += 1
+            continue
+        row = {
+            "messages": [
+                {"role": "user", "content": user_prompt},
+                {"role": "assistant", "content": answer},
+            ],
+            "source": "rio31_teacher_distill",
+            "seed_category": category,
+            "teacher_model": teacher_model,
+        }
+        rows.append(row)
+        _write_jsonl(output, row)
+        data_volume.commit()
+    data_volume.commit()
+    stats = {
+        "teacher_model": teacher_model,
+        "rows": len(rows),
+        "rejected": rejected,
+        "output": output_path,
+        "target_rows": target_rows,
+    }
+    print(json.dumps(stats, indent=2, ensure_ascii=False))
+    return stats
+
+
+@app.function(image=image, volumes={"/data": data_volume}, timeout=4 * 3600, cpu=4, memory=16384)
+def prepare_v3_dataset(
+    *,
+    total_limit: int = DEFAULT_V3_ROWS,
+    seed: int = 42,
+    teacher_rows_path: str = TEACHER_REMOTE,
+    public_weight: float = DEFAULT_PUBLIC_WEIGHT,
+    distill_weight: float = DEFAULT_DISTILL_WEIGHT,
+    domain_weight: float = DEFAULT_DOMAIN_WEIGHT,
+    travel_weight: float = 0.0,
+    negative_weight: float = DEFAULT_NEGATIVE_WEIGHT,
+    generic_weight: float = DEFAULT_GENERIC_WEIGHT,
+) -> dict[str, Any]:
+    _ensure_paths()
+    from prepare_minicpm5_v2_distill_sft import (
+        DISTILL_BUCKET,
+        GENERIC_BUCKET,
+        prepare_minicpm5_v2_distill_sft,
+    )
+    from prepare_minicpm5_text_sft import (
+        DOMAIN_BUCKET,
+        NEGATIVE_BUCKET,
+        PUBLIC_BUCKET,
+        TRAVEL_BUCKET,
+    )
+
+    stats = prepare_minicpm5_v2_distill_sft(
+        output_path=Path(TRAIN_REMOTE),
+        eval_output_path=Path(EVAL_REMOTE),
+        teacher_rows_path=Path(teacher_rows_path),
+        total_limit=total_limit,
+        seed=seed,
+        weights={
+            PUBLIC_BUCKET: public_weight,
+            DISTILL_BUCKET: distill_weight,
+            DOMAIN_BUCKET: domain_weight,
+            TRAVEL_BUCKET: travel_weight,
+            NEGATIVE_BUCKET: negative_weight,
+            GENERIC_BUCKET: generic_weight,
+        },
+    )
+    stats["assistant_accent_normalized_rows"] = _normalize_assistant_accents_in_jsonl(
+        Path(TRAIN_REMOTE)
+    )
+    data_volume.commit()
+    print(json.dumps(stats, indent=2, ensure_ascii=False))
+    return stats
+
+
+def _load_peft_model(model_name: str, *, context_length: int, load_in_4bit: bool):
+    from unsloth import FastLanguageModel
+
+    return FastLanguageModel.from_pretrained(
+        model_name=model_name,
+        max_seq_length=context_length,
+        dtype=None,
+        load_in_4bit=load_in_4bit,
+    )
+
+
+def _attach_lora(model, *, rank: int, alpha: int, dropout: float):
+    from unsloth import FastLanguageModel
+
+    return FastLanguageModel.get_peft_model(
+        model,
+        r=rank,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        lora_alpha=alpha,
+        lora_dropout=dropout,
+        use_gradient_checkpointing="unsloth",
+    )
+
+
+def _render_sft_text(tokenizer, messages: list[dict[str, str]]) -> str:
+    prompt = tokenizer.apply_chat_template(
+        messages[:-1],
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+    answer = str(messages[-1].get("content", "")).strip()
+    return f"{prompt}{answer}<|im_end|>\n"
+
+
+@app.function(
+    gpu=TRAIN_GPU,
+    image=image,
+    volumes={"/data": data_volume},
+    timeout=12 * 3600,
+)
+def train_sft(
+    *,
+    base_model: str = V1_MODEL,
+    output_dir: str = LORA_DIR,
+    context_length: int = DEFAULT_CONTEXT_LENGTH,
+    num_epochs: float = DEFAULT_EPOCHS,
+    learning_rate: float = DEFAULT_LEARNING_RATE,
+    per_device_batch_size: int = 2,
+    gradient_accumulation_steps: int = 8,
+    lora_rank: int = 16,
+    lora_alpha: int = 32,
+) -> str:
+    os.environ["UNSLOTH_COMPILE_DISABLE"] = "1"
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    from datasets import load_dataset
+    from peft import PeftModel
+    from transformers import DataCollatorForLanguageModeling, Trainer, TrainingArguments
+    from unsloth.chat_templates import train_on_responses_only
+
+    model, tokenizer = _load_peft_model(
+        base_model,
+        context_length=context_length,
+        load_in_4bit=True,
+    )
+    _configure_tokenizer_for_generation(tokenizer, model)
+    if isinstance(model, PeftModel):
+        raise RuntimeError(f"Base model {base_model!r} still has LoRA adapters attached")
+    model = _attach_lora(model, rank=lora_rank, alpha=lora_alpha, dropout=0.05)
+
+    dataset = load_dataset("json", data_files=TRAIN_REMOTE, split="train")
+    print(f"Loaded {len(dataset)} examples from {TRAIN_REMOTE}")
+
+    def to_text(example: dict) -> dict:
+        return {"text": _render_sft_text(tokenizer, example["messages"])}
+
+    dataset = dataset.map(to_text, remove_columns=dataset.column_names, num_proc=1)
+
+    def tokenize(example: dict) -> dict:
+        return tokenizer(example["text"], truncation=True, max_length=context_length)
+
+    dataset = dataset.map(tokenize, remove_columns=["text"], num_proc=1)
+    collator = DataCollatorForLanguageModeling(
+        tokenizer=tokenizer,
+        mlm=False,
+        pad_to_multiple_of=8,
+    )
+    trainer = Trainer(
+        model=model,
+        processing_class=tokenizer,
+        train_dataset=dataset,
+        data_collator=collator,
+        args=TrainingArguments(
+            output_dir=output_dir,
+            per_device_train_batch_size=per_device_batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            warmup_ratio=0.03,
+            lr_scheduler_type="cosine",
+            bf16=True,
+            logging_steps=20,
+            save_strategy="steps",
+            save_steps=500,
+            save_total_limit=2,
+            dataloader_num_workers=0,
+            dataloader_pin_memory=False,
+            report_to="none",
+            remove_unused_columns=False,
+        ),
+    )
+    trainer = train_on_responses_only(
+        trainer,
+        instruction_part="<|im_start|>user\n",
+        response_part=NO_THINKING_RESPONSE_PREFIX,
+        num_proc=1,
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+    data_volume.commit()
+    return output_dir
+
+
+@app.function(
+    gpu=TRAIN_GPU,
+    image=image,
+    volumes={"/data": data_volume},
+    timeout=4 * 3600,
+)
+def merge_lora(
+    *,
+    lora_dir: str = LORA_DIR,
+    merged_dir: str = MERGED_DIR,
+    context_length: int = DEFAULT_CONTEXT_LENGTH,
+) -> str:
+    from unsloth import FastLanguageModel
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=lora_dir,
+        max_seq_length=context_length,
+        dtype=None,
+        load_in_4bit=False,
+    )
+    model.save_pretrained_merged(merged_dir, tokenizer, save_method="merged_16bit")
+    data_volume.commit()
+    return merged_dir
+
+
+def _generate_answer(
+    *,
+    model,
+    tokenizer,
+    messages: list[dict[str, Any]],
+    max_new_tokens: int,
+    do_sample: bool = False,
+) -> str:
+    import torch
+
+    _configure_tokenizer_for_generation(tokenizer, model)
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+    generation_kwargs: dict[str, Any] = {
+        "max_new_tokens": max_new_tokens,
+        "do_sample": do_sample,
+        "pad_token_id": tokenizer.pad_token_id,
+        "eos_token_id": tokenizer.eos_token_id,
+    }
+    if do_sample:
+        generation_kwargs["temperature"] = 0.7
+        generation_kwargs["top_p"] = 0.9
+    with torch.no_grad():
+        output_ids = model.generate(**inputs, **generation_kwargs)
+    return tokenizer.decode(
+        output_ids[0][inputs["input_ids"].shape[1] :],
+        skip_special_tokens=True,
+    )
+
+
+@app.function(
+    gpu=GENERATION_GPU,
+    image=image,
+    volumes={"/data": data_volume, "/results": results_volume},
+    timeout=4 * 3600,
+)
+def eval_vivamais(
+    *,
+    model_id: str,
+    run_name: str,
+    max_new_tokens: int = 160,
+) -> dict[str, Any]:
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    _ensure_paths()
+    import sys
+
+    sys.path.insert(0, "/opt/vivamais/evals")
+    from vivamais_qa_scoring import score_case, summarize_results
+
+    eval_file = Path(EVAL_REMOTE)
+    cases = _load_jsonl(eval_file)
+    if len(cases) < 120:
+        from build_vivamais_qa_eval import build_vivamais_qa_eval
+
+        build_vivamais_qa_eval(eval_file)
+        data_volume.commit()
+        cases = _load_jsonl(eval_file)
+    output_dir = Path("/results") / run_name
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_log_path = output_dir / "outputs.jsonl"
+    output_log_path.write_text("", encoding="utf-8")
+    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+    )
+    model.eval()
+    predictions = []
+    for case_number, case in enumerate(cases, start=1):
+        prediction = _generate_answer(
+            model=model,
+            tokenizer=tokenizer,
+            messages=case["messages"],
+            max_new_tokens=max_new_tokens,
+        )
+        scored = score_case(case, prediction)
+        row = {
+            "id": case.get("id"),
+            "category": case.get("category"),
+            "case": case,
+            "prediction": scored["prediction"],
+            "score": scored["score"],
+            "passed": scored["passed"],
+            "forbidden_hits": scored["forbidden_hits"],
+            "unknown_gate": scored["unknown_gate"],
+            "expected_answer": case.get("expected_answer"),
+        }
+        predictions.append(row)
+        _write_jsonl(output_log_path, row)
+        print(
+            json.dumps(
+                {
+                    "event": "vivamais_eval_output",
+                    "run_name": run_name,
+                    "case_number": case_number,
+                    "total_cases": len(cases),
+                    "id": row["id"],
+                    "category": row["category"],
+                    "passed": row["passed"],
+                    "score": row["score"],
+                    "forbidden_hits": row["forbidden_hits"],
+                    "unknown_gate": row["unknown_gate"],
+                    "prediction_preview": _preview(row["prediction"]),
+                },
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+    payload = {
+        "model_name": model_id,
+        "run_name": run_name,
+        "generation": {"enable_thinking": False, "max_new_tokens": max_new_tokens},
+        "predictions": predictions,
+    }
+    summary = summarize_results(payload)
+    (output_dir / "results.json").write_text(json.dumps(payload, indent=2, ensure_ascii=False))
+    (output_dir / "summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+    results_volume.commit()
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    return summary
+
+
+@app.function(
+    gpu=GENERATION_GPU,
+    image=image,
+    volumes={"/data": data_volume, "/results": results_volume},
+    timeout=2 * 3600,
+)
+def eval_generic_ptbr(
+    *,
+    model_id: str,
+    run_name: str,
+    max_new_tokens: int = 180,
+) -> dict[str, Any]:
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    _ensure_paths()
+    from ptbr_conversation_eval import (
+        GENERIC_EVAL_CASES,
+        score_generic_case,
+        summarize_generic_scores,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+    )
+    model.eval()
+    scored = []
+    output_dir = Path("/results") / run_name
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_log_path = output_dir / "outputs.jsonl"
+    output_log_path.write_text("", encoding="utf-8")
+    for case_number, case in enumerate(GENERIC_EVAL_CASES, start=1):
+        prediction = _generate_answer(
+            model=model,
+            tokenizer=tokenizer,
+            messages=case["messages"],
+            max_new_tokens=max_new_tokens,
+        )
+        row = score_generic_case(case, prediction)
+        row["case"] = case
+        scored.append(row)
+        _write_jsonl(output_log_path, row)
+        print(
+            json.dumps(
+                {
+                    "event": "generic_eval_output",
+                    "run_name": run_name,
+                    "case_number": case_number,
+                    "total_cases": len(GENERIC_EVAL_CASES),
+                    "id": row["id"],
+                    "category": row["category"],
+                    "passed": row["passed"],
+                    "score": row["score"],
+                    "forbidden_hits": row["forbidden_hits"],
+                    "prediction_preview": _preview(row["prediction"]),
+                },
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+    summary = summarize_generic_scores(model=model_id, run_name=run_name, scored=scored)
+    (output_dir / "results.json").write_text(
+        json.dumps({"summary": summary, "predictions": scored}, indent=2, ensure_ascii=False)
+    )
+    (output_dir / "summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+    results_volume.commit()
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    return summary
+
+
+def _candidate_passes(
+    *,
+    baseline_vivamais: dict[str, Any],
+    candidate_vivamais: dict[str, Any],
+    baseline_generic: dict[str, Any],
+    candidate_generic: dict[str, Any],
+    min_dashboard_delta: float = V3_MIN_DASHBOARD_DELTA,
+    min_generic_score: float = V3_MIN_GENERIC_SCORE,
+) -> bool:
+    dashboard_passed = (
+        candidate_vivamais["average_score"]
+        >= baseline_vivamais["average_score"] + min_dashboard_delta
+        and candidate_vivamais["unknown_failures"] <= baseline_vivamais["unknown_failures"]
+        and candidate_vivamais["leakage_failures"] <= baseline_vivamais["leakage_failures"]
+    )
+    if IS_V4:
+        return dashboard_passed and candidate_generic["average_score"] >= min_generic_score
+    return (
+        dashboard_passed
+        and candidate_generic["average_score"] > baseline_generic["average_score"]
+        and candidate_generic["average_score"] >= min_generic_score
+    )
+
+
+@app.function(image=image, volumes={"/results": results_volume}, timeout=10 * 60)
+def show_eval_details(
+    *,
+    run_names: list[str],
+    failed_only: bool = True,
+    max_prediction_chars: int = 600,
+) -> dict[str, Any]:
+    summaries: dict[str, Any] = {}
+    for run_name in run_names:
+        results_path = Path("/results") / run_name / "results.json"
+        if not results_path.is_file():
+            summaries[run_name] = {"error": f"Missing results file: {results_path}"}
+            continue
+        payload = json.loads(results_path.read_text(encoding="utf-8"))
+        rows = payload.get("predictions", [])
+        details = []
+        for row in rows:
+            passed = bool(row.get("passed"))
+            if failed_only and passed:
+                continue
+            case = row.get("case", {})
+            if not isinstance(case, dict):
+                case = {}
+            prediction = str(row.get("prediction", "")).strip()
+            details.append(
+                {
+                    "id": row.get("id") or case.get("id"),
+                    "category": row.get("category") or case.get("category"),
+                    "passed": passed,
+                    "score": row.get("score"),
+                    "forbidden_hits": row.get("forbidden_hits", []),
+                    "unknown_gate": row.get("unknown_gate"),
+                    "expected_answer": row.get("expected_answer") or case.get("expected_answer"),
+                    "prediction": prediction[:max_prediction_chars],
+                }
+            )
+        summaries[run_name] = {
+            "summary": payload.get("summary"),
+            "details": details,
+        }
+    print(json.dumps(summaries, indent=2, ensure_ascii=False))
+    return summaries
+
+
+@app.function(image=image, volumes={"/data": data_volume}, timeout=4 * 3600, cpu=4, memory=16384)
+def publish_model(
+    *,
+    repo_id: str = V3_MODEL_REPO,
+    source_dir: str = MERGED_DIR,
+    base_model: str = V1_MODEL,
+    hf_token: str,
+) -> dict[str, str]:
+    from huggingface_hub import HfApi
+
+    token = hf_token.strip()
+    if not token:
+        raise RuntimeError(f"HF token is required to publish {TEXT_VARIANT}")
+    source = Path(source_dir)
+    readme = source / "README.md"
+    readme.write_text(
+        f"""---
+language:
+- pt
+license: apache-2.0
+base_model: {base_model}
+library_name: transformers
+tags:
+- brazilian-portuguese
+- minicpm5
+- vivamais
+- distilled
+- conversational
+- grounded-qa
+---
+
+# {repo_id.split("/")[-1]}
+
+MiniCPM5-1B Viva Mais text {TEXT_VARIANT}, trained from `{base_model}` with a
+broader Brazilian Portuguese conversational and grounded-Q&A mix.
+
+The training package uses a redacted Viva Mais dashboard Q&A replay set,
+grounding-negative rows, and filtered Rio 3.1 teacher-distilled rows. The v4
+variant intentionally excludes the generic WhatsApp-style bucket and uses a
+stricter final-answer-only teacher prompt. Teacher rows are filtered to reject
+verbose wrappers and hidden-reasoning artifacts. No raw WhatsApp exports, client
+identifiers, identity documents, or local private data are published.
+""",
+        encoding="utf-8",
+    )
+    api = HfApi(token=token)
+    api.create_repo(repo_id=repo_id, repo_type="model", exist_ok=True)
+    api.upload_folder(
+        folder_path=str(source),
+        repo_id=repo_id,
+        repo_type="model",
+        commit_message=f"Publish MiniCPM5 Viva Mais text {TEXT_VARIANT}",
+    )
+    return {"repo": repo_id, "url": f"https://huggingface.co/{repo_id}"}
+
+
+@app.function(gpu="A100", image=image, volumes={"/data": data_volume}, timeout=6 * 3600)
+def export_and_publish_gguf(
+    *,
+    source_model: str = V3_MODEL_REPO,
+    repo_id: str = V3_GGUF_REPO,
+    quant: str = "q4_k_m",
+    context_length: int = DEFAULT_CONTEXT_LENGTH,
+    hf_token: str,
+) -> dict[str, Any]:
+    import shutil
+
+    from huggingface_hub import HfApi
+    from unsloth import FastLanguageModel
+
+    token = hf_token.strip()
+    if not token:
+        raise RuntimeError(f"HF token is required to publish {TEXT_VARIANT} GGUF")
+    output_dir = Path(GGUF_DIR)
+    gguf_output_dir = Path(f"{GGUF_DIR}_gguf")
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    if gguf_output_dir.exists():
+        shutil.rmtree(gguf_output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=source_model,
+        max_seq_length=context_length,
+        dtype=None,
+        load_in_4bit=False,
+    )
+    FastLanguageModel.for_inference(model)
+    model.save_pretrained_gguf(str(output_dir), tokenizer, quantization_method=quant)
+    gguf_files = sorted(gguf_output_dir.glob("*.gguf"))
+    if len(gguf_files) != 1:
+        found = ", ".join(path.name for path in gguf_files) or "none"
+        raise RuntimeError(f"Expected one GGUF file in {gguf_output_dir}, found {found}")
+    target_name = f"{source_model.split('/')[-1]}-{quant.upper()}.gguf"
+    target_path = gguf_output_dir / target_name
+    if gguf_files[0] != target_path:
+        gguf_files[0].rename(target_path)
+    (gguf_output_dir / "README.md").write_text(
+        f"""---
+language:
+- pt
+license: apache-2.0
+base_model: {source_model}
+library_name: gguf
+tags:
+- gguf
+- llama-cpp
+- minicpm5
+- vivamais
+- brazilian-portuguese
+---
+
+# {repo_id.split("/")[-1]}
+
+GGUF export of `{source_model}` for llama.cpp-compatible Viva Mais inference.
+
+- Quantization: `{quant.upper()}`
+- File: `{target_name}`
+""",
+        encoding="utf-8",
+    )
+    data_volume.commit()
+    api = HfApi(token=token)
+    api.create_repo(repo_id=repo_id, repo_type="model", exist_ok=True)
+    api.upload_folder(
+        folder_path=str(gguf_output_dir),
+        repo_id=repo_id,
+        repo_type="model",
+        commit_message=(
+            f"Publish {quant.upper()} GGUF for MiniCPM5 Viva Mais {TEXT_VARIANT}"
+        ),
+    )
+    return {
+        "repo": repo_id,
+        "url": f"https://huggingface.co/{repo_id}",
+        "file": target_name,
+        "size_bytes": target_path.stat().st_size,
+    }
+
+
+@app.local_entrypoint()
+def main(
+    *,
+    step: str = "candidate",
+    run_name: str = DEFAULT_RUN_NAME,
+    teacher_model: str = RIO_TEACHER_MODEL,
+    teacher_rows: int = DEFAULT_TEACHER_ROWS,
+    teacher_gigaverbo_seed_limit: int = DEFAULT_TEACHER_SEED_LIMIT,
+    teacher_max_new_tokens: int = 180,
+    total_limit: int = DEFAULT_V3_ROWS,
+    public_weight: float = DEFAULT_PUBLIC_WEIGHT,
+    distill_weight: float = DEFAULT_DISTILL_WEIGHT,
+    domain_weight: float = DEFAULT_DOMAIN_WEIGHT,
+    travel_weight: float = 0.0,
+    negative_weight: float = DEFAULT_NEGATIVE_WEIGHT,
+    generic_weight: float = DEFAULT_GENERIC_WEIGHT,
+    learning_rate: float = DEFAULT_LEARNING_RATE,
+    num_epochs: float = DEFAULT_EPOCHS,
+    baseline_eval_model: str = V1_MODEL,
+    candidate_eval_model: str = "",
+    details_run_names: str = "",
+    publish: bool = False,
+    publish_gguf: bool = False,
+) -> None:
+    if step in {"publish", "gguf"}:
+        raise RuntimeError(
+            "Direct publish steps are disabled. Run --step eval with --publish and/or "
+            "--publish-gguf so the v1 comparison gates run in the same invocation."
+        )
+    if step in {"candidate", "distill"}:
+        stats = distill_teacher_rows.remote(
+            teacher_model=teacher_model,
+            target_rows=teacher_rows,
+            gigaverbo_seed_limit=teacher_gigaverbo_seed_limit,
+            max_new_tokens=teacher_max_new_tokens,
+        )
+        print(f"Teacher distill stats: {stats}")
+    if step in {"candidate", "prepare"}:
+        stats = prepare_v3_dataset.remote(
+            total_limit=total_limit,
+            public_weight=public_weight,
+            distill_weight=distill_weight,
+            domain_weight=domain_weight,
+            travel_weight=travel_weight,
+            negative_weight=negative_weight,
+            generic_weight=generic_weight,
+        )
+        print(f"Dataset stats: {stats}")
+    if step in {"candidate", "train"}:
+        lora = train_sft.remote(learning_rate=learning_rate, num_epochs=num_epochs)
+        print(f"LoRA saved to {lora}")
+    if step in {"candidate", "merge"}:
+        merged = merge_lora.remote()
+        print(f"Merged model saved to {merged}")
+    if step == "inspect-evals":
+        summary = inspect_eval_suites.remote()
+        print(json.dumps(summary, indent=2, ensure_ascii=False))
+    if step == "check-evals":
+        result = run_eval_unit_subset.remote()
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    if step in {"candidate", "eval"}:
+        selected_candidate = candidate_eval_model or MERGED_DIR
+        baseline_vivamais = eval_vivamais.remote(
+            model_id=baseline_eval_model,
+            run_name=f"{run_name}_baseline_vivamais",
+        )
+        candidate_vivamais = eval_vivamais.remote(
+            model_id=selected_candidate,
+            run_name=f"{run_name}_candidate_vivamais",
+        )
+        baseline_generic = eval_generic_ptbr.remote(
+            model_id=baseline_eval_model,
+            run_name=f"{run_name}_baseline_generic",
+        )
+        candidate_generic = eval_generic_ptbr.remote(
+            model_id=selected_candidate,
+            run_name=f"{run_name}_candidate_generic",
+        )
+        decision = _candidate_passes(
+            baseline_vivamais=baseline_vivamais,
+            candidate_vivamais=candidate_vivamais,
+            baseline_generic=baseline_generic,
+            candidate_generic=candidate_generic,
+        )
+        print(
+            json.dumps(
+                {
+                    "accepted": decision,
+                    "baseline_vivamais": baseline_vivamais,
+                    "candidate_vivamais": candidate_vivamais,
+                    "baseline_generic": baseline_generic,
+                    "candidate_generic": candidate_generic,
+                },
+                indent=2,
+                ensure_ascii=False,
+            )
+        )
+        if not decision and (publish or publish_gguf):
+            raise RuntimeError("Candidate did not pass v3 publish gates")
+    if step == "details":
+        run_names = [part.strip() for part in details_run_names.split(",") if part.strip()]
+        if not run_names:
+            raise RuntimeError("--details-run-names is required for --step details")
+        show_eval_details.remote(run_names=run_names)
+    if step == "publish" or publish:
+        published = publish_model.remote(
+            repo_id=V3_MODEL_REPO,
+            source_dir=MERGED_DIR,
+            hf_token=os.environ.get("HF_TOKEN", ""),
+        )
+        print(f"Published model: {published}")
+    if step == "gguf" or publish_gguf:
+        published_gguf = export_and_publish_gguf.remote(
+            source_model=V3_MODEL_REPO,
+            repo_id=V3_GGUF_REPO,
+            hf_token=os.environ.get("HF_TOKEN", ""),
+        )
+        print(f"Published GGUF: {published_gguf}")

modal/restore_vivamais_v3_dataset_volume.py

@@ -0,0 +1,76 @@
+"""Restore Viva Mais MiniCPM5 text v3 data volume from the HF dataset package."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+import modal
+
+APP_NAME = "vivamais-v3-dataset-volume-restore"
+DATA_VOLUME_NAME = "minicpm5-vivamais-v3-rio-data"
+DATASET_REPO = "marinarosa/minicpm5-vivamais-text-sft-v3"
+
+RESTORE_MAP = {
+    "data/train.jsonl": Path("/data/minicpm5_v3_rio_sft.jsonl"),
+    "data/eval/vivamais_qa_eval.jsonl": Path("/data/vivamais_qa_eval.jsonl"),
+    "data/teacher/rio31_teacher_distill.jsonl": Path("/data/teacher_distill_v3_rio.jsonl"),
+}
+
+app = modal.App(APP_NAME)
+data_volume = modal.Volume.from_name(DATA_VOLUME_NAME, create_if_missing=False)
+
+image = modal.Image.debian_slim(python_version="3.11").pip_install("huggingface_hub")
+
+
+def _count_jsonl(path: Path) -> int:
+    with path.open(encoding="utf-8") as handle:
+        return sum(1 for line in handle if line.strip())
+
+
+@app.function(
+    image=image,
+    volumes={"/data": data_volume},
+    timeout=30 * 60,
+    cpu=2,
+    memory=4096,
+)
+def restore_dataset(repo_id: str, hf_token: str) -> dict[str, Any]:
+    from huggingface_hub import hf_hub_download
+
+    token = hf_token.strip()
+    if not token:
+        raise RuntimeError("HF_TOKEN is required to restore the v3 data volume")
+
+    restored: dict[str, Any] = {}
+    for source_path, target_path in RESTORE_MAP.items():
+        downloaded = Path(
+            hf_hub_download(
+                repo_id=repo_id,
+                filename=source_path,
+                repo_type="dataset",
+                token=token,
+            )
+        )
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(downloaded, target_path)
+        restored[source_path] = {
+            "target": str(target_path),
+            "rows": _count_jsonl(target_path),
+            "bytes": target_path.stat().st_size,
+        }
+    data_volume.commit()
+    print(json.dumps(restored, ensure_ascii=False, indent=2))
+    return restored
+
+
+@app.local_entrypoint()
+def main(repo_id: str = DATASET_REPO) -> None:
+    result = restore_dataset.remote(
+        repo_id=repo_id,
+        hf_token=os.environ.get("HF_TOKEN", ""),
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))