patch_v3.py

#!/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 == "<candidate>":
            ch = {}
            try:
                for k, v in list(frame.f_locals.items()):
                    if k.startswith("__"):
                        continue
                    try:
                        r = repr(v)
                    except Exception:  # noqa: BLE001
                        r = "<unrepr>"
                    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, "<candidate>", "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")