round3 screening pool: 3,144 certified problems, 10 shards, loop0-only + minipatch

README.md

@@ -0,0 +1,8 @@
+# round3-screen-pool — 新硬题池 loop0 筛查数据（3,144 题 × 10 shards）
+
+用法见 repo 分支 `claude/round2-matched-compute` 的 `docs/ROUND3_SCREEN_HANDOFF.zh.md`
+（先 git pull —— 分支已合并 harness 关键修复，跑前必须 `python scripts/verify_stdin_buffer_bug.py` 自检）。
+
+- `shard00..09/seeds.jsonl` — 每 shard ~315 题，20B 和 120B 各跑一遍 **loop0-only**
+- `manifest.json` — 分片与题池构成（≥2400: 1,120 题，其中 2800+: 507）
+- 判分在我们这边；回传整个 RUN_DIR。

manifest.json

@@ -0,0 +1,25 @@
+{
+ "source": "round3_cc_pool_v3.jsonl",
+ "n_rows": 3144,
+ "n_shards": 10,
+ "deal": "round-robin",
+ "per_shard": [
+  315,
+  315,
+  315,
+  315,
+  314,
+  314,
+  314,
+  314,
+  314,
+  314
+ ],
+ "bands": {
+  ">=2400": 1120,
+  "1800-2399": 859,
+  "unrated": 1165
+ },
+ "special_judge_rows": 264,
+ "note": "screening = loop0 only, both models; grading on our side"
+}

minipatch/README.zh.md

@@ -0,0 +1,12 @@
+# minipatch — 最小补丁（不切分支、不动其他文件）
+
+只覆盖 6 个文件：`scripts/lcb_{exec_harness,public_probe_harness,probe_exec}.py`
+（**关键 harness 修复**）+ `scripts/verify_stdin_buffer_bug.py`（自检）+
+`handoff/round3/run_shard_loop0.sh`（round3 loop0 runner）+
+`handoff/configs/se_120b_loop0.yaml`（已存在则跳过）。
+
+```bash
+bash install.sh /path/to/tts-sft     # 会自动跑功能自检，必须显示 “自检通过”
+```
+
+之后直接按 ROUND3_SCREEN_HANDOFF.zh.md 第 ⑤ 步跑（无需 git 操作）。

minipatch/handoff/configs/se_120b_loop0.yaml

@@ -0,0 +1,41 @@
+# Phase 1: gpt-oss-120b LOOP0 (independent sampling, pop=16) on the FULL cf+cc pool.
+# loops:1 => produces only loop0 + its checkpoint <RUN_DIR>/ck0/<run_name>_loop0.json.
+# gpt-oss port of the se16 codeforces config: chat, reasoning_effort medium, max_tokens 32768 (raised from 16384: cap-hits were frontier-concentrated),
+# dropped extra_body.top_k. Verifier-free (grading is OFFLINE, after this phase).
+# __RUN_DIR__ is substituted by run_pipeline.sh to an ABSOLUTE path (SE runs with cwd=se_dir,
+# so checkpoint_dir/metrics_path MUST be absolute).
+run_name: __RUN_NAME__
+routing:
+  k: 4
+  population: 16
+  groups: 16
+  loops: 1                                   # loop0 ONLY
+  confidence_percentiles: []
+  fitness: diversity
+  selection: uniform
+  selection_temperature: 1.0
+  update: replace
+  lite_fraction: 0.0
+  lite_method: majority
+  recombination: livecodebench-aggregate
+  evaluation: livecodebench-none
+  task: code
+  generation_batch_size: 30000
+  strip_think: true
+  seed: 1234
+models:
+  - name: gpt-oss-120b
+    base_url: http://localhost:8000/v1
+    api_key: EMPTY
+    endpoint: chat
+    max_tokens: 32768
+    temperature: 1.0
+    top_p: 0.95
+    max_concurrency: 256
+    reasoning_effort: medium
+    seed: 1234
+retry:
+  request_timeout_seconds: 3600
+resume: true                                  # resumable: re-run to continue an interrupted loop0
+checkpoint_dir: __RUN_DIR__/ck0
+metrics_path: __RUN_DIR__/metrics_loop0.json

