Update script.py

script.py

@@ -1,29 +1,25 @@
-# script.py — CONTROLLED EXPERIMENT: Qwen2.5-14B-Instruct (bnb-4bit, via
-# unsloth/Qwen2.5-14B-Instruct-bnb-4bit) + decomposition/verification prompt
-# + safe arithmetic for number tasks + guaranteed explanations.
+# script.py — PROVEN bnb Qwen2.5-14B (0.104) + two SAFE, deterministic
+# improvements only. No sampling, no MBR (that was the -0.07 regression).
 # =============================================================================
-# THE ONLY CHANGE vs the 0.0834 baseline is the pip block below. Inference is
-# byte-identical. Purpose: the grader's scoring step (metric.py:179 ->
-# hf_hub_download of the private solution file) was dying with RemoteDisconnected
-# AFTER our script exited cleanly (exit code 0). The leading hypothesis is that
-# our `pip install -U transformers ...` dragged a newer huggingface_hub /
-# requests / urllib3 into the shared site-packages, and the grader then ran its
-# solution-file download on that untested networking stack. This submission
-# installs NOTHING that can move those packages, so if it scores, that
-# hypothesis is confirmed; if it still fails identically, the class is ruled out
-# and the cause is organizer-side infrastructure.
+# Base = the exact 0.104 pipeline (Qwen2.5-14B-Instruct-bnb-4bit, install only
+# bitsandbytes --no-deps so the networking stack is untouched).
+# ADDED (both deterministic, both fail-open, neither can tank exact_match):
+#   1. match_letters BIJECTION-CONSTRAINED answer pass: after the model
+#      reasons, a short second pass regenerates just the letters under a
+#      decoder grammar that allows only valid option letters and — when
+#      #letters == #items — forbids any letter already used, so it cannot
+#      repeat or skip. Non-bijection / any failure -> fall back to greedy.
+#   2. NFC unicode normalization in clean_answer: composes look-identical
+#      code points to their canonical form so a correct answer isn't lost to
+#      an invisible encoding difference. Purely canonical (does NOT swap
+#      characters), so it cannot corrupt puzzle-orthography answers.
 # =============================================================================
 import os
 import atexit
-# Save pre-script state BEFORE we touch these variables, so we can restore
-# it exactly (unset if they were unset, original value if they had one).
+import unicodedata
 _ORIGINAL_HF_HUB_OFFLINE = os.environ.get("HF_HUB_OFFLINE")
 _ORIGINAL_TRANSFORMERS_OFFLINE = os.environ.get("TRANSFORMERS_OFFLINE")
 def _restore_offline_env_vars():
-    """Restores these two variables to their exact pre-script state on
-    exit. Harmless belt-and-suspenders: the scoring traceback reaches the
-    network, so offline vars are demonstrably NOT the failure cause, but
-    restoring them cannot hurt and keeps the file otherwise identical."""
     for key, original in (("HF_HUB_OFFLINE", _ORIGINAL_HF_HUB_OFFLINE),
                            ("TRANSFORMERS_OFFLINE", _ORIGINAL_TRANSFORMERS_OFFLINE)):
         if original is None:
@@ -35,8 +31,6 @@ os.environ["HF_HUB_OFFLINE"] = "1"
 os.environ["TRANSFORMERS_OFFLINE"] = "1"
 import subprocess, sys
 def emergency_submission_csv(reason, rows_so_far=None):
-    """Last-resort guarantee: no matter WHERE the script dies, write a valid
-    submission.csv before the process exits."""
     try:
         import pandas as pd
         if rows_so_far:
@@ -52,17 +46,12 @@ def emergency_submission_csv(reason, rows_so_far=None):
                   "explanation": f"EMERGENCY FALLBACK: {str(reason)[:150]}"} for i in ids]
         pd.DataFrame(rows, columns=["id", "pred", "explanation"]).to_csv("submission.csv", index=False)
     except Exception:
