alphaengine 1.0.1__tar.gz → 1.0.2__tar.gz

{alphaengine-1.0.1 → alphaengine-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: alphaengine
-Version: 1.0.1
+Version: 1.0.2
 Summary: Validated research tooling for investment strategies: deflation, overfitting detection, and honest trial counts.
 Project-URL: Homepage, https://github.com/quantOSC/alphaengine
 Project-URL: Documentation, https://github.com/quantOSC/alphaengine#readme

{alphaengine-1.0.1 → alphaengine-1.0.2}/src/alphaengine/_version.py

@@ -143,4 +143,11 @@ is what a changed figure costs. The API may still move underneath it.
 # the sample-count divisor in Ledoit-Wolf shrinkage so hierarchical risk parity
 # and risk parity differentiate weights across a 50-name panel, and writes a
 # multi-page portfolio, scenario, Monte Carlo, and bakeoff report to Downloads.
-__version__ = "1.0.1"
+#
+# 1.0.2 IS THE FOUR-PASS GAN BAKEOFF. No golden in tests/test_goldens.py moves.
+# The bakeoff tournament runs four adversarial passes (eight candidate proposals
+# across `equal`, `hrp`, `risk_parity`, `inverse_vol`, `var_sorted`, `low_vol`,
+# `momentum`, and `reversion` against eight regime, tail, rate, and crash-cluster
+# attacks) under a hard twelve-call, sixty-second ceiling, feeding the referee's
+# post-attack standing back to the board after every pass.
+__version__ = "1.0.2"

alphaengine-1.0.2/src/alphaengine/agent/bakeoff.py

@@ -0,0 +1,398 @@
+"""Bakeoff mode. Two roles, one clock, and a referee that does not take votes.
+
+Generators may submit a rule. An adversary may submit an attack. Neither may
+start another bakeoff, and neither may name the survivor. The loop is four
+passes of two proposals plus one attack after each pass: twelve model calls,
+and then it stops even if a model asks to continue.
+
+The clock is the other stop. The default budget is 45 seconds. Nothing can
+stretch it past 60. When the budget is gone, the call in flight is abandoned
+and the referee scores whatever already came back.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from ..core.bakeoff import ATTACKS, RULES, referee, trial_paths
+from .sim import Call, Think, Trace
+
+DEFAULT_SECONDS = 45.0
+HARD_CEILING = 60.0
+MAX_ROUNDS = 4
+MAX_SEATS = 2
+
+_DROPPED = {"winner", "survivor", "score", "sharpe", "verdict", "deflated_sharpe"}
+
+_GENERATOR = """BAKEOFF GENERATOR
+Pass @@ROUND@@ of @@ROUNDS@@ (Seat @@SEAT@@ of @@SEATS@@).
+Propose one strategy that survives the adversary's active attacks and improves on
+the current leader's post-attack standing. Do not repeat a rule+lookback+names
+already on the board. You do not score it, you do not name a winner, and you
+do not start another bakeoff.
+Rules: @@RULES@@
+lookback (5 to 60) sets the signal window for momentum/reversion or the calibration
+window for hrp, risk_parity, inverse_vol, var_sorted, and low_vol.
+Optional names: a subset of 2 to 12 symbols from [@@NAMES@@].
+Active attacks: @@ACTIVE_ATTACKS@@
+Question:
+@@QUESTION@@
+Board:
+@@BOARD@@
+Reply with one JSON object: {"rule": "hrp", "lookback": 30, "why": "short reason"}
+"""
+
+_ADVERSARY = """BAKEOFF ADVERSARY
+Pass @@ROUND@@ of @@ROUNDS@@.
+Name one attack to stress the current leader's regime or tail vulnerability.
+Prefer an attack from Unused attacks so each pass adds a new stress dimension.
+You do not propose a rule, you do not name a winner, and you do not start another bakeoff.
+Attacks: @@ATTACKS@@
+Active attacks: @@ACTIVE_ATTACKS@@
+Unused attacks: @@UNUSED_ATTACKS@@
+Question:
+@@QUESTION@@
+Board:
+@@BOARD@@
+Reply with one JSON object: {"attack": "tail_stress", "why": "short reason"}
+"""
+
+
+@dataclass
+class Bakeoff:
+    """The trace the session shows, and the figures a tool result is allowed to carry."""
+
+    trace: Trace
+    figures: dict[str, Any]
+
+
+def run_bakeoff(
+    question: str,
+    think: Think,
+    data: Any,
+    *,
+    rounds: int = MAX_ROUNDS,
+    seats: int = MAX_SEATS,
+    seconds: float = DEFAULT_SECONDS,
+    on_call: Callable[[Call], None] | None = None,
+) -> Bakeoff:
+    """Run one bakeoff. Returns when the rounds end or the clock does, whichever is first."""
+    budget = _budget(seconds)
+    deadline = time.monotonic() + budget
+    n_rounds = min(max(int(rounds), 1), MAX_ROUNDS)
+    n_seats = min(max(int(seats), 1), MAX_SEATS)
+    submissions: list[dict[str, Any]] = []
+    attacks: list[str] = []
+    passes: list[dict[str, Any]] = []
+    trace = Trace(question=question)
+    stopped = "complete"
+    names = _universe_names(data)
+
+    def board() -> str:
+        if not submissions and not attacks:
+            return "nothing proposed yet"
+        scored = referee(data, submissions, attacks)
+        lines = list(scored.get("trials") or [])
+        if scored.get("survivor"):
+            lines.append(
+                f"leader {scored.get('survivor')}  "
+                f"sharpe {scored.get('survivor_sharpe')}  "
+                f"standing {scored.get('attacked_sharpe')}"
+            )
+        if attacks:
+            lines.append("attacks " + ", ".join(dict.fromkeys(attacks)))
+        return "\n".join(str(line) for line in lines) or "nothing proposed yet"
+
+    def emit(call: Call) -> None:
+        trace.calls.append(call)
+        if on_call is not None:
+            on_call(call)
+
+    for round_idx in range(1, n_rounds + 1):
+        for seat_idx in range(1, n_seats + 1):
+            prompt = _fill(
+                _GENERATOR,
+                question,
+                board(),
+                round_idx=round_idx,
+                n_rounds=n_rounds,
+                seat_idx=seat_idx,
+                n_seats=n_seats,
+                attacks=attacks,
+                names=names,
+            )
+            text, in_time = _ask(think, prompt, deadline)
+            if not in_time:
+                stopped = "clock"
+                break
+            submission, why = _proposal(text)
+            submission["_round"] = round_idx
+            submission["_seat"] = seat_idx
+            submissions.append(submission)
+            emit(_submit_call(data, submissions, attacks, submission, why, round_idx, seat_idx))
+        if stopped == "clock":
+            break
+        prompt = _fill(
+            _ADVERSARY,
+            question,
+            board(),
+            round_idx=round_idx,
+            n_rounds=n_rounds,
+            seat_idx=0,
+            n_seats=n_seats,
+            attacks=attacks,
+            names=names,
+        )
+        text, in_time = _ask(think, prompt, deadline)
+        if not in_time:
+            stopped = "clock"
+            break
+        attack, why = _attack(text)
+        if attack is None:
+            emit(
+                Call(
+                    tool="attack",
+                    args={"pass": round_idx},
+                    error="that attack is not in the menu",
+                )
+            )
+            continue
+        attacks.append(attack)
+        scored_pass = referee(data, submissions, attacks)
+        passes.append(
+            {
+                "pass": round_idx,
+                "attack": attack,
+                "why": why,
+                "leader": scored_pass.get("survivor"),
+                "leader_sharpe": scored_pass.get("survivor_sharpe"),
+                "leader_standing": scored_pass.get("attacked_sharpe"),
+                "n_trials": len(submissions),
+            }
+        )
+        emit(_attack_call(scored_pass, attack, why, round_idx))
+
+    figures = referee(data, submissions, attacks)
+    elapsed = min(budget, time.monotonic() - (deadline - budget))
+    figures["seconds"] = round(elapsed, 1)
+    figures["stopped"] = stopped
+    figures["budget_seconds"] = budget
+    figures["n_passes"] = len(passes) or n_rounds
+    trace.answer = _verdict(figures)
+    curves = trial_paths(data, submissions, attacks)
+    survivor_label = str(figures.get("survivor") or "")
+    survivor_curve = next((c for c in curves if c.get("label") == survivor_label), None)
+    trace.bakeoff = {
+        "survivor": figures.get("survivor"),
+        "survivor_sharpe": figures.get("survivor_sharpe"),
+        "attacked_sharpe": figures.get("attacked_sharpe"),
+        "deflated_sharpe": figures.get("deflated_sharpe"),
+        "verdict": figures.get("verdict"),
+        "n_trials": figures.get("n_trials"),
+        "n_failed": figures.get("n_failed"),
+        "n_passes": len(passes) or n_rounds,
+        "attacks": list(figures.get("attacks") or []),
+        "trials": list(figures.get("trials") or []),
+        "passes": passes,
+        "curves": curves,
+        "survivor_weights": (survivor_curve or {}).get("weights") or {},
+    }
+    return Bakeoff(trace=trace, figures=figures)
+
+
+def _submit_call(
+    data: Any,
+    submissions: list[dict[str, Any]],
+    attacks: list[str],
+    submission: dict[str, Any],
+    why: str,
+    round_idx: int,
+    seat_idx: int,
+) -> Call:
+    clean_args = {k: v for k, v in submission.items() if not str(k).startswith("_")}
+    scored = referee(data, submissions, attacks)
+    trials = list(scored.get("trials") or [])
+    last_line = str(trials[-1]) if trials else ""
+    rule_name = str(submission.get("rule") or "")
+    if not rule_name or "that rule is not in the bakeoff" in last_line:
+        return Call(
+            tool="submit",
+            args=clean_args,
+            figures={"pass": round_idx, "seat": seat_idx, "rule": rule_name or "refused"},
+            note=f"pass {round_idx}.{seat_idx}  refused",
+        )
+    parts = last_line.split()
+    label = parts[1] if len(parts) > 1 else rule_name
+    call_figs: dict[str, Any] = {
+        "pass": round_idx,
+        "seat": seat_idx,
+        "proposal": label,
+        "leader": scored.get("survivor"),
+        "leader_standing": scored.get("attacked_sharpe"),
+    }
+    if "lookback" in clean_args:
+        call_figs["lookback"] = clean_args["lookback"]
+    if why:
+        call_figs["why"] = why
+    note_tail = " ".join(parts[1:]) if len(parts) > 1 else rule_name
+    note = f"pass {round_idx}.{seat_idx}  {note_tail}"
+    return Call(tool="submit", args=clean_args, figures=call_figs, note=note)
+
+
+def _attack_call(
+    scored: dict[str, Any],
+    attack: str,
+    why: str,
+    round_idx: int,
+) -> Call:
+    leader = scored.get("survivor") or "none"
+    standing = scored.get("attacked_sharpe")
+    call_figs: dict[str, Any] = {
+        "pass": round_idx,
+        "attack": attack,
+        "leader": leader,
+        "leader_sharpe": scored.get("survivor_sharpe"),
+        "leader_standing": standing,
+        "n_trials": scored.get("n_trials"),
+    }
+    if why:
+        call_figs["why"] = why
+    note = f"pass {round_idx}  {attack}  leader {leader}  standing {standing}"
+    return Call(tool="attack", args={"attack": attack}, figures=call_figs, note=note)
+
+
+def _universe_names(data: Any) -> list[str]:
+    if not isinstance(data, dict):
+        return []
+    return [str(k) for k in list(data.keys())[:24]]
+
+
+def _budget(seconds: float) -> float:
+    """A positive request, never longer than a minute. A bad request uses the default."""
+    try:
+        number = float(seconds)
+    except (TypeError, ValueError):
+        return DEFAULT_SECONDS
+    if not math.isfinite(number) or number <= 0:
+        return DEFAULT_SECONDS
+    return min(HARD_CEILING, number)
+
+
+def _ask(think: Think, prompt: str, deadline: float) -> tuple[str, bool]:
+    """One model call. The second value is false when the clock won and the loop must stop.
+
+    The worker is a daemon so a model that keeps talking after the deadline
+    cannot hold the process open. That reply is never read.
+    """
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        return "", False
+    box: list[str] = []
+
+    def run() -> None:
+        try:
+            text = think(prompt)
+        except Exception:  # noqa: BLE001 — a broken call is a refused turn, not a crash
+            return
+        if isinstance(text, str):
+            box.append(text)
+
+    worker = threading.Thread(target=run, daemon=True)
+    worker.start()
+    worker.join(remaining)
+    if worker.is_alive():
+        return "", False
+    return (box[0] if box else ""), True
+
+
+def _fill(
+    template: str,
+    question: str,
+    board: str,
+    *,
+    round_idx: int = 1,
+    n_rounds: int = MAX_ROUNDS,
+    seat_idx: int = 1,
+    n_seats: int = MAX_SEATS,
+    attacks: list[str] | None = None,
+    names: list[str] | None = None,
+) -> str:
+    active = list(dict.fromkeys(attacks or []))
+    unused = [a for a in ATTACKS if a not in active]
+    return (
+        template.replace("@@QUESTION@@", question)
+        .replace("@@BOARD@@", board)
+        .replace("@@ROUND@@", str(round_idx))
+        .replace("@@ROUNDS@@", str(n_rounds))
+        .replace("@@SEAT@@", str(seat_idx))
+        .replace("@@SEATS@@", str(n_seats))
+        .replace("@@RULES@@", ", ".join(RULES))
+        .replace("@@ATTACKS@@", ", ".join(ATTACKS))
+        .replace("@@ACTIVE_ATTACKS@@", ", ".join(active) or "none yet")
+        .replace("@@UNUSED_ATTACKS@@", ", ".join(unused) or "all attacks active")
+        .replace("@@NAMES@@", ", ".join(names or []) or "loaded book")
+    )
+
+
+def _proposal(text: str) -> tuple[dict[str, Any], str]:
+    obj = _object(text)
+    if obj is None:
+        return {"rule": ""}, ""
+    if "bakeoff" in {str(obj.get("tool") or ""), str(obj.get("rule") or "")}:
+        return {"rule": ""}, ""
+    rule = obj.get("rule")
+    if not isinstance(rule, str):
+        return {"rule": ""}, ""
+    out: dict[str, Any] = {"rule": rule}
+    if "lookback" in obj and obj["lookback"] is not None:
+        out["lookback"] = obj["lookback"]
+    if isinstance(obj.get("names"), list):
+        out["names"] = [str(name) for name in obj["names"][:12]]
+    why = str(obj.get("why") or "").strip()[:80]
+    return out, why
+
+
+def _attack(text: str) -> tuple[str | None, str]:
+    obj = _object(text)
+    if obj is None:
+        return None, ""
+    attack = str(obj.get("attack") or "").strip().lower().replace("-", "_").replace(" ", "_")
+    if attack not in ATTACKS:
+        return None, ""
+    why = str(obj.get("why") or "").strip()[:80]
+    return attack, why
+
+
+def _object(text: str) -> dict[str, Any] | None:
+    start = text.find("{")
+    end = text.rfind("}")
+    if start < 0 or end <= start:
+        return None
+    try:
+        obj = json.loads(text[start : end + 1])
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    nested = obj.get("args")
+    if isinstance(nested, dict) and "rule" not in obj and "attack" not in obj:
+        obj = nested
+    return {str(key): value for key, value in obj.items() if str(key) not in _DROPPED}
+
+
+def _verdict(figures: dict[str, Any]) -> str:
+    survivor = figures.get("survivor")
+    if not survivor:
+        return "Referee. No proposal survived."
+    return (
+        f"Referee. {figures.get('n_trials')} candidates across {figures.get('n_passes', MAX_ROUNDS)} passes, "
+        f"source bakeoff. Survivor {survivor} (in-sample Sharpe {figures.get('survivor_sharpe')}, "
+        f"post-attack standing {figures.get('attacked_sharpe')}, "
+        f"deflated Sharpe {figures.get('deflated_sharpe')}). Verdict {figures.get('verdict')}."
+    )

{alphaengine-1.0.1 → alphaengine-1.0.2}/src/alphaengine/agent/brief.py

@@ -216,7 +216,7 @@ def _books(data: dict[str, list[float]], question: str = "") -> list[dict[str, A
         return []
     if aligned.ndim != 2 or aligned.shape[1] < 2 or aligned.shape[0] < 8:
         return []
-    built: dict[str, np.ndarray] = {}
+    built: dict[str, Any] = {}
     for method in ("hrp", "risk_parity"):
         try:
             result = build_portfolio(data, method=method)
@@ -559,7 +559,7 @@ def _bakeoff(raw: Any, data: dict[str, list[float]]) -> dict[str, Any] | None:
     if not isinstance(raw, dict):
         return None
     curves = []
-    for row in raw.get("curves") or []:
+    for idx, row in enumerate(raw.get("curves") or []):
         if not isinstance(row, dict):
             continue
         growth = row.get("growth")
@@ -570,10 +570,14 @@ def _bakeoff(raw: Any, data: dict[str, list[float]]) -> dict[str, Any] | None:
         stats = _stats([float(x) for x in rets])
         curves.append(
             {
+                "round": int(row.get("round") or (idx // 2 + 1)),
+                "seat": int(row.get("seat") or (idx % 2 + 1)),
                 "label": str(row.get("label") or ""),
                 "growth": growth,
                 "sharpe": row.get("sharpe"),
                 "standing": row.get("standing"),
+                "worst_attack": row.get("worst_attack") or "in_sample",
+                "attack_scores": row.get("attack_scores") or {},
                 "annualized_sharpe": stats.get("sharpe_annualized"),
                 "total_return_pct": stats.get("total_return_pct"),
                 "max_drawdown_pct": stats.get("max_drawdown_pct"),
@@ -583,6 +587,7 @@ def _bakeoff(raw: Any, data: dict[str, list[float]]) -> dict[str, Any] | None:
     trials = [str(line) for line in (raw.get("trials") or [])]
     if not raw.get("survivor") and not trials and not curves:
         return None
+    passes = [p for p in (raw.get("passes") or []) if isinstance(p, dict)]
     return {
         "survivor": raw.get("survivor"),
         "survivor_sharpe": raw.get("survivor_sharpe"),
@@ -590,33 +595,56 @@ def _bakeoff(raw: Any, data: dict[str, list[float]]) -> dict[str, Any] | None:
         "deflated_sharpe": raw.get("deflated_sharpe"),
         "verdict": raw.get("verdict"),
         "n_trials": raw.get("n_trials"),
+        "n_passes": raw.get("n_passes") or max(len(passes), 4),
         "attacks": [str(attack) for attack in (raw.get("attacks") or [])],
         "trials": trials,
-        "curves": curves[:6],
+        "passes": passes,
+        "curves": curves[:8],
+        "survivor_weights": raw.get("survivor_weights") or {},
     }
 
 
 def _default_bakeoff(data: dict[str, list[float]]) -> dict[str, Any] | None:
-    """Run the referee across all six rules when the session did not already run a bakeoff."""
+    """Run the 4-pass referee tournament across all eight rules when the session did not run one."""
     try:
-        from ..core.bakeoff import ATTACKS, referee, trial_paths
+        from ..core.bakeoff import referee, trial_paths
     except Exception:  # noqa: BLE001
         return None
     submissions: list[dict[str, Any]] = [
-        {"rule": "hrp"},
-        {"rule": "risk_parity"},
-        {"rule": "inverse_vol"},
-        {"rule": "equal"},
-        {"rule": "momentum", "lookback": 20},
-        {"rule": "reversion", "lookback": 20},
+        {"rule": "hrp", "_round": 1, "_seat": 1},
+        {"rule": "risk_parity", "_round": 1, "_seat": 2},
+        {"rule": "inverse_vol", "_round": 2, "_seat": 1},
+        {"rule": "var_sorted", "_round": 2, "_seat": 2},
+        {"rule": "low_vol", "_round": 3, "_seat": 1},
+        {"rule": "equal", "_round": 3, "_seat": 2},
+        {"rule": "momentum", "lookback": 20, "_round": 4, "_seat": 1},
+        {"rule": "reversion", "lookback": 20, "_round": 4, "_seat": 2},
     ]
+    pass_attacks = ["last_half", "high_vol", "tail_stress", "rate_shock"]
     try:
-        figures = referee(data, submissions, list(ATTACKS))
-        curves = trial_paths(data, submissions)
+        passes: list[dict[str, Any]] = []
+        for p_idx, atk in enumerate(pass_attacks, start=1):
+            sub_slice = submissions[: p_idx * 2]
+            atk_slice = pass_attacks[:p_idx]
+            step = referee(data, sub_slice, atk_slice)
+            passes.append(
+                {
+                    "pass": p_idx,
+                    "attack": atk,
+                    "leader": step.get("survivor"),
+                    "leader_sharpe": step.get("survivor_sharpe"),
+                    "leader_standing": step.get("attacked_sharpe"),
+                    "n_trials": len(sub_slice),
+                }
+            )
+        figures = referee(data, submissions, pass_attacks)
+        curves = trial_paths(data, submissions, pass_attacks)
     except Exception:  # noqa: BLE001
         return None
     if not figures.get("survivor") and not curves:
         return None
+    survivor_label = str(figures.get("survivor") or "")
+    survivor_curve = next((c for c in curves if c.get("label") == survivor_label), None)
     return {
         "survivor": figures.get("survivor"),
         "survivor_sharpe": figures.get("survivor_sharpe"),
@@ -624,9 +652,12 @@ def _default_bakeoff(data: dict[str, list[float]]) -> dict[str, Any] | None:
         "deflated_sharpe": figures.get("deflated_sharpe"),
         "verdict": figures.get("verdict"),
         "n_trials": figures.get("n_trials"),
+        "n_passes": 4,
         "attacks": list(figures.get("attacks") or []),
         "trials": list(figures.get("trials") or []),
+        "passes": passes,
         "curves": curves,
+        "survivor_weights": (survivor_curve or {}).get("weights") or {},
     }
 
 

{alphaengine-1.0.1 → alphaengine-1.0.2}/src/alphaengine/agent/chart.py

@@ -792,7 +792,7 @@ def _bakeoff(
     fig = plt.figure(figsize=(8.5, 11))
     _chrome(
         fig,
-        "Strategy Bakeoff & Adversarial Referee Tournament",
+        f"Multi-Pass GAN Strategy Bakeoff & Referee Tournament ({bakeoff.get('n_passes') or 4} Passes)",
         stamp,
         stem,
         _question(trace),
@@ -800,68 +800,88 @@ def _bakeoff(
     banner = (
         f"Survivor: {bakeoff.get('survivor')}  |  "
         f"In-Sample Sharpe: {bakeoff.get('survivor_sharpe')}  |  "
-        f"Attacked Sharpe: {bakeoff.get('attacked_sharpe')}  |  "
+        f"Post-Attack Standing: {bakeoff.get('attacked_sharpe')}  |  "
         f"Deflated Sharpe: {bakeoff.get('deflated_sharpe')} ({bakeoff.get('verdict')})\n"
-        f"Trials: {bakeoff.get('n_trials')}  |  "
+        f"Passes: {bakeoff.get('n_passes') or 4}  |  "
+        f"Candidates: {bakeoff.get('n_trials')}  |  "
         f"Adversarial Attacks: {', '.join(bakeoff.get('attacks') or []) or 'none'}"
     )
     fig.text(0.075, 0.895, banner, fontsize=8.0, fontweight="bold", color="#0F172A", va="top")
 
     curves = list(bakeoff.get("curves") or [])
     if curves:
-        ax = fig.add_axes((0.11, 0.45, 0.80, 0.37))
-        ax.set_title("Cumulative Wealth (Growth of 1) Across Candidate Rules", loc="left")
+        ax1 = fig.add_axes((0.09, 0.48, 0.44, 0.34))
+        ax1.set_title("Cumulative Wealth Across Passes", loc="left", fontsize=9.5)
         survivor = str(bakeoff.get("survivor") or "")
         for index, curve in enumerate(curves):
             label = str(curve.get("label") or "")
             is_win = label == survivor
-            ax.plot(
+            ax1.plot(
                 curve.get("growth") or [],
                 color="#0F172A" if is_win else _COLORS[index % len(_COLORS)],
-                lw=2.3 if is_win else 1.25,
-                alpha=1.0 if is_win else 0.85,
-                label=f"{label} (survivor)" if is_win else label,
+                lw=2.2 if is_win else 1.2,
+                alpha=1.0 if is_win else 0.84,
+                label=f"{label}*" if is_win else label,
             )
-        ax.axhline(1.0, color="#64748B", lw=0.7, ls="--")
-        ax.set_xlabel("trading observation")
-        ax.set_ylabel("growth of 1")
-        ax.legend(loc="upper left", ncol=3, fontsize=7.6)
+        ax1.axhline(1.0, color="#64748B", lw=0.7, ls="--")
+        ax1.set_xlabel("trading observation")
+        ax1.set_ylabel("growth of 1")
+        ax1.legend(loc="upper left", ncol=2, fontsize=6.8)
+
+        ax2 = fig.add_axes((0.62, 0.48, 0.30, 0.34))
+        labels = [str(c.get("label") or "") for c in curves][::-1]
+        in_sh = [float(c.get("sharpe") or 0.0) for c in curves][::-1]
+        st_sh = [
+            float(c.get("standing") if c.get("standing") is not None else (c.get("sharpe") or 0.0))
+            for c in curves
+        ][::-1]
+        y_pos = np.arange(len(labels))
+        ax2.barh(y_pos + 0.17, in_sh, height=0.32, color="#0072B2", label="In-Sample")
+        ax2.barh(y_pos - 0.17, st_sh, height=0.32, color="#D95F02", label="Post-Attack")
+        ax2.axvline(0.0, color="#475569", lw=0.8)
+        ax2.set_yticks(y_pos, labels, fontsize=7.2)
+        ax2.set_title("In-Sample vs. Attacked Sharpe", loc="left", fontsize=9.5)
+        ax2.set_xlabel("period Sharpe")
+        ax2.legend(loc="lower right", fontsize=7.0)
 
         tbl_rows: list[list[str]] = []
         survivor = str(bakeoff.get("survivor") or "")
         for idx, curve in enumerate(curves, start=1):
             label = str(curve.get("label") or "")
             status = "SURVIVOR" if label == survivor else "eliminated"
+            p_num = curve.get("round") or ((idx - 1) // 2 + 1)
             tbl_rows.append(
                 [
-                    f"{idx:02d}",
+                    f"P{p_num}",
                     label,
                     _shown(curve.get("sharpe")),
+                    _shown(curve.get("standing")),
+                    str(curve.get("worst_attack") or "in_sample"),
                     _shown(curve.get("annualized_sharpe")),
                     _fmt_pct(curve.get("total_return_pct")),
-                    _fmt_pct(curve.get("volatility_annualized_pct")),
                     _fmt_pct(curve.get("max_drawdown_pct")),
                     status,
                 ]
             )
-        ax_tbl = fig.add_axes((0.075, 0.08, 0.85, 0.30))
+        ax_tbl = fig.add_axes((0.075, 0.07, 0.85, 0.34))
         ax_tbl.axis("off")
-        ax_tbl.set_title("Referee Candidate Scorecard", loc="left", fontsize=9.5)
+        ax_tbl.set_title("Multi-Pass Referee Candidate Scorecard", loc="left", fontsize=9.5)
         _styled_table(
             ax_tbl,
             [
-                "#",
+                "Pass",
                 "Candidate Rule",
-                "Period Sharpe",
-                "Ann Sharpe",
+                "Period SR",
+                "Attacked SR",
+                "Worst Attack",
+                "Ann SR",
                 "Total Ret",
-                "Ann Vol",
                 "Max DD",
-                "Referee Status",
+                "Status",
             ],
             tbl_rows,
-            [0.06, 0.20, 0.12, 0.12, 0.12, 0.12, 0.12, 0.14],
-            fontsize=7.6,
+            [0.06, 0.17, 0.10, 0.11, 0.14, 0.10, 0.10, 0.10, 0.12],
+            fontsize=7.3,
         )
     else:
         trials = list(bakeoff.get("trials") or [])