minipatch/handoff/round3/run_shard_loop0.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Round-3 SCREENING: loop0 ONLY (pop=16 independent samples) on one seeds shard.
+# No evolution, no feedback, no grading (判分在我们这边做).
+#
+# REQUIRED env:
+#   MODEL     20b | 120b            (picks config + --model name)
+#   SEEDS     this shard's seeds.jsonl (from the HF dataset)
+#   RUN_NAME  unique, e.g. r3screen_20b_shard03
+#   RUN_DIR   per-shard output dir (absolute)
+# Optional: REPO SE_DIR CLIENT_PY BASE_URL (default http://localhost:8000/v1)
+#           BACKFILL_MAX_ROUNDS (default 10)
+#
+# Output to回传: RUN_DIR/ 整个目录 (loop0.out.jsonl + ck0/ + *.raw.json + run.log)
+set -u
+: "${REPO:=$(cd "$(dirname "$0")/../.." && pwd)}"
+: "${SE_DIR:=$REPO/external/squeeze-evolve}"
+: "${CLIENT_PY:=$REPO/../envs/vllm-gptoss/bin/python}"
+: "${BASE_URL:=http://localhost:8000/v1}"
+: "${MODEL:?set MODEL=20b or 120b}"
+: "${SEEDS:?set SEEDS to this shard's seeds.jsonl}"
+: "${RUN_NAME:?set RUN_NAME}"
+: "${RUN_DIR:?set RUN_DIR}"
+case "$MODEL" in
+  20b)  CFG="se_20b_loop0.yaml";  MODEL_NAME="gpt-oss-20b" ;;
+  120b) CFG="se_120b_loop0.yaml"; MODEL_NAME="gpt-oss-120b" ;;
+  *) echo "MODEL must be 20b or 120b"; exit 2 ;;
+esac
+H="$REPO/handoff"; mkdir -p "$RUN_DIR"
+rc(){ "$CLIENT_PY" "$@"; }
+unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY all_proxy 2>/dev/null || true
+
+# sanity: this repo MUST carry the stdin-buffer harness fix (5d921c4).
+# Static check — standalone, works on any branch/checkout state.
+if grep -q "sys.stdin = io.StringIO(" "$REPO/scripts/lcb_exec_harness.py"; then
+  echo "FATAL: scripts/lcb_exec_harness.py still has the bare-StringIO stdin stub"
+  echo "       apply the minipatch (or pull branch claude/round2-matched-compute) first"; exit 3
+fi
+
+echo "[$(date +%T)] r3 screen loop0: model=$MODEL_NAME seeds=$(wc -l <"$SEEDS") run_dir=$RUN_DIR"
+sed -e "s#__RUN_DIR__#$RUN_DIR#g" -e "s#__RUN_NAME__#$RUN_NAME#g" \
+    "$H/configs/$CFG" > "$RUN_DIR/cfg_loop0.yaml"
+
+echo "[$(date +%T)] Phase 1: loop0"
+rc "$REPO/scripts/run_squeeze_evolve.py" --input "$SEEDS" --output "$RUN_DIR/loop0.out.jsonl" \
+  --config "$RUN_DIR/cfg_loop0.yaml" --squeeze-evolve-dir "$SE_DIR" \
+  --model "$MODEL_NAME" --base-url "$BASE_URL" --api-key EMPTY || exit 1
+
+echo "[$(date +%T)] Phase 1b: backfill empty candidates"
+rc "$H/scripts/backfill_empty_candidates.py" --run-dir "$RUN_DIR" --run-name "$RUN_NAME" \
+  --config "$RUN_DIR/cfg_loop0.yaml" --squeeze-evolve-dir "$SE_DIR" \
+  --base-url "$BASE_URL" --api-key EMPTY --max-rounds "${BACKFILL_MAX_ROUNDS:-10}" || \
+  echo "[$(date +%T)] WARN: backfill incomplete; continuing"
+
+echo "[$(date +%T)] DONE — 回传整个 $RUN_DIR"

minipatch/install.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# 最小补丁安装：只覆盖 6 个文件（3 个 harness 修复 + 自检 + round3 runner + 120B 配置）。
+# 其他任何文件都不动。用法: bash install.sh /path/to/tts-sft
+set -eu
+REPO="${1:?用法: bash install.sh /path/to/tts-sft}"
+HERE="$(cd "$(dirname "$0")" && pwd)"
+cp -v "$HERE"/scripts/lcb_exec_harness.py "$HERE"/scripts/lcb_public_probe_harness.py \
+      "$HERE"/scripts/lcb_probe_exec.py "$HERE"/scripts/verify_stdin_buffer_bug.py "$REPO/scripts/"
+mkdir -p "$REPO/handoff/round3"
+cp -v "$HERE"/handoff/round3/run_shard_loop0.sh "$REPO/handoff/round3/"
+chmod +x "$REPO/handoff/round3/run_shard_loop0.sh"
+if [ ! -f "$REPO/handoff/configs/se_120b_loop0.yaml" ]; then
+  cp -v "$HERE"/handoff/configs/se_120b_loop0.yaml "$REPO/handoff/configs/"
+else
+  echo "keep existing: handoff/configs/se_120b_loop0.yaml"
+fi
+# 功能自检：.buffer 写法的正确解必须 pass（不依赖 git 历史）
+python3 - "$REPO" <<'PY'
+import json, subprocess, sys, tempfile, os
+repo = sys.argv[1]
+tests = {"inputs": ["3 4\n"], "outputs": ["7\n"], "testtype": "stdin"}
+code = "import sys\na,b=map(int,sys.stdin.buffer.read().split())\nprint(a+b)\n"
+with tempfile.TemporaryDirectory() as td:
+    cp, tp = os.path.join(td, "c.py"), os.path.join(td, "t.json")
+    open(cp, "w").write(code); open(tp, "w").write(json.dumps(tests))
+    r = subprocess.run([sys.executable, os.path.join(repo, "scripts", "lcb_exec_harness.py"), cp, tp],
+                      capture_output=True, text=True, timeout=60)
+    v = json.loads(r.stdout.strip().splitlines()[-1])
+    assert v.get("passed") is True, f"自检失败: {v}"
+print("自检通过: harness 修复生效 (bug absent)")
+PY
+echo "minipatch 安装完成。"