-        # Absolute last resort: a header-only file is still a file.
         try:
             with open("submission.csv", "w") as f:
                 f.write("id,pred,explanation\n")
         except Exception:
             pass
 def write_submission_csv(rows_list):
-    """Stdlib csv, not pandas -- avoids a real pandas/numpy ABI crash inside
-    pandas' Index construction seen in this exact sandbox. ATOMIC: writes to
-    a temp file then os.replace()s it into place, so a reader can never
-    observe a partially-written file mid-save."""
     import csv as _csv
     tmp_path = "submission.csv.tmp"
     with open(tmp_path, "w", newline="", encoding="utf-8") as f:
@@ -72,17 +61,6 @@ def write_submission_csv(rows_list):
             w.writerow(row)
     os.replace(tmp_path, "submission.csv")
 try:
-    # CONTROLLED EXPERIMENT: no upgrades, no networking-stack churn.
-    # We install NOTHING that could pull a newer huggingface_hub / requests /
-    # urllib3 into the shared site-packages, because the grader's scoring step
-    # (metric.py:179 -> hf_hub_download of the solution file) runs on whatever
-    # stack we leave behind. bitsandbytes is the only package the 4-bit model
-    # genuinely needs that may be absent; --no-deps guarantees it cannot drag
-    # huggingface_hub / requests / urllib3 up with it. torch, pandas,
-    # transformers, accelerate, tokenizers are used at their PREINSTALLED
-    # sandbox versions. If a genuine ModuleNotFoundError appears in OUR script
-    # (non-zero exit, a different failure than the scoring RemoteDisconnected),
-    # add just that one package back with --no-deps.
     subprocess.run([sys.executable, "-m", "pip", "install", "-q",
                     "--no-deps", "bitsandbytes"], check=True)
 except Exception as e:
@@ -94,13 +72,9 @@ import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
 MODEL_ID = "."
 TIME_LIMIT_S = 30 * 60
-SETUP_BUFFER_S = 420   # larger margin: 14B bnb-4bit checkpoint is ~8-9GB, slower to load than anything tested before
+SETUP_BUFFER_S = 420
 start_time = time.time()
 try:
