#!/usr/bin/env python3 """RT-cut patch: --emit-top-k, --blocked-restart (prepare); trace-exec (harness); trace + restart rendering (renderer). All opt-in; bit-identical when off.""" import sys def apply(path, edits): s = open(path).read() for old, new in edits: n = s.count(old) if n != 1: sys.exit(f"ANCHOR FAIL in {path} ({n}): {old[:80]!r}") s = s.replace(old, new) open(path, "w").write(s) print(f"{path}: {len(edits)} edits") # ── prepare: emit-top-k + blocked-restart ──────────────────────────────── P = "minipatch/selffb/selffb_v2_prepare.py" apply(P, [ # emit-top-k truncation at emission (""" if merged: pub = {"inputs": [t["input"] for t in merged], "outputs": [t["output"] for t in merged]}""", """ emit = merged[:args.emit_top_k] if args.emit_top_k > 0 else merged if emit: pub = {"inputs": [t["input"] for t in emit], "outputs": [t["output"] for t in emit]}"""), (""" if any(t.get("out_validator") for t in merged): # D-cut (C): per-test property validators ride inside # public_tests verbatim to the (patched) probe harness pub["out_validators"] = [t.get("out_validator") for t in merged] rec = {"id": pid, "n_tests": len(merged), "public_tests": json.dumps(pub)}""", """ if any(t.get("out_validator") for t in emit): # D-cut (C): per-test property validators ride inside # public_tests verbatim to the (patched) probe harness pub["out_validators"] = [t.get("out_validator") for t in emit] rec = {"id": pid, "n_tests": len(emit), "public_tests": json.dumps(pub)}"""), # streak machinery now also serves blocked-restart (""" fire_counts = None if merged and (args.emit_order == "failcount" or args.fb_summary or args.trace_repair):""", """ fire_counts = None if merged and (args.emit_order == "failcount" or args.fb_summary or args.trace_repair or args.blocked_restart):"""), (""" if args.trace_repair: blocked = sum(1 for res in mres if any(test_fires(res[j], t) for j, t in enumerate(merged))) funnel["trace_blocked_frac"] = round( blocked / max(1, len(fc_cands)), 3)""", """ if args.trace_repair or args.blocked_restart: blocked = sum(1 for res in mres if any(test_fires(res[j], t) for j, t in enumerate(merged))) funnel["trace_blocked_frac"] = round( blocked / max(1, len(fc_cands)), 3)"""), (""" if args.trace_repair and fire_counts: bf = funnel.get("trace_blocked_frac", 0.0)""", """ if (args.trace_repair or args.blocked_restart) and fire_counts: bf = funnel.get("trace_blocked_frac", 0.0)"""), (""" funnel["trace_streak"] = streak if streak >= args.trace_streak and max(fire_counts) > 0:""", """ funnel["trace_streak"] = streak # ── RT-cut: blocked-restart — population-level diversity injection. # Under the canonical operator all parents share ONE prompt, so # restart = show only the best few failed parents and demand # structurally different fresh attempts (renderer side). if (args.blocked_restart and streak >= args.trace_streak): async with lock: with open(args.out + ".restart.jsonl", "a") as rf: rf.write(json.dumps({"id": pid, "loop": args.loop, "keep": args.restart_keep}) + "\\n") funnel["restart_fired"] = True if args.trace_repair and streak >= args.trace_streak and max(fire_counts) > 0:"""), (""" ap.add_argument("--trace-blocked-frac", type=float, default=0.5) ap.add_argument("--trace-streak", type=int, default=2)""", """ ap.add_argument("--trace-blocked-frac", type=float, default=0.5) ap.add_argument("--trace-streak", type=int, default=2) ap.add_argument("--emit-top-k", type=int, default=0, help="emit only the first K tests of the (ordered) bank to " "the feedback suite (0 = all); bank itself unchanged") ap.add_argument("--blocked-restart", action="store_true", help="RT-cut: on trace-streak, write a restart row -> the " "renderer shows only --restart-keep parents and demands " "structurally fresh attempts (diversity injection)") ap.add_argument("--restart-keep", type=int, default=4)"""), ]) # fix: the trace-repair summary emission was indented under its old `if`; the # new combined gate rewrote only the header. Verify the jtop block still refers # to the right condition (it now sits under the trace_repair-only if above). # ── harness: instrumented execution trace on first fail ────────────────── H = "minipatch/scripts/lcb_public_probe_harness_spj.py" apply(H, [ ("""def run_stdin(code, inputs, outputs, tl, max_fails=1, checker_path=None, order=None, oval_paths=None):""", '''def _traced_exec(compiled, stdin_text, tl, src, max_events=48): """RT-cut (env LCB_TRACE_EXEC=1): re-execute ONE failing test under sys.settrace, returning a compact "last executed lines + variable changes" trace (the DebugRepair/TraceCoder-style runtime-state channel). Best-effort: any tracer failure returns None and the feedback is unchanged.""" lines = src.split("\\n") events, prev = [], {} def tracer(frame, event, arg): if event == "line" and frame.f_code.co_filename == "": ch = {} try: for k, v in list(frame.f_locals.items()): if k.startswith("__"): continue try: r = repr(v) except Exception: # noqa: BLE001 r = "" if len(r) > 48: r = r[:45] + "..." if prev.get(k) != r: ch[k] = r prev[k] = r except Exception: # noqa: BLE001 pass events.append((frame.f_lineno, ch)) if len(events) > max_events: events.pop(0) return tracer old_in, old_out = sys.stdin, sys.stdout sys.stdin = _mk_stdin(stdin_text) buf, raw = _mk_stdout() sys.stdout = buf tail = "" try: sys.settrace(tracer) _alarm(min(tl, 5.0)) try: exec(compiled, {"__name__": "__main__"}) except SystemExit: pass _cancel() except TimeoutError: _cancel(); tail = "\\n[trace cut: TIME LIMIT hit here — the lines above are the hot loop]" except Exception as e: # noqa: BLE001 _cancel(); tail = f"\\n[trace ends at the raising line: {type(e).__name__}: {e}]" finally: sys.settrace(None) sys.stdin, sys.stdout = old_in, old_out if not events: return None out = [] for ln, ch in events[-max_events:]: srcl = lines[ln - 1].strip() if 0 < ln <= len(lines) else "?" s = f"L{ln}: {srcl[:90]}" if ch: s += " || " + ", ".join(f"{k}={v}" for k, v in list(ch.items())[:6]) out.append(s) txt = "\\n".join(out) + tail return txt[-2400:] def run_stdin(code, inputs, outputs, tl, max_fails=1, checker_path=None, order=None, oval_paths=None):'''), (""" cat = fails[0]["kind"] if fails else "all_pass" return (cat, npass, len(inputs), n_ran, fails)""", """ cat = fails[0]["kind"] if fails else "all_pass" if (fails and os.environ.get("LCB_TRACE_EXEC") and fails[0].get("input") is not None and fails[0]["kind"] in ("wrong_answer", "runtime_error", "timeout")): try: compiled2 = compile(code, "", "exec") tr = _traced_exec(compiled2, fails[0]["input"], tl, code) if tr: fails[0]["trace"] = tr except Exception: # noqa: BLE001 pass return (cat, npass, len(inputs), n_ran, fails)"""), ]) # ── renderer: show trace; restart mode ─────────────────────────────────── A = "minipatch/benchmarks/livecodebench/_feedback_aggregate.py" apply(A, [ (""" if kind == "wrong_answer": parts.append(f"[test {f.get('idx')}] wrong_answer\\nInput:\\n{_trunc(f.get('input'))}\\n" f"Expected output:\\n{_trunc(f.get('expected'))}\\nActual output:\\n{_trunc(f.get('actual'))}") elif kind in ("runtime_error", "no_callable", "compile_error"): parts.append(f"[test {f.get('idx')}] {kind}\\nInput:\\n{_trunc(f.get('input'))}\\n" f"Error:\\n{_trunc(f.get('error'), 300)}")""", """ if kind == "wrong_answer": parts.append(f"[test {f.get('idx')}] wrong_answer\\nInput:\\n{_trunc(f.get('input'))}\\n" f"Expected output:\\n{_trunc(f.get('expected'))}\\nActual output:\\n{_trunc(f.get('actual'))}") elif kind in ("runtime_error", "no_callable", "compile_error"): parts.append(f"[test {f.get('idx')}] {kind}\\nInput:\\n{_trunc(f.get('input'))}\\n" f"Error:\\n{_trunc(f.get('error'), 300)}") if f.get("trace"): # RT-cut: actual runtime states beat outcome-only feedback parts.append("RUNTIME TRACE of THIS code on that input (last executed " "lines, with variable changes) — find the first line where " "the state diverges from what the statement requires:\\n" + _trunc(f.get("trace"), 2400))"""), ]) C = "minipatch/benchmarks/livecodebench/_feedback_canonical.py" apply(C, [ (""" parts, n_blocks = [], 0 summ = _summary_for(pid)""", """ parts, n_blocks = [], 0 # RT-cut restart mode: LCB_FB_RESTART jsonl of {id, loop, keep} (last row # wins). For flagged problems show only the FIRST `keep` parents and # demand structurally different fresh attempts. Env unset -> identical. restart_keep = None rp = os.environ.get("LCB_FB_RESTART") if rp and os.path.exists(rp): try: for _line in open(rp): _r = json.loads(_line) if str(_r.get("id")) == str(pid): restart_keep = int(_r.get("keep", 4)) except Exception: # noqa: BLE001 restart_keep = None summ = _summary_for(pid)"""), (""" for j, (c, a) in enumerate(zip(candidates, fbs), 1): parts.append(f"\\n---- Solution {j} ----\\n{(c or '').strip()}\\n") if a[0] is not None: parts.append(f"---- Visible feedback on Solution {j} ----\\n{a[0]}\\n") n_blocks += 1""", """ shown = candidates if restart_keep is None else candidates[:max(1, restart_keep)] for j, (c, a) in enumerate(zip(shown, fbs), 1): parts.append(f"\\n---- Solution {j} ----\\n{(c or '').strip()}\\n") if a[0] is not None: parts.append(f"---- Visible feedback on Solution {j} ----\\n{a[0]}\\n") n_blocks += 1 if restart_keep is not None: parts.append( "\\n---- RESTART DIRECTIVE ----\\n" f"This problem has resisted repair for multiple rounds; only {len(shown)} " "of the failed attempts are shown above. Do NOT produce another variation " "of those approaches — they share a flaw. Re-read the statement from " "scratch and write a structurally DIFFERENT solution: different algorithm, " "different reading of the tricky clause, or a simple brute-force if limits " "allow. Diversity matters more than polish this round.\\n")""" ), ]) print("patch v3 complete")