minipatch/scripts/lcb_exec_harness.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Single-sample LiveCodeBench execution harness (one subprocess per candidate).
+
+Runs an extracted code candidate against a problem's hidden test suite and prints
+a JSON verdict to stdout. Isolated in its own process so a crash / sys.exit / TLE
+in untrusted model code is contained (the parent imposes an overall timeout too).
+
+Usage:
+  python lcb_exec_harness.py <code_file> <tests_json_file>
+
+tests_json_file: {"inputs":[...], "outputs":[...], "testtype":"stdin"|"functional",
+                  "fn_name":"...", "time_limit":int}
+Verdict (stdout, last line): {"passed":bool,"error":"","n_passed":int,"n_total":int,
+                              "first_fail":int}
+
+Test semantics (standard LCB):
+  * stdin (atcoder): feed input to stdin, run as __main__ script, compare stdout
+    line-wise rstrip + overall strip.
+  * functional (leetcode): each test `input` is newline-joined JSON args; parse each
+    line with json.loads, call Solution().<fn_name>(*args) (or a bare global fn),
+    json-compare against json.loads(output) with a float / list fallback.
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import signal
+import sys
+
+# --- resource cap (best-effort; this process is the disposable subprocess) ---
+# RLIMIT_AS is the only defense against single-opcode memory bombs ([0]*b,
+# bytearray(b)): SIGALRM fires only between bytecodes, so a C-level allocation
+# fault-ins RAM until the container cgroup OOMs. See lcb_public_probe_harness.
+try:
+    import resource
+
+    def _limit_mem(mem_bytes: int) -> None:
+        try:
+            resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
+            resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+        except (ValueError, OSError):
+            pass
+except Exception:  # pragma: no cover — non-POSIX fallback
+    def _limit_mem(mem_bytes: int) -> None:
+        return None
+
+
+def _set_alarm(seconds: float) -> None:
+    def _handler(signum, frame):
+        raise TimeoutError(f"time limit exceeded ({seconds}s)")
+
+    signal.signal(signal.SIGALRM, _handler)
+    signal.setitimer(signal.ITIMER_REAL, max(0.1, seconds))
+
+
+def _cancel_alarm() -> None:
+    signal.setitimer(signal.ITIMER_REAL, 0)
+
+
+def _norm_out(s: str) -> str:
+    return "\n".join(line.rstrip() for line in str(s).strip().split("\n"))
+
+
+def _eq(got, want) -> bool:
+    if got == want:
+        return True
+    try:
+        if abs(float(got) - float(want)) < 1e-6:
+            return True
+    except (TypeError, ValueError):
+        pass
+    try:
+        if list(got) == list(want):
+            return True
+    except TypeError:
+        pass
+    return False
+
+
+def _mk_stdin(text: str):
+    """Text stream over a real byte buffer, so `sys.stdin.buffer` works.
+
+    A bare io.StringIO has no `.buffer`, which made every candidate using the
+    standard competitive-programming idiom `sys.stdin.buffer.read()` die with
+    AttributeError and score as a wrong answer regardless of correctness.
+    """
+    return io.TextIOWrapper(io.BytesIO(text.encode()), encoding="utf-8", newline="")
+
+
+def _mk_stdout():
+    """(text_stream, raw_bytes) — `.buffer` works; write_through keeps ordering
+    correct when a candidate mixes print() and sys.stdout.buffer.write()."""
+    raw = io.BytesIO()
+    return io.TextIOWrapper(raw, encoding="utf-8", newline="", write_through=True), raw
+
+
+def _stdout_value(stream, raw) -> str:
+    try:
+        stream.flush()
+    except Exception:  # noqa: BLE001  (candidate may have closed it)
+        pass
+    return raw.getvalue().decode("utf-8", "replace")
+
+
+def run_stdin(code, inputs, outputs, tl):
+    for i, (inp, exp) in enumerate(zip(inputs, outputs)):
+        stdin_text = inp if isinstance(inp, str) else "\n".join(str(x) for x in inp)
+        want = _norm_out(exp if isinstance(exp, str) else str(exp))
+        old_in, old_out = sys.stdin, sys.stdout
+        sys.stdin = _mk_stdin(stdin_text)
+        buf, buf_raw = _mk_stdout()
+        sys.stdout = buf
+        try:
+            _set_alarm(tl)
+            try:
+                exec(compile(code, "<candidate>", "exec"), {"__name__": "__main__"})
+            except SystemExit:
+                pass
+            _cancel_alarm()
+        except Exception as e:  # noqa: BLE001
+            _cancel_alarm()
+            sys.stdin, sys.stdout = old_in, old_out
+            return False, f"{type(e).__name__}: {e}", i
+        finally:
+            sys.stdin, sys.stdout = old_in, old_out
+        if _norm_out(_stdout_value(buf, buf_raw)) != want:
+            return False, "wrong_answer", i
+    return True, "", len(inputs)
+
+
+def run_functional(code, fn_name, inputs, outputs, tl):
+    g = {"__name__": "__lcb_harness__"}
+    try:
+        exec(compile(code, "<candidate>", "exec"), g)
+    except Exception as e:  # noqa: BLE001
+        return False, f"import_error: {type(e).__name__}: {e}", 0
+
+    def resolve():
+        if "Solution" in g:
+            return getattr(g["Solution"](), fn_name)
+        if fn_name in g and callable(g[fn_name]):
+            return g[fn_name]
+        return None
+
+    if resolve() is None:
+        return False, f"no_callable:{fn_name}", 0
+
+    for i, (inp, exp) in enumerate(zip(inputs, outputs)):
+        try:
+            lines = inp.split("\n") if isinstance(inp, str) else list(inp)
+            args = [json.loads(line) for line in lines]
+        except Exception:  # noqa: BLE001
+            args = [inp]
+        try:
+            want = json.loads(exp) if isinstance(exp, str) else exp
+        except Exception:  # noqa: BLE001
+            want = exp
+        try:
+            fn = resolve()  # fresh Solution() per test
+            _set_alarm(tl)
+            got = fn(*args)
+            _cancel_alarm()
+        except Exception as e:  # noqa: BLE001
+            _cancel_alarm()
+            return False, f"{type(e).__name__}: {e}", i
+        if not _eq(got, want):
+            return False, "wrong_answer", i
+    return True, "", len(inputs)
+
+
+def main() -> int:
+    _limit_mem(int(os.environ.get("LCB_EXEC_MEM_MB", "4096")) * 1024 * 1024)
+    code = open(sys.argv[1]).read()
+    tests = json.load(open(sys.argv[2]))
+    inputs, outputs = tests["inputs"], tests["outputs"]
+    tl = float(tests.get("time_limit", 6))
+    testtype = tests.get("testtype", "stdin")
+    fn_name = tests.get("fn_name", "")
+    try:
+        if testtype == "functional" and fn_name:
+            passed, err, fail_idx = run_functional(code, fn_name, inputs, outputs, tl)
+        else:
+            passed, err, fail_idx = run_stdin(code, inputs, outputs, tl)
+    except Exception as e:  # noqa: BLE001  (harness-level guard)
+        passed, err, fail_idx = False, f"harness_error: {type(e).__name__}: {e}", -1
+    n_total = len(inputs)
+    n_passed = n_total if passed else max(0, fail_idx)
+    print(json.dumps({
+        "passed": passed, "error": err,
+        "n_passed": n_passed, "n_total": n_total, "first_fail": fail_idx,
+    }))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