-    # Read test.csv and checkpoint a placeholder submission FIRST, before
-    # the slowest and most failure-prone step (model loading, ~7-9 min for
-    # this checkpoint size) even starts. If loading hangs or gets killed,
-    # something valid already exists on disk rather than nothing at all.
     df = pd.read_csv("/tmp/data/test.csv", dtype=str).fillna("")
     placeholder_rows = [{"id": rid, "pred": json.dumps([""]),
                           "explanation": "Placeholder written before model load."}
@@ -111,10 +85,6 @@ try:
         tok = AutoTokenizer.from_pretrained(MODEL_ID)
         print("Tokenizer loaded (fast).", flush=True)
     except Exception as e:
-        # Mechanism-level fix: bypasses TokenizerFast.from_file() entirely,
-        # which is exactly the call that fails on a tokenizer.json saved by a
-        # newer tokenizers library than the sandbox has. Falls back to the
-        # pure Python tokenizer built from vocab.json/merges.txt instead.
         print(f"Fast tokenizer failed ({e}); falling back to use_fast=False.", flush=True)
         tok = AutoTokenizer.from_pretrained(MODEL_ID, use_fast=False)
         print("Tokenizer loaded (slow fallback).", flush=True)
@@ -127,18 +97,12 @@ except Exception as e:
     emergency_submission_csv(f"tokenizer/model load or test.csv read failed: {e}")
     raise
 n_rows = len(df)
-# Measured, not estimated: if real loading took longer or shorter than the
-# SETUP_BUFFER_S guess, every downstream timing decision for the rest of the
-# run should work from what actually happened, not a stale assumption.
 actual_setup_elapsed = time.time() - start_time
 per_row_budget = max(20, (TIME_LIMIT_S - actual_setup_elapsed) / max(n_rows, 1))
-print(f"Setup took {actual_setup_elapsed:.0f}s (estimated {SETUP_BUFFER_S}s) | "
-      f"per_row_budget={per_row_budget:.0f}s for {n_rows} rows", flush=True)
-# ---- Query parsing: widened patterns + honest "unknown count" fallback ----
+print(f"Setup took {actual_setup_elapsed:.0f}s | per_row_budget={per_row_budget:.0f}s "
+      f"for {n_rows} rows", flush=True)
+# ---- Query parsing ----
 def parse_items(query: str):
-    """Returns (preamble, items, count_known). count_known=False means no
-    pattern matched -- we do NOT guess a count, we let the model's own
-    answer list stand rather than risk truncating real content."""
     item_pat = re.compile(r"(?m)^\s*(\d+)\s*[.\)]\s*(.*)$")
     matches = list(item_pat.finditer(query))
     if matches:
@@ -180,20 +144,9 @@ TASK_GUIDANCE = {
     "num_to_text": "give the number written out in words, in the language asked.",
 }
 DEFAULT_GUIDANCE = "give exactly what the instruction asks, nothing else."
-# =============================================================================
-# SYMBOLIC PREPROCESSING LAYER -- pure Python standard library only (re,
-# difflib, collections), no new dependencies. Deterministic, CPU-only,
-# negligible runtime. Augments the raw context; never replaces or rewrites
-# any of it.
-# =============================================================================
 from difflib import SequenceMatcher
-from collections import defaultdict, Counter
+from collections import defaultdict
 def extract_forms_from_context(context: str):
-    """Pulls candidate unknown-language 'forms' out of raw context text, for
-    reduplication's per-word self-check ONLY. Pipe-delimited lines
-    contribute ONLY their FIRST field (the conventional unknown-language
-    side). Plain lines contribute whitespace tokens. Lines with more than 3
-    pipes are skipped defensively (click-language transcriptions)."""
     forms = []
     for line in context.splitlines():
         line = line.strip()
@@ -216,9 +169,6 @@ def extract_forms_from_context(context: str):
             unique_forms.append(f)
     return unique_forms
 def extract_explicit_pairs(context: str):
-    """Extracts genuine (input, output) pairs from pipe-delimited rows using
-    the row's own layout, not language-specific assumptions. Forms from
-    DIFFERENT rows are never cross-compared."""
     pairs = []
     for line in context.splitlines():
         line = line.strip()
@@ -230,9 +180,6 @@ def extract_explicit_pairs(context: str):
             pairs.append((fields[0], fields[1]))
     return pairs
 def edit_signature(a: str, b: str):
-    """A clean single-region transformation signature between two strings,
-    or None if the difference is scattered across multiple regions, OR if
-    there is no genuine shared stem of at least 2 characters."""
     sm = SequenceMatcher(None, a, b, autojunk=False)
     all_ops = sm.get_opcodes()
     ops = [op for op in all_ops if op[0] != "equal"]
@@ -251,9 +198,6 @@ def edit_signature(a: str, b: str):
         pos = "infix"
     return (pos, removed, inserted)
 def find_transformation_families(pairs):
-    """Clusters GENUINELY PAIRED forms (same row only) sharing an identical
-    clean edit signature. Emits a family only if 2+ separate given pairs
-    share it."""
     groups = defaultdict(list)
     for a, b in pairs:
         if not a or not b or a == b:
@@ -271,11 +215,9 @@ def find_transformation_families(pairs):
             examples = "; ".join(f"{a}->{b}" for a, b in unique_pairs[:4])
             families.append((len(unique_pairs),
                               f"{pos} change: '{removed_disp}' -> '{inserted_disp}' (seen in: {examples})"))
-    families.sort(key=lambda x: -x[0])  # strongest support first
+    families.sort(key=lambda x: -x[0])
     return [f for _, f in families]
 def detect_reduplication(forms):
-    """Flags a word only if it contains an exact adjacent doubled substring
-    (length >= 2). Emits nothing if absent."""
     findings = []
     for w in forms:
         n = len(w)
@@ -292,8 +234,6 @@ def detect_reduplication(forms):
                 break
     return findings
 def build_symbolic_evidence(context: str) -> str:
-    """The full symbolic layer. Returns "" if no supported transformation
-    family and no reduplication is found. Never replaces context."""
     forms = extract_forms_from_context(context)
     pairs = extract_explicit_pairs(context)
     families = find_transformation_families(pairs) if pairs else []
@@ -313,11 +253,9 @@ def build_symbolic_evidence(context: str) -> str:
             "may be incomplete -- verify against the examples, do not trust blindly):\n"
             + "\n".join(lines))
 def build_messages(context, query, task_type):
