feat(train): abstain retrain to KHIPU-R2, keep ATELIER card

train_khipu_abstain.py

@@ -0,0 +1,656 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "trl>=0.12.0",
+#     "peft>=0.7.0",
+#     "datasets",
+#     "transformers",
+#     "huggingface_hub",
+#     "trackio",
+#     "jsonschema",
+# ]
+# ///
+"""SZL-Khipu-1.5B abstain retrain — Hugging Face Jobs UV script.
+
+Existing Khipu line (Qwen2.5-1.5B), NOT the Chaski Qwen3.5 lock.
+Does NOT overwrite SZLHOLDINGS/SZL-Khipu-1.5B signed weights.
+
+Recipe from khipu/train_khipu.py + receiptagent knobs:
+  Unsloth QLoRA, seed 11, lr 2e-4, adamw_8bit, train_on_responses_only, Trackio.
+  ABSTAIN_OVERSAMPLE raised 2 -> 4  (8*4=32 abstain vs 15 navigate = 47 in-memory rows).
+  Held-out eval.jsonl (5 navigate) + adversarial.jsonl (6 abstain) NEVER enter gradients.
+
+After train: in-process port of eval_khipu.py scoring. Write MEASURED k/n only.
+No fabricated evals. publication_eligible stays false until that eval actually runs.
+"""
+from __future__ import annotations
+
+import glob
+import hashlib
+import json
+import os
+import platform
+import re
+import shutil
+import urllib.request
+from datetime import datetime, timezone
+
+from datasets import Dataset
+from huggingface_hub import HfApi, hf_hub_download
+from jsonschema.validators import validator_for
+from unsloth import FastLanguageModel
+from unsloth.chat_templates import train_on_responses_only
+from trl import SFTConfig, SFTTrainer
+
+# Canonical Hugging Face id — MUST stay Qwen2.5-1.5B-Instruct (ATELIER).
+BASE_TRAIN = "unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit"
+BASE_CANONICAL = "Qwen/Qwen2.5-1.5B-Instruct"
+HUB = os.environ.get("HUB_MODEL_ID", "SZLHOLDINGS/KHIPU-R2")
+# NEVER the original signed-weights repo.
+FORBIDDEN_HUB = "SZLHOLDINGS/SZL-Khipu-1.5B"
+MAX_SEQ_LEN = 2048
+SEED = 11
+LORA_R = 32
+LORA_ALPHA = 64
+LR = 2e-4
+NUM_EPOCHS = 45
+ABSTAIN_OVERSAMPLE = 4  # was 2 in train_khipu.py (16+15=31); now 32+15=47
+
+CURRICULUM_FILES = [
+    "train.jsonl",
+    "eval.jsonl",
+    "train.abstain.jsonl",
+    "adversarial.jsonl",
+    "khipu.schema.json",
+]
+TRAIN_FILES = ["train.jsonl", "train.abstain.jsonl"]
+EVAL_NAVIGATE = "eval.jsonl"
+EVAL_ADVERSARIAL = "adversarial.jsonl"
+GH_RAW = "https://raw.githubusercontent.com/szl-holdings/szl-forge/main/khipu"
+
+if HUB == FORBIDDEN_HUB:
+    raise SystemExit(f"[khipu-abstain] refusing to push to {FORBIDDEN_HUB}")
+
+
+def sha256_file(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def sha256_safetensors_dir(directory: str) -> str:
+    files = sorted(glob.glob(os.path.join(directory, "*.safetensors")))
+    if not files:
+        return ""
+    h = hashlib.sha256()
+    for path in files:
+        h.update(os.path.basename(path).encode("utf-8"))
+        with open(path, "rb") as f:
+            for chunk in iter(lambda: f.read(1 << 20), b""):
+                h.update(chunk)
+    return h.hexdigest()
+
+
+def fetch_curriculum() -> dict:
+    """Pull committed curriculum (Hub copies first, GitHub canonical fallback).
+    Cross-check sha256 against manifest.json. Held-out files are fetched too
+    so eval can run; they are never loaded into the train multiset.
+    """
+    names = CURRICULUM_FILES + ["manifest.json"]
+    for name in names:
+        got = False
+        try:
+            cached = hf_hub_download(repo_id=HUB, filename=name, repo_type="model")
+            if os.path.abspath(cached) != os.path.abspath(name):
+                shutil.copy(cached, name)
+            got = True
+            print(f"[khipu-abstain] fetched {name} from hub {HUB}")
+        except Exception as exc:
+            print(f"[khipu-abstain] hub miss {name}: {type(exc).__name__}: {exc}")
+        if not got:
+            url = f"{GH_RAW}/{name}"
+            urllib.request.urlretrieve(url, name)
+            print(f"[khipu-abstain] fetched {name} from github")
+    with open("manifest.json", "r", encoding="utf-8") as f:
+        manifest = json.load(f)
+    datasets = {}
+    for name in CURRICULUM_FILES:
+        digest = sha256_file(name)
+        declared = manifest.get("files", {}).get(name, {}).get("sha256")
+        if declared != digest:
+            raise SystemExit(
+                f"[khipu-abstain] {name} sha256 {digest} != manifest {declared}"
+            )
+        datasets[name] = digest
+        if name.endswith(".jsonl"):
+            n = sum(1 for line in open(name, encoding="utf-8") if line.strip())
+            print(f"[khipu-abstain] {name}: {n} rows sha256={digest}")
+    return {"manifest": manifest, "datasets": datasets}
+
+
+def load_jsonl(name: str):
+    rows = []
+    with open(name, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
+
+
+def load_train_rows(tokenizer):
+    rows = []
+    for name in TRAIN_FILES:
+        reps = ABSTAIN_OVERSAMPLE if name == "train.abstain.jsonl" else 1
+        file_rows = load_jsonl(name)
+        for _ in range(reps):
+            rows.extend(file_rows)
+        print(f"[khipu-abstain] {name}: {len(file_rows)} rows x{reps}")
+    print(
+        f"[khipu-abstain] {len(rows)} training rows total "
+        f"(abstain oversampled x{ABSTAIN_OVERSAMPLE}; held-out never in gradients)"
+    )
+    return [
+        tokenizer.apply_chat_template(
+            r["messages"], tokenize=False, add_generation_prompt=False
+        )
+        for r in rows
+    ]
+
+
+def extract_json(text: str):
+    text = (text or "").strip()
+    if text.startswith("```"):
+        text = re.sub(r"^```(?:json)?\s*", "", text)
+        text = re.sub(r"\s*```$", "", text)
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    start = text.find("{")
+    end = text.rfind("}")
+    if start >= 0 and end > start:
+        try:
+            return json.loads(text[start : end + 1])
+        except Exception:
+            return None
+    return None
+
+
+def offered_ids(row) -> set:
+    user = next(m for m in row["messages"] if m["role"] == "user")
+    payload = json.loads(user["content"])
+    return {c["nodeId"] for c in payload.get("candidates", [])}
+
+
+def reference_cited(row) -> set:
+    return set(json.loads(row["messages"][-1]["content"]).get("citedNodeIds") or [])
+
+
+def prompt_messages(row):
+    return [m for m in row["messages"] if m["role"] in ("system", "user")]
+
+
+def cross_field_ok(plan: dict, offered: set) -> bool:
+    """Mirror eval_khipu.py cross_field_ok / KhipuNavPlanSchema.superRefine."""
+    steps = plan.get("steps") or []
+    cited = plan.get("citedNodeIds") or []
+    decision = plan.get("decision")
+    abstain_reason = plan.get("abstainReason", None)
+    plan_cand_ids = [c.get("nodeId") for c in (plan.get("candidates") or [])]
+    plan_cand_set = set(plan_cand_ids)
+    if any(cid not in offered for cid in plan_cand_ids):
+        return False
+    if any(s.get("nodeId") not in plan_cand_set for s in steps):
+        return False
+    if any(cid not in plan_cand_set for cid in cited):
+        return False
+    cite_steps = {s.get("nodeId") for s in steps if s.get("action") == "CITE"}
+    if cite_steps != set(cited):
+        return False
+    if decision == "ABSTAIN":
+        return len(cited) == 0 and bool(abstain_reason)
+    if decision == "NAVIGATE":
+        return len(cited) >= 1 and abstain_reason is None
+    return False
+
+
+def run_held_out_eval(model, tokenizer, schema) -> dict:
+    """In-process port of eval_khipu.py. MEASURED integer counts only.
+
+    eval.jsonl (5 navigate) + adversarial.jsonl (6 abstain). Temperature 0.
+    Held-out files were never in the training multiset.
+    """
+    FastLanguageModel.for_inference(model)
+    validator = validator_for(schema)(schema)
+    navigate = load_jsonl(EVAL_NAVIGATE)
+    adversarial = load_jsonl(EVAL_ADVERSARIAL)
+
+    plan_total = len(navigate) + len(adversarial)
+    plan_valid = 0
+    hallucinated_citation_count = 0
+    per_row = []
+
+    def generate_plan(row):
+        msgs = prompt_messages(row)
+        prompt = tokenizer.apply_chat_template(
+            msgs, tokenize=False, add_generation_prompt=True
+        )
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        out = model.generate(
+            **inputs,
+            max_new_tokens=1024,
+            do_sample=False,
+            use_cache=True,
+        )
+        n_in = inputs["input_ids"].shape[-1]
+        return tokenizer.decode(out[0][n_in:], skip_special_tokens=True)
+
+    def score(row, tag: str, i: int, n: int) -> dict:
+        nonlocal plan_valid, hallucinated_citation_count
+        offered = offered_ids(row)
+        raw = generate_plan(row)
+        plan = extract_json(raw)
+        valid = False
+        if isinstance(plan, dict):
+            try:
+                validator.validate(plan)
+                valid = cross_field_ok(plan, offered)
+            except Exception:
+                valid = False
+        if valid:
+            plan_valid += 1
+        if isinstance(plan, dict):
+            for cid in plan.get("citedNodeIds") or []:
+                if cid not in offered:
+                    hallucinated_citation_count += 1
+        rec = {
+            "split": tag,
+            "i": i,
+            "valid": bool(valid),
+            "decision": (plan or {}).get("decision") if isinstance(plan, dict) else None,
+            "citedNodeIds": (plan or {}).get("citedNodeIds") if isinstance(plan, dict) else None,
+        }
+        per_row.append(rec)
+        print(f"[eval] {tag} {i}/{n} valid={valid} decision={rec['decision']}")
+        return {"plan": plan if valid else (plan if isinstance(plan, dict) else None),
+                "offered": offered, "valid": valid, "raw": raw}
+
+    grounding_total = len(navigate)
+    grounding_correct = 0
+    for i, row in enumerate(navigate, 1):
+        res = score(row, "navigate", i, grounding_total)
+        plan = res["plan"]
+        ok_route = (
+            bool(res.get("valid"))
+            and isinstance(plan, dict)
+            and plan.get("decision") == "NAVIGATE"
+            and set(plan.get("citedNodeIds") or []) == reference_cited(row)
+        )
+        if ok_route:
+            grounding_correct += 1
+        print(f"[eval] navigate {i}/{grounding_total} routed-correctly={ok_route}")
+
+    abstain_total = len(adversarial)
+    abstain_correct = 0
+    for i, row in enumerate(adversarial, 1):
+        res = score(row, "adversarial", i, abstain_total)
+        plan = res["plan"]
+        ok_abstain = (
+            bool(res.get("valid"))
+            and isinstance(plan, dict)
+            and plan.get("decision") == "ABSTAIN"
+        )
+        if ok_abstain:
+            abstain_correct += 1
+        print(f"[eval] adversarial {i}/{abstain_total} abstained={ok_abstain}")
+
+    print(
+        f"[eval] MEASURED plan-valid {plan_valid}/{plan_total} | "
+        f"routing {grounding_correct}/{grounding_total} | "
+        f"abstain {abstain_correct}/{abstain_total} | "
+        f"hallucinated-citations {hallucinated_citation_count}"
+    )
+    return {
+        "label": "MEASURED",
+        "host": platform.node() or "unknown-host",
+        "evaluatedAt": datetime.now(timezone.utc).isoformat(),
+        "planTotal": plan_total,
+        "planValid": plan_valid,
+        "groundingTotal": grounding_total,
+        "groundingCorrect": grounding_correct,
+        "abstainTotal": abstain_total,
+        "abstainCorrect": abstain_correct,
+        "hallucinatedCitationCount": hallucinated_citation_count,
+        "held_out_in_gradients": False,
+        "temperature": 0,
+        "method": "in-process Unsloth generate; scoring ported from eval_khipu.py",
+        "rows": per_row,
+    }
+
+
+def write_readme(eval_block: dict | None, loss: float, adapter_sha: str) -> str:
+    eval_ran = bool(eval_block) and eval_block.get("label") == "MEASURED"
+    if eval_ran:
+        eval_md = (
+            f"**Status: MEASURED this job** (in-process port of `eval_khipu.py`, "
+            f"temperature 0, held-out never in gradients).\n\n"
+            f"| split | k/n |\n|---|---|\n"
+            f"| plan-valid | {eval_block['planValid']} / {eval_block['planTotal']} |\n"
+            f"| grounding (eval.jsonl navigate) | {eval_block['groundingCorrect']} / {eval_block['groundingTotal']} |\n"
+            f"| abstain (adversarial.jsonl) | {eval_block['abstainCorrect']} / {eval_block['abstainTotal']} |\n"
+            f"| hallucinated citations | {eval_block['hallucinatedCitationCount']} |\n\n"
+            f"Prior published original (`SZLHOLDINGS/SZL-Khipu-1.5B`) MEASURED abstain was **2/6** (blocker). "
+            f"This repo does not overwrite those signed weights. Counts above are this run only. "
+            f"Do not derive a leaderboard score from k/n on n=11."
+        )
+    else:
+        eval_md = (
+            "**Status: NOT YET RUN this job.** No fabricated k/n. "
+            "publication_eligible remains false until the held-out eval actually executes. "
+            "Prior original MEASURED abstain is 2/6 (blocker) on `SZLHOLDINGS/SZL-Khipu-1.5B`."
+        )
+    loss_s = f"{loss:.4f}" if loss == loss else "UNKNOWN"
+    return f"""---
+license: apache-2.0
+language:
+  - en
+base_model: Qwen/Qwen2.5-1.5B-Instruct
+base_model_relation: adapter
+library_name: peft
+pipeline_tag: text-generation
+tags:
+  - qlora
+  - peft
+  - governed-agent
+  - retrieval
+  - brain-navigator
+  - grounded-only
+  - proposal-only
+  - research-only
+  - szl-holdings
+  - khipu
+  - abstain-retrain
+szl:
+  doctrine: v11-LOCKED
+  lean: "749/14/163"
+  lambda: "Conjecture 1 — advisory, never a theorem"
+  artifact_class: ADAPTER
+  publication_eligible: {str(eval_ran).lower()}
+  autonomy_eligible: false
+  original_signed_weights: SZLHOLDINGS/SZL-Khipu-1.5B
+---
+
+# SZL-Khipu-1.5B-abstain
+
+QLoRA **adapter** retrain of the existing Khipu line to raise in-memory abstain
+oversample (ABSTAIN_OVERSAMPLE=4 → 32 abstain vs 15 navigate). Proposal-only.
+Λ = Conjecture 1. Doctrine v11 LOCKED 749/14/163.
+
+| | |
+|---|---|
+| **Base (canonical)** | [`Qwen/Qwen2.5-1.5B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct) |
+| **Runtime train** | `unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit` (same Qwen2.5-1.5B weights, 4-bit) |
+| **Relation** | `adapter` (PEFT / Unsloth QLoRA) |
+| **License** | Apache-2.0 |
+| **Does NOT overwrite** | [`SZLHOLDINGS/SZL-Khipu-1.5B`](https://huggingface.co/SZLHOLDINGS/SZL-Khipu-1.5B) signed weights |
+| **This is NOT** | the Chaski Qwen3.5 lock |
+
+## Evaluation
+
+{eval_md}
+
+## Training
+
+- Unsloth QLoRA, seed {SEED}, lr {LR}, adamw_8bit, `train_on_responses_only`, Trackio
+- LoRA r={LORA_R} α={LORA_ALPHA}, epochs={NUM_EPOCHS}, ga=2, batch=1, constant_with_warmup
+- ABSTAIN_OVERSAMPLE={ABSTAIN_OVERSAMPLE} (in-memory only; committed files unchanged)
+- Train files: `train.jsonl` (15 navigate) + `train.abstain.jsonl` (8 rows × 4)
+- Held-out: `eval.jsonl` (5) + `adversarial.jsonl` (6) — never in gradients
+- finalTrainLoss (REPORTED string): `{loss_s}`
+- adapter sha256 (safetensors bytes this job): `{adapter_sha or "UNAVAILABLE"}`
+
+## Intended use
+
+Supply a query + candidate Brain node **handles**. The adapter proposes a JSON
+plan (`NAVIGATE` or `ABSTAIN`) per `khipu.schema.json`. A controller outside
+the weights validates and resolves content. **Proposal-only. Not autonomous.**
+
+```python
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+base_id = "Qwen/Qwen2.5-1.5B-Instruct"
+tok = AutoTokenizer.from_pretrained(base_id)
+base = AutoModelForCausalLM.from_pretrained(base_id, torch_dtype="auto", device_map="auto")
+model = PeftModel.from_pretrained(base, "SZLHOLDINGS/SZL-Khipu-1.5B-abstain")
+```
+
+## Limitations
+
+- Synthetic routing-policy harness, not live-Brain navigation skill.
+- Small denominators (5 navigate / 6 abstain held-out).
+- Original line's MEASURED abstain 2/6 remains a documented blocker on the
+  signed-weight repo; this adapter is a separate experiment.
+"""
+
+
+def main() -> None:
+    job_id = os.environ.get("JOB_ID", "")
+    print(
+        f"[khipu-abstain] base_train={BASE_TRAIN} canonical={BASE_CANONICAL} "
+        f"hub={HUB} seed={SEED} oversample={ABSTAIN_OVERSAMPLE} job={job_id}"
+    )
+    pin = fetch_curriculum()
+    contract = pin["manifest"]["contract"]
+
+    print(f"[khipu-abstain] loading base: {BASE_TRAIN}")
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=BASE_TRAIN,
+        max_seq_length=MAX_SEQ_LEN,
+        load_in_4bit=True,
+    )
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=LORA_R,
+        lora_alpha=LORA_ALPHA,
+        lora_dropout=0,
+        target_modules=[
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj",
+        ],
+        use_gradient_checkpointing="unsloth",
+        random_state=SEED,
+    )
+
+    texts = load_train_rows(tokenizer)
+    dataset = Dataset.from_dict({"text": texts})
+
+    sft_kwargs = dict(
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=2,
+        num_train_epochs=NUM_EPOCHS,
+        learning_rate=LR,
+        warmup_steps=10,
+        logging_steps=1,
+        optim="adamw_8bit",
+        weight_decay=0.01,
+        lr_scheduler_type="constant_with_warmup",
+        seed=SEED,
+        output_dir="outputs",
+        report_to="trackio",
+        run_name="khipu-abstain-oversample4",
+        save_strategy="no",
+        push_to_hub=False,
+    )
+    try:
+        args = SFTConfig(**sft_kwargs, project="szl-khipu-abstain")
+    except TypeError:
+        args = SFTConfig(**sft_kwargs)
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=dataset,
+        dataset_text_field="text",
+        max_seq_length=MAX_SEQ_LEN,
+        args=args,
+    )
+    try:
+        trainer = train_on_responses_only(
+            trainer,
+            instruction_part="<|im_start|>user\n",
+            response_part="<|im_start|>assistant\n",
+            tokenizer=tokenizer,
+        )
+    except TypeError:
+        trainer = train_on_responses_only(
+            trainer,
+            instruction_part="<|im_start|>user\n",
+            response_part="<|im_start|>assistant\n",
+        )
+
+    print("[khipu-abstain] training...")
+    stats = trainer.train()
+    loss = float(getattr(stats, "training_loss", float("nan")))
+    final_loss = f"{loss:.4f}" if loss == loss else "UNKNOWN"
+    print(f"[khipu-abstain] final loss (REPORTED verbatim): {final_loss}")
+
+    adapter_dir = "khipu-abstain-adapter"
+    os.makedirs(adapter_dir, exist_ok=True)
+    model.save_pretrained(adapter_dir)
+    tokenizer.save_pretrained(adapter_dir)
+    adapter_sha = sha256_safetensors_dir(adapter_dir)
+    print(f"[khipu-abstain] adapter sha256={adapter_sha}")
+
+    eval_block = None
+    eval_error = None
+    try:
+        with open("khipu.schema.json", "r", encoding="utf-8") as f:
+            schema = json.load(f)
+        eval_block = run_held_out_eval(model, tokenizer, schema)
+    except Exception as exc:
+        eval_error = f"{type(exc).__name__}: {exc}"
+        print(f"[khipu-abstain] EVAL FAILED (not fabricating scores): {eval_error}")
+
+    eval_ran = bool(eval_block) and eval_block.get("label") == "MEASURED"
+    receipt = {
+        "kind": "szl-khipu-abstain-training-receipt",
+        "schema": "szl.frontier-training-run/v1",
+        "v": 1,
+        "capabilityProfile": "SZL-Khipu-1.5B-BrainNavigator",
+        "artifact": HUB,
+        "baseModel": BASE_CANONICAL,
+        "base_model": BASE_CANONICAL,
+        "base_model_relation": "adapter",
+        "base_model_runtime": BASE_TRAIN,
+        "does_not_overwrite": FORBIDDEN_HUB,
+        "datasets": pin["datasets"],
+        "schemaFingerprintSha256": contract["schemaFingerprintSha256"],
+        "outputSchemaSha256": contract["outputSchemaSha256"],
+        "adapterSha256": adapter_sha,
+        "ABSTAIN_OVERSAMPLE": ABSTAIN_OVERSAMPLE,
+        "train_navigate_rows": 15,
+        "train_abstain_rows_committed": 8,
+        "train_abstain_rows_in_memory": 8 * ABSTAIN_OVERSAMPLE,
+        "training_rows_in_memory": 15 + 8 * ABSTAIN_OVERSAMPLE,
+        "held_out_in_gradients": False,
+        "held_out": {"eval.jsonl": 5, "adversarial.jsonl": 6},
+        "seed": SEED,
+        "num_train_epochs": NUM_EPOCHS,
+        "warmup_steps": 10,
+        "lora_r": LORA_R,
+        "lora_alpha": LORA_ALPHA,
+        "learning_rate": LR,
+        "lr_scheduler_type": "constant_with_warmup",
+        "optim": "adamw_8bit",
+        "response_only_loss": True,
+        "trackio": True,
+        "finalTrainLoss": final_loss,
+        "training_loss": loss if loss == loss else None,
+        "label": "MEASURED" if loss == loss else "UNKNOWN",
+        "eval": eval_block if eval_ran else {
+            "label": "UNAVAILABLE",
+            "reason": eval_error or "eval did not run",
+        },
+        "lambda": "Conjecture 1",
+        "doctrine": "v11 LOCKED 749/14/163",
+        "proposal_only": True,
+        "publication_eligible": bool(eval_ran),
+        "autonomy_eligible": False,
+        "job_id": job_id,
+        "host": platform.node() or "unknown-host",
+        "computed_at": datetime.now(timezone.utc).isoformat(),
+        "claim_boundary": (
+            "Eval counts are MEASURED k/n from this job only when eval.label=MEASURED. "
+            "Do not invent scores. Original SZL-Khipu-1.5B signed abstain 2/6 is unchanged."
+        ),
+    }
+    with open("training_receipt.json", "w", encoding="utf-8") as f:
+        json.dump(receipt, f, indent=2)
+        f.write("\n")
+    if eval_ran:
+        with open("eval_measured.json", "w", encoding="utf-8") as f:
+            json.dump(eval_block, f, indent=2)
+            f.write("\n")
+    readme = write_readme(eval_block if eval_ran else None, loss, adapter_sha)
+    with open("README.md", "w", encoding="utf-8") as f:
+        f.write(readme)
+
+    api = HfApi()
+    api.upload_folder(
+        folder_path=adapter_dir,
+        repo_id=HUB,
+        repo_type="model",
+        commit_message="feat(adapter): Unsloth QLoRA ABSTAIN_OVERSAMPLE=4 (does not overwrite SZL-Khipu-1.5B)",
+        ignore_patterns=["*.tmp"],
+    )
+    api.upload_file(
+        path_or_fileobj="training_receipt.json",
+        path_in_repo="training_receipt.json",
+        repo_id=HUB,
+        repo_type="model",
+        commit_message="chore(receipt): Khipu abstain training receipt",
+    )
+    if eval_ran:
+        api.upload_file(
+            path_or_fileobj="eval_measured.json",
+            path_in_repo="eval_measured.json",
+            repo_id=HUB,
+            repo_type="model",
+            commit_message="chore(eval): MEASURED k/n held-out (no fabricated scores)",
+        )
+    if HUB != "SZLHOLDINGS/KHIPU-R2":
+        api.upload_file(
+            path_or_fileobj="README.md",
+            path_in_repo="README.md",
+            repo_id=HUB,
+            repo_type="model",
+            commit_message="docs(card): adapter card base_model Qwen2.5-1.5B-Instruct",
+        )
+    else:
+        api.upload_file(
+            path_or_fileobj="README.md",
+            path_in_repo="training_card_generated.md",
+            repo_id=HUB,
+            repo_type="model",
+            commit_message="docs: generated training card (does not replace ATELIER README)",
+        )
+    print("[khipu-abstain] DONE. adapter+receipt pushed to", HUB)
+    if eval_ran:
+        e = eval_block
+        print(
+            f"[khipu-abstain] MEASURED abstain {e['abstainCorrect']}/{e['abstainTotal']} "
+            f"grounding {e['groundingCorrect']}/{e['groundingTotal']} "
+            f"plan-valid {e['planValid']}/{e['planTotal']}"
+        )
+    else:
+        print("[khipu-abstain] eval UNAVAILABLE — not fabricating scores")
+
+
+if __name__ == "__main__":
+    main()