minipatch/scripts/lcb_probe_exec.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""P1 step 2: run a candidate on PROBE INPUTS with NO expected outputs — capture raw behavior only
+(stdout / function return / error / timeout). Used purely for cross-candidate disagreement detection;
+no correctness judgement is made or implied. Subprocess-isolated, per-input SIGALRM.
+
+argv: <code_file> <spec_json_file>   spec = {"inputs":[...], "testtype":"stdin"|"functional", "fn_name":""}
+stdout (last line) JSON: {"results":[{"kind":"output"|"error"|"timeout","value":str}, ...]}
+"""
+from __future__ import annotations
+import io, json, os, signal, sys
+
+# RLIMIT_AS cap: SIGALRM cannot interrupt single-opcode memory bombs ([0]*b);
+# see lcb_public_probe_harness.py (2026-07-20 container-OOM root cause).
+try:
+    import resource
+
+    def _limit_mem(mem_bytes: int) -> None:
+        try:
+            resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
+            resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+        except (ValueError, OSError):
+            pass
+except Exception:  # pragma: no cover — non-POSIX fallback
+    def _limit_mem(mem_bytes: int) -> None:
+        return None
+
+
+def _alarm(sec):
+    def h(s, f): raise TimeoutError("TLE")
+    signal.signal(signal.SIGALRM, h); signal.setitimer(signal.ITIMER_REAL, max(0.1, sec))
+def _cancel(): signal.setitimer(signal.ITIMER_REAL, 0)
+def _norm(s): return "\n".join(l.rstrip() for l in str(s).strip().split("\n"))
+
+
+def run_stdin(code, inputs, tl):
+    try:
+        compiled = compile(code, "<candidate>", "exec")
+    except Exception as e:  # noqa: BLE001
+        return [{"kind": "error", "value": f"compile: {type(e).__name__}"} for _ in inputs]
+    out = []
+    for inp in inputs:
+        oi, oo = sys.stdin, sys.stdout
+        # TextIOWrapper over BytesIO: bare StringIO has no .buffer, so every
+        # candidate using sys.stdin.buffer.read() died as a runtime error.
+        sys.stdin = io.TextIOWrapper(io.BytesIO(inp.encode()), encoding="utf-8", newline="")
+        obuf = io.BytesIO()
+        buf = io.TextIOWrapper(obuf, encoding="utf-8", newline="", write_through=True)
+        sys.stdout = buf
+        try:
+            _alarm(tl)
+            try:
+                exec(compiled, {"__name__": "__main__"})
+            except SystemExit:
+                pass
+            _cancel()
+            try:
+                buf.flush()
+            except Exception:  # noqa: BLE001
+                pass
+            out.append({"kind": "output", "value": _norm(obuf.getvalue().decode("utf-8", "replace"))[:1000]})
+        except TimeoutError:
+            _cancel(); out.append({"kind": "timeout", "value": ""})
+        except Exception as e:  # noqa: BLE001
+            _cancel(); out.append({"kind": "error", "value": f"{type(e).__name__}"})
+        finally:
+            sys.stdin, sys.stdout = oi, oo
+    return out
+
+
+def run_functional(code, fn_name, inputs, tl):
+    g = {"__name__": "__probe__"}
+    try:
+        exec(compile(code, "<candidate>", "exec"), g)
+    except Exception as e:  # noqa: BLE001
+        return [{"kind": "error", "value": f"compile: {type(e).__name__}"} for _ in inputs]
+    def resolve():
+        if "Solution" in g:
+            try: return getattr(g["Solution"](), fn_name)
+            except Exception: return None
+        f = g.get(fn_name); return f if callable(f) else None
+    if resolve() is None:
+        return [{"kind": "error", "value": "no_callable"} for _ in inputs]
+    out = []
+    for inp in inputs:
+        try:
+            args = [json.loads(x) for x in str(inp).split("\n") if x.strip()]
+        except Exception:
+            args = [inp]
+        try:
+            fn = resolve(); _alarm(tl); res = fn(*args); _cancel()
+            out.append({"kind": "output", "value": repr(res)[:1000]})
+        except TimeoutError:
+            _cancel(); out.append({"kind": "timeout", "value": ""})
+        except Exception as e:  # noqa: BLE001
+            _cancel(); out.append({"kind": "error", "value": f"{type(e).__name__}"})
+    return out
+
+
+def main():
+    _limit_mem(int(os.environ.get("LCB_EXEC_MEM_MB", "4096")) * 1024 * 1024)
+    code = open(sys.argv[1]).read()
+    spec = json.load(open(sys.argv[2]))
+    inputs = spec["inputs"]; tl = float(spec.get("time_limit", 6))
+    if spec.get("testtype") == "functional" and spec.get("fn_name"):
+        res = run_functional(code, spec["fn_name"], inputs, tl)
+    else:
+        res = run_stdin(code, inputs, tl)
+    print(json.dumps({"results": res}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

minipatch/scripts/lcb_public_probe_harness.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Run a candidate against PUBLIC (non-hidden) LCB tests and return DETAILED, structured results
+for building non-leaky execution feedback (V2/V3/V4 in the LCB feedback-repair probe).
+
+Subprocess-isolated (untrusted code), per-test SIGALRM timeout. NEVER touches hidden tests.
+
+argv: <code_file> <public_tests_json_file>   (tests json = {inputs,outputs,testtype,fn_name,time_limit})
+stdout (last line) JSON: {"category","n_pass","n_total","first_fail":{idx,input,expected,actual,error}|null}
+category in: compile_error | runtime_error | wrong_answer | timeout | all_pass | no_callable
+"""
+from __future__ import annotations
+import io, json, os, signal, sys
+
+# --- resource cap (best-effort; this process is the disposable subprocess) ---
+# RLIMIT_AS is the only defense that works against single-opcode memory bombs
+# ([0]*b, bytearray(b)): SIGALRM only fires between bytecodes, so a C-level
+# allocation fault-ins RAM until the CONTAINER cgroup OOMs (2026-07-20 root
+# cause: cc-05672 naive-expansion candidates killed both the 20B and 120B
+# shard04 nodes mid-loop-1 feedback exec). With the cap, the bomb raises
+# MemoryError in microseconds and becomes useful runtime_error feedback.
+try:
+    import resource
+
+    def _limit_mem(mem_bytes: int) -> None:
+        try:
+            resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
+            resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+        except (ValueError, OSError):
+            pass
+except Exception:  # pragma: no cover — non-POSIX fallback
+    def _limit_mem(mem_bytes: int) -> None:
+        return None
+
+
+def _alarm(sec):
+    def h(s, f): raise TimeoutError(f"TLE {sec}s")
+    signal.signal(signal.SIGALRM, h); signal.setitimer(signal.ITIMER_REAL, max(0.1, sec))
+def _cancel(): signal.setitimer(signal.ITIMER_REAL, 0)
+def _norm(s): return "\n".join(l.rstrip() for l in str(s).strip().split("\n"))
+
+
+def _drain(stream, raw):
+    """Text written through `stream` plus anything written straight to its .buffer."""
+    try:
+        stream.flush()
+    except Exception:  # noqa: BLE001  (candidate may have closed it)
+        pass
+    return raw.getvalue().decode("utf-8", "replace")
+
+
+def run_stdin(code, inputs, outputs, tl, max_fails=1):
+    # max_fails=1 (default) reproduces the historical stop-at-first-failure behavior exactly.
+    # max_fails>1 keeps executing after a failure and collects up to max_fails failing cases
+    # (each tagged with its category) so the feedback operator can show more than one bug signal.
+    # compile once to detect syntax/compile errors up front
+    try:
+        compiled = compile(code, "<candidate>", "exec")
+    except Exception as e:  # noqa: BLE001
+        return ("compile_error", 0, len(inputs), 0,
+                [{"idx": -1, "input": None, "expected": None, "actual": None,
+                  "error": f"{type(e).__name__}: {e}", "kind": "compile_error"}])
+    npass = 0
+    fails = []
+    n_ran = 0
+    for i, (inp, exp) in enumerate(zip(inputs, outputs)):
+        n_ran = i + 1
+        stdin = inp if isinstance(inp, str) else "\n".join(str(x) for x in inp)
+        want = _norm(exp if isinstance(exp, str) else str(exp))
+        oi, oo = sys.stdin, sys.stdout
+        # TextIOWrapper over BytesIO so candidates using sys.stdin.buffer.read()
+        # / sys.stdout.buffer.write() (ubiquitous in CP code) work too — bare
+        # StringIO has no .buffer and crashed them all as runtime_error, which
+        # then fed a bogus "your solution crashed" message back to the model.
+        sys.stdin = io.TextIOWrapper(io.BytesIO(stdin.encode()), encoding="utf-8", newline="")
+        obuf = io.BytesIO()
+        buf = io.TextIOWrapper(obuf, encoding="utf-8", newline="", write_through=True)
+        sys.stdout = buf
+        try:
+            _alarm(tl)
+            try:
+                exec(compiled, {"__name__": "__main__"})
+            except SystemExit:
+                pass
+            _cancel()
+        except TimeoutError as e:
+            _cancel(); sys.stdin, sys.stdout = oi, oo
+            fails.append({"idx": i, "input": stdin, "expected": want, "actual": None,
+                          "error": str(e), "kind": "timeout"})
+            if len(fails) >= max_fails: break
+            continue
+        except Exception as e:  # noqa: BLE001
+            _cancel(); sys.stdin, sys.stdout = oi, oo
+            fails.append({"idx": i, "input": stdin, "expected": want, "actual": None,
+                          "error": f"{type(e).__name__}: {e}", "kind": "runtime_error"})
+            if len(fails) >= max_fails: break
+            continue
+        finally:
+            sys.stdin, sys.stdout = oi, oo
+        got = _norm(_drain(buf, obuf))
+        if got == want:
+            npass += 1
+        else:
+            fails.append({"idx": i, "input": stdin, "expected": want, "actual": got[:2000],
+                          "kind": "wrong_answer"})
+            if len(fails) >= max_fails: break
+    cat = fails[0]["kind"] if fails else "all_pass"
+    return (cat, npass, len(inputs), n_ran, fails)
+
+
+def run_functional(code, fn_name, inputs, outputs, tl):
+    g = {"__name__": "__h__"}
+    try:
+        exec(compile(code, "<candidate>", "exec"), g)
+    except Exception as e:  # noqa: BLE001
+        return ("compile_error", 0, len(inputs), {"idx": -1, "input": None, "expected": None, "actual": None, "error": f"{type(e).__name__}: {e}"})
+    def resolve():
+        if "Solution" in g:
+            try: return getattr(g["Solution"](), fn_name)
+            except Exception: return None
+        return g.get(fn_name) if callable(g.get(fn_name)) else None
+    if resolve() is None:
+        return ("no_callable", 0, len(inputs), {"idx": -1, "input": None, "expected": None, "actual": None, "error": f"no callable {fn_name}"})
+    npass = 0
+    for i, (inp, exp) in enumerate(zip(inputs, outputs)):
+        try:
+            args = [json.loads(x) for x in (inp.split("\n") if isinstance(inp, str) else list(inp))]
+        except Exception:
+            args = [inp]
+        try:
+            want = json.loads(exp) if isinstance(exp, str) else exp
+        except Exception:
+            want = exp
+        try:
+            fn = resolve(); _alarm(tl); got = fn(*args); _cancel()
+        except TimeoutError as e:
+            _cancel(); return ("timeout", npass, len(inputs), {"idx": i, "input": str(inp), "expected": str(want), "actual": None, "error": str(e)})
+        except Exception as e:  # noqa: BLE001
+            _cancel(); return ("runtime_error", npass, len(inputs), {"idx": i, "input": str(inp), "expected": str(want), "actual": None, "error": f"{type(e).__name__}: {e}"})
+        if got == want or str(got) == str(want):
+            npass += 1
+        else:
+            return ("wrong_answer", npass, len(inputs), {"idx": i, "input": str(inp), "expected": str(want), "actual": str(got)[:2000]})
+    return ("all_pass", npass, len(inputs), None)
+
+
+def main():
+    _limit_mem(int(os.environ.get("LCB_EXEC_MEM_MB", "4096")) * 1024 * 1024)
+    code = open(sys.argv[1]).read()
+    t = json.load(open(sys.argv[2]))
+    inp, out = t["inputs"], t["outputs"]; tl = float(t.get("time_limit", 6))
+    max_fails = max(1, int(os.environ.get("LCB_PROBE_MAX_FAILS", "1")))
+    if t.get("testtype") == "functional" and t.get("fn_name"):
+        # functional path keeps stop-at-first-failure (no multi-fail need yet)
+        cat, npass, ntot, ff = run_functional(code, t["fn_name"], inp, out, tl)
+        n_ran, fails = (ff["idx"] + 1 if ff and ff.get("idx", -1) >= 0 else ntot), ([ff] if ff else [])
+    else:
+        cat, npass, ntot, n_ran, fails = run_stdin(code, inp, out, tl, max_fails=max_fails)
+    print(json.dumps({"category": cat, "n_pass": npass, "n_total": ntot, "n_ran": n_ran,
+                      "first_fail": (fails[0] if fails else None), "fails": fails}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

minipatch/scripts/verify_stdin_buffer_bug.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Self-contained check for the `sys.stdin.buffer` harness bug. Trusts nothing.
+
+Run with no arguments for levels 1-2 (a few seconds, no data needed):
+
+    python scripts/verify_stdin_buffer_bug.py
+
+Add a run directory from tts-sft/round2-oss-matched to also run level 3 against
+real shipped results:
+
+    python scripts/verify_stdin_buffer_bug.py --run-dir <DATA>/exp3_120b/node03
+
+Level 1  a property of Python itself — no repo, no data, no analysis involved.
+Level 2  this repo's grading harness, on a hand-written solution that is
+         obviously correct, at the current commit and at the pre-fix commit.
+Level 3  real shipped candidates the fleet graded 0/16, re-executed here.
+
+Exit code 0 = the bug is absent (harness handles .buffer). 1 = present.
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# Correct solution to "read two ints, print their sum", written the way gpt-oss
+# writes it. There is no argument to be had about whether this is correct.
+BUFFER_SOLUTION = "import sys\na, b = map(int, sys.stdin.buffer.read().split())\nprint(a + b)\n"
+PLAIN_SOLUTION = "a, b = map(int, input().split())\nprint(a + b)\n"
+WRONG_SOLUTION = "a, b = map(int, input().split())\nprint(a - b)\n"
+TESTS = {"inputs": ["2 3\n"], "outputs": ["5\n"], "testtype": "stdin"}
+
+
+def level1() -> bool:
+    print("LEVEL 1 — plain Python, nothing to do with this repo")
+    print("    sys.stdin = io.StringIO('2 3'); sys.stdin.buffer.read()")
+    old = sys.stdin
+    sys.stdin = io.StringIO("2 3\n")
+    try:
+        sys.stdin.buffer.read()
+        print("    -> no error (this Python has .buffer on StringIO?!)\n")
+        return True
+    except AttributeError as e:
+        print(f"    -> AttributeError: {e}")
+        print("    Any candidate reading input this way dies here, correct or not.\n")
+        return False
+    finally:
+        sys.stdin = old
+
+
+def _verdict(harness: str, code: str) -> dict:
+    cf = tempfile.NamedTemporaryFile("w", suffix=".py", delete=False)
+    cf.write(code); cf.close()
+    tf = tempfile.NamedTemporaryFile("w", suffix=".json", delete=False)
+    json.dump(TESTS, tf); tf.close()
+    try:
+        p = subprocess.run([sys.executable, harness, cf.name, tf.name],
+                           capture_output=True, text=True, timeout=60)
+        out = p.stdout.strip().splitlines()
+        return json.loads(out[-1]) if out else {"error": (p.stderr or "")[:200]}
+    finally:
+        os.unlink(cf.name); os.unlink(tf.name)
+
+
+def level2() -> bool:
+    print("LEVEL 2 — this repo's grading harness on a hand-written correct solution")
+    harness = os.path.join(REPO, "scripts", "lcb_exec_harness.py")
+
+    old_harness = None
+    try:  # the harness as it was before the fix, straight out of git
+        blob = subprocess.run(
+            ["git", "-C", REPO, "show", "HEAD~1:scripts/lcb_exec_harness.py"],
+            capture_output=True, text=True, timeout=30)
+        if blob.returncode == 0 and "def run_stdin" in blob.stdout:
+            f = tempfile.NamedTemporaryFile("w", suffix=".py", delete=False)
+            f.write(blob.stdout); f.close()
+            old_harness = f.name
+    except Exception:  # noqa: BLE001
+        pass
+
+    ok = True
+    rows = [("sys.stdin.buffer.read()  [correct]", BUFFER_SOLUTION, True),
+            ("input()                  [correct]", PLAIN_SOLUTION, True),
+            ("input(), prints a-b      [WRONG]  ", WRONG_SOLUTION, False)]
+    print(f"    {'candidate':38} {'pre-fix':>12} {'current':>12}  {'expected':>10}")
+    for label, code, want in rows:
+        cur = bool(_verdict(harness, code).get("passed"))
+        pre = "n/a"
+        if old_harness:
+            pre = "PASS" if _verdict(old_harness, code).get("passed") else "fail"
+        print(f"    {label:38} {pre:>12} {'PASS' if cur else 'fail':>12}"
+              f"  {'PASS' if want else 'fail':>10}")
+        if cur != want:
+            ok = False
+    if old_harness:
+        os.unlink(old_harness)
+    print("    A correct solution scored 'fail' is the bug. A wrong one must still fail.\n")
+    return ok
+
+
+def level3(run_dir: str) -> bool:
+    print(f"LEVEL 3 — real shipped candidates from {run_dir}")
+    sys.path.insert(0, os.path.join(REPO, "scripts"))
+    sys.path.insert(0, os.path.join(REPO, "handoff", "scripts"))
+    import csv
+    from score_diversify_ab import extract_code
+    from grade_v2_lib import _job_for
+    from lcb_grading import _run_once
+
+    csv_path = os.path.join(run_dir, "final_grade_per_problem.csv")
+    graded0 = [r["id"] for r in csv.DictReader(open(csv_path))
+               if int(r["correct_count"]) == 0 and r["format"] == "stdin_stdout"]
+    print(f"    the fleet graded {len(graded0)} stdin problems 0/16; checking the first 5")
+
+    pool = {}
+    for line in open(os.path.join(run_dir, "pool.jsonl")):
+        r = json.loads(line)
+        pool[r["seed_id"]] = r
+    want = set(graded0[:5])
+    outs = {}
+    for line in open(os.path.join(run_dir, "loops.out.jsonl")):
+        d = json.loads(line)
+        if d["id"] in want:
+            outs[d["id"]] = d
+
+    bad = 0
+    for pid in graded0[:5]:
+        harness, tj, n, tl = _job_for(pool[pid], REPO, 8.0)
+        code = extract_code((outs[pid].get("candidates") or [""])[0])
+        v = _run_once(harness, code, tj, n, tl) or {}
+        ok = bool(v.get("passed"))
+        bad += ok
+        print(f"    {pid:>12}  fleet said 0/16  |  here: "
+              f"{'PASSES all ' + str(n) + ' ground-truth tests' if ok else 'fails: ' + str(v.get('error'))[:50]}")
+    print(f"    {bad}/5 of the fleet's zeros actually pass.\n")
+    return bad == 0
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--run-dir", help="a node dir with final_grade_per_problem.csv, "
+                                      "pool.jsonl and loops.out.jsonl")
+    a = ap.parse_args()
+    level1()
+    clean = level2()
+    if a.run_dir:
+        clean = level3(a.run_dir) and clean
+    print("VERDICT:", "harness handles .buffer — bug absent" if clean
+          else "correct solutions are being scored wrong — bug present")
+    sys.exit(0 if clean else 1)