-    """The frozen single-call decomposition scaffold behind the accepted
-    0.083/0.0296/0.2323 baseline."""
     preamble, items, count_known = parse_items(query)
     guidance = TASK_GUIDANCE.get(task_type, DEFAULT_GUIDANCE)
-    symbolic_evidence = build_symbolic_evidence(context)  # "" if nothing found
+    symbolic_evidence = build_symbolic_evidence(context)
     system = (
         "You solve puzzles about a language you have never seen. Everything you "
         "need is in the examples below. Use only the examples, not outside "
@@ -386,7 +324,6 @@ def build_repair_messages(query, n_items, bad_text):
         f"FINAL ANSWERS: answer1 | answer2"
     )
     return [{"role": "system", "content": system}, {"role": "user", "content": user}]
-# ---- Safe arithmetic: no exec(), no eval() of arbitrary code ----
 _ALLOWED_BINOPS = (pyast.Add, pyast.Sub, pyast.Mult)
 def safe_arithmetic(expr: str):
     try:
@@ -411,16 +348,16 @@ def safe_arithmetic(expr: str):
         return None
     return _eval(tree)
 def clean_answer(a: str) -> str:
-    # Strips "Answer N:", "is:", "the answer is:", "final answer:".
+    # NFC normalization first: composes visually-identical code points to a
+    # canonical form so a correct answer isn't lost to an invisible encoding
+    # difference. Canonical composition only -- never swaps a character for a
+    # different one, so puzzle-orthography answers stay intact.
+    a = unicodedata.normalize("NFC", a)
     a = re.sub(r"(?i)^\s*(the\s+)?(final\s+)?answer\s*\d*\s*(is)?\s*:\s*", "", a).strip()
     a = re.sub(r"(?i)^\s*is\s*:\s*", "", a).strip()
     a = a.strip("* ")
     return a.strip(" .\"'“”‘’")
 def extract(text):
-    """Fixed against three real bugs found on real Linguini output:
-    (1) markdown-bold marker with content on the NEXT line, not same line;
-    (2) a following COMPUTE: line bleeding into the answer list;
-    (3) NO marker found + all answers dumped on one pipe-separated line."""
     m = list(re.finditer(r"final answers?\s*:?\s*\**", text, flags=re.IGNORECASE))
     if m:
         tail = text[m[-1].end():]
@@ -432,7 +369,6 @@ def extract(text):
         parts = [clean_answer(p) for p in candidate.split("|") if p.strip()]
         if parts:
             return parts, m[-1].start()
-    # Fallback (no marker found): split each line further by "|" if present.
     lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
     fallback = []
     for ln in lines:
@@ -453,15 +389,7 @@ def extract_compute_overrides(text, n_answers):
         if val is not None:
             overrides[i] = str(int(val)) if float(val).is_integer() else str(val)
     return overrides
-# ---- Generation: defensive against BOTH chat-template return shapes.     ----
-def generate(messages, max_new_tokens, constraint_fn=None, sample=False, seed=None):
-    """constraint_fn: optional prefix_allowed_tokens_fn, default None means
-    byte-identical behavior to every existing call site. If a constrained
-    attempt fails for ANY reason, falls back to a fully UNCONSTRAINED
-    generation. sample=True switches to Qwen's recommended stochastic
-    settings (temp 0.7 / top_p 0.8 / top_k 20) for MBR candidate generation;
-    the greedy default path is untouched, so every existing call is
-    byte-identical to the 0.104 baseline."""
+def generate(messages, max_new_tokens, constraint_fn=None):
     def _try_generate(gen_kwargs):
         try:
             enc = tok.apply_chat_template(
@@ -478,15 +406,7 @@ def generate(messages, max_new_tokens, constraint_fn=None, sample=False, seed=No
             with torch.no_grad():
                 out = model.generate(ids, **gen_kwargs)
         return out, input_len
-    if sample:
-        if seed is not None:
-            torch.manual_seed(seed)
-            if torch.cuda.is_available():
-                torch.cuda.manual_seed_all(seed)
-        base_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": True,
-                       "temperature": 0.7, "top_p": 0.8, "top_k": 20}
-    else:
-        base_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": False}
+    base_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": False}
     if constraint_fn is not None:
         try:
             out, input_len = _try_generate({**base_kwargs, "prefix_allowed_tokens_fn": constraint_fn})
@@ -501,36 +421,7 @@ EXPLANATION_SYSTEM = (
     "Be concise and structured -- do not repeat the full reasoning."
 )
 EXPLANATION_FALLBACK = "Answer derived from patterns found in the examples above."
-_LETTER_CONSTRAINT_CACHE = {}
-def build_letter_constraint_fn(tok, valid_letters):
-    cache_key = (id(tok), tuple(sorted(valid_letters)))
-    if cache_key in _LETTER_CONSTRAINT_CACHE:
-        return _LETTER_CONSTRAINT_CACHE[cache_key]
-    try:
-        allowed_chars = set(valid_letters) | set(" |\n\t\r")
-        eos = tok.eos_token_id
-        pieces = []
-        for token_id in range(len(tok)):
-            if token_id == eos:
-                continue
-            piece = tok.decode([token_id], skip_special_tokens=False)
-            if piece and all(c in allowed_chars for c in piece):
-                pieces.append(token_id)
-        allowed_ids = ([eos] if eos is not None else []) + pieces
-        def allowed(_batch_id, _input_ids):
-            return allowed_ids if allowed_ids else list(range(len(tok)))
-        _LETTER_CONSTRAINT_CACHE[cache_key] = allowed
-        return allowed
-    except Exception:
-        return None
-# =============================================================================
-# closed-answer-space pre-constraint, match_letters only. Deterministic,
-# read-only. Extracts the closed set of option letters genuinely present in
-# the context and states that exact set as a hard constraint. FAIL-OPEN.
-# =============================================================================
 def extract_match_letter_options(context: str):
-    """Returns a sorted list of option letters if extraction is CLEAN and
-    UNAMBIGUOUS, else None. Deliberately strict: this must never guess."""
     found = set()
     for line in context.splitlines():
         for m in re.finditer(r"(?:^|\s)([A-Z])[.\)]\s+\S", line):
@@ -545,67 +436,11 @@ def extract_match_letter_options(context: str):
         return None
     return letters
 # =============================================================================
-# TRANSLATION: chrF-MBR (Minimum Bayes Risk) item-level selection.
-# We are scored on chrF; MBR with a chrF utility provably optimizes chrF
-# (Freitag et al. TACL 2022). Instead of voting on the exact string (which
-# almost never agrees on free-form translations), we pick, PER ITEM, the
-# candidate whose mean chrF against the other candidates is highest -- the
-# "chrF-central" answer. That central answer tends to be both the highest-chrF
-# AND the likeliest exact match, so it lifts both scored components at once.
-# Pure stdlib, no dependencies. The greedy candidate is always in the pool, so
-# MBR can only match or beat greedy, never regress it.
-# =============================================================================
-def _char_ngrams(s, n):
-    return Counter(s[i:i + n] for i in range(len(s) - n + 1)) if len(s) >= n else Counter()
-def chrf_score(hyp, ref, max_n=6, beta=2.0):
-    """Character n-gram F-beta (chrF), the same family the grader uses. Light
-    normalization (lowercase, collapse whitespace) so it rewards content, not
-    incidental spacing/case. Returns 1.0 on exact post-normalization match."""
-    hyp = re.sub(r"\s+", " ", (hyp or "").strip().lower())
-    ref = re.sub(r"\s+", " ", (ref or "").strip().lower())
-    if hyp == ref:
-        return 1.0
-    if not hyp or not ref:
-        return 0.0
-    b2 = beta * beta
-    total, counted = 0.0, 0
-    for n in range(1, max_n + 1):
-        h, r = _char_ngrams(hyp, n), _char_ngrams(ref, n)
-        if not h or not r:
-            continue
-        overlap = sum((h & r).values())
-        p = overlap / max(sum(h.values()), 1)
-        rec = overlap / max(sum(r.values()), 1)
-        f = 0.0 if (p + rec) == 0 else (1 + b2) * p * rec / (b2 * p + rec)
-        total += f
-        counted += 1
-    return total / counted if counted else 0.0
-def mbr_select_item(cands):
-    """Pick the chrF-central candidate for one item. Ties keep the first
-    (which is the greedy answer, since it is inserted first)."""
-    cands = [c for c in cands if c is not None]
-    if not cands:
-        return ""
-    if len(set(cands)) == 1:
-        return cands[0]
-    best, best_score = cands[0], -1.0
-    for i, c in enumerate(cands):
-        others = [cands[j] for j in range(len(cands)) if j != i]
-        score = sum(chrf_score(c, o) for o in others) / max(len(others), 1)
-        if score > best_score:
-            best, best_score = c, score
-    return best
-# =============================================================================
-# MATCH_LETTERS: reason first, then a bijection-CONSTRAINED answer pass.
-# The main greedy generation is left to reason freely and produce FINAL
-# ANSWERS. Then, ONLY for match_letters, we run a short second pass whose
-# decoding grammar (a) allows only valid option letters + separators + EOS,
-# and (b) when #letters == #items (a clean bijection), forbids any letter
-# already emitted -- so the output physically cannot repeat or skip a letter.
-# This is the structural half of how humans solve matching puzzles
-# (anchor + elimination), enforced at the decoder. FAIL-OPEN everywhere:
-# any failure or a non-bijection problem falls straight back to the greedy
-# answers, so this can only help.
+# MATCH_LETTERS: reason first (main pass), then a bijection-CONSTRAINED answer
+# pass. Grammar allows only valid option letters + separators + EOS, and when
+# #letters == #items forbids any letter already emitted, so the output cannot
+# repeat or skip a letter. FAIL-OPEN: any failure or non-bijection problem
+# falls straight back to the greedy answers, so this can only help.
 # =============================================================================
 _LETTER_TOKEN_CACHE = {}
 def _letter_token_map(tok, labels):
@@ -631,14 +466,12 @@ def build_answer_only_messages(query, reasoning_text, labels, n_items, bijection
               "No numbering, no words, no punctuation.")
     user = (
         f"Task:\n{query.strip()}\n\n"
-        f"Your reasoning:\n{reasoning_text[:1200]}\n\n"
+        f"Your reasoning:\n{reasoning_text[:1400]}\n\n"
         f"Valid letters: {', '.join(labels)}. Give exactly {n_items} letters, one per "
         f"line, in item order. Each item takes exactly one letter{uniq}."
     )
     return [{"role": "system", "content": system}, {"role": "user", "content": user}]
 def generate_constrained_letters(messages, labels, n_items, bijection, max_new_tokens=96):
-    """Own encode/generate so the stateful constraint knows where the prompt
-    ends. Returns a list of letters or None on any failure (fail-open)."""
     labels = set(labels)
     try:
         try:
@@ -704,13 +537,7 @@ try:
                     if idx < len(answers):
                         answers[idx] = val
             if (marker_pos is None or not answers) and remaining > SETUP_BUFFER_S:
-                repair_constraint = None
-                if task_type == "match_letters":
-                    repair_options = extract_match_letter_options(r["context"])
-                    if repair_options:
-                        repair_constraint = build_letter_constraint_fn(tok, repair_options)
-                repair_text = generate(build_repair_messages(r["query"], n_items, text), 128,
-                                        constraint_fn=repair_constraint)
+                repair_text = generate(build_repair_messages(r["query"], n_items, text), 128)
                 rep, rep_pos = extract(repair_text)
                 if rep:
                     answers, marker_pos = rep, rep_pos
@@ -719,14 +546,12 @@ try:
                     answers = answers + [answers[-1] if answers else ""] * (n_items - len(answers))
                 elif len(answers) > n_items and marker_pos is None:
                     answers = answers[:n_items]
-                # else: marker found, more answers than our guess -> KEEP THEM ALL
             if not answers:
                 answers = [""]
-            # ---- TASK-SPECIFIC REFINEMENT (translation MBR / match_letters bijection) ----
-            # match_letters: reason (already done above) -> bijection-constrained answer pass.
+            # ---- SAFE REFINEMENT: match_letters bijection-constrained pass ----
             if task_type == "match_letters" and n_items:
                 labels = extract_match_letter_options(r["context"])
-                if labels and len(labels) >= 2:
+                if labels and len(labels) >= 2 and remaining > SETUP_BUFFER_S:
                     bijection = (len(labels) == n_items)
                     refined = generate_constrained_letters(
                         build_answer_only_messages(r["query"], text, labels, n_items, bijection),
@@ -734,25 +559,6 @@ try:
                     )
                     if refined and len(refined) == n_items:
                         answers = refined
-            # translation: chrF-MBR, but only when we can afford ~2 extra full
-            # generations without eating another row's budget. Time-gated so it
-            # never causes a timeout; greedy answer is always candidate #1.
-            elif task_type == "translation" and n_items and n_items > 0:
-                remaining_now = TIME_LIMIT_S - (time.time() - start_time)
-                rows_left = max(n_rows - len(rows), 1)
-                afford_mbr = remaining_now > rows_left * per_row_budget * 2.2
-                if afford_mbr and n_items <= 20:
-                    cand_lists = [answers]
-                    for s in range(2):
-                        stext = generate(messages, tokens_cap, sample=True, seed=1234 + s)
-                        sa, _ = extract(stext)
-                        if len(sa) >= n_items:
-                            cand_lists.append(sa[:n_items])
-                        elif sa:
-                            cand_lists.append(sa + [sa[-1]] * (n_items - len(sa)))
-                    if len(cand_lists) >= 2:
-                        answers = [mbr_select_item([cl[i] for cl in cand_lists if i < len(cl)])
-                                   for i in range(n_items)]
             remaining_after = TIME_LIMIT_S - (time.time() - start_time)
             budget_left_after = max(n_rows - len(rows) - 1, 0)
             comfortable = remaining_after > (budget_left_after + 1) * per_row_budget * 1.3
@@ -786,7 +592,6 @@ try:
         if time.time() - start_time > TIME_LIMIT_S - 60:
             print("Time budget nearly exhausted, stopping early.", flush=True)
             break
-    # Guarantee one row per test.csv id, even under a timeout.
     for _, r in df.iterrows():
         if r["id"] in processed_ids:
             continue
@@ -800,7 +605,5 @@ try:
     write_submission_csv(rows)
     print("DONE.", flush=True)
 except Exception as e:
-    # Final safety net: even if something escapes every inner try/except
-    # above, whatever rows were collected so far still get written.
     emergency_submission_csv(f"main loop failed: {e}", rows_so_far=rows if rows else None)
     print(f"FATAL, but submission.csv was written with {len(rows)} rows. Error: {e}", flush=True)