feat(robustness): wire LOO grid into CPCV suite — real PBO=0.20 replaces trivial mirror

Self-audit finding: the fold-mirror PBO was structurally trivial (=0.00) because
a 2-column matrix with a median-shifted mirror always picks the same best IS
strategy. The offline-robustness packet already ships a 13×5 LOO grid at
results/cross_asset_kuramoto/offline_robustness/leave_one_asset_out.csv
(13 asset-LOO perturbations × 5 walk-forward folds) — this is a bona-fide
OOS matrix for Bailey et al. (2017) PBO estimation.

Changes:
- kuramoto_contract.py — optional loo_grid field on the contract; inline
  LOO_GRID_SHA256 constant for fail-closed hash verification outside the
  28-entry SOURCE_HASHES.json contract (additive, SOURCE_HASHES untouched).
  Missing file is tolerated (loo_grid=None); present-but-mismatched file
  raises FrozenArtifactMismatch.
- kuramoto_cpcv_suite.py — _loo_oos_matrix() builds (folds × strategies)
  from non-baseline LOO rows; estimate_pbo() runs on it when present.
  KuramotoCPCVResult now carries loo_pbo (float|None), loo_pbo_pass,
  loo_n_strategies alongside the existing fields.
- backtest/robustness_gates.py — _CPCVEvidence Protocol gains loo_pbo_pass;
  evaluate_robustness_gates() includes it in cpcv_pass conjunction.
- CLI + ROBUSTNESS_v1.md now surface 'CPCV | PBO (LOO grid, n=13) | 0.2000 ✓'.

First-run evidence on the frozen bundle:
  PBO (fold mirror): 0.0000   (trivial, as before — kept for continuity)
  PBO (LOO grid):    0.2000   (13 strategies × 5 folds — real estimator)
  best-IS each fold: tradable:TLT × 5 (OOS ranks 6, 13, 14, 14, 14)

Interpretation: 1/5 folds has best-IS below-median OOS → 20 % overfit
probability on the LOO family. Consistent with SEPARATION_FINDING.md
('drop TLT → Sharpe 1.26 → 1.73'): the TLT-drop variant is genuinely
best on 4 of 5 folds, not a lucky pick.

Tests:
- test_loo_pbo_present_and_bounded — loo_pbo ∈ [0, 1], n=13.
- test_loo_pbo_matches_hand_computed — regression pin at 0.20.
- test_loo_pbo_red_gives_fail — decision layer correctly propagates
  loo_pbo_pass=False to FAIL.
- Existing _FakeCPCV fixture gained loo_pbo_pass: bool = True default
  so existing decision-layer tests stay green.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: neuron7xLab

backtest/robustness_gates.py

@@ -38,6 +38,8 @@ def psr_pass(self) -> bool: ...
     def annualised_sharpe(self) -> float: ...
     @property
     def n_folds(self) -> int: ...
+    @property
+    def loo_pbo_pass(self) -> bool: ...
 
 
 @runtime_checkable
@@ -94,11 +96,15 @@ def evaluate_robustness_gates(
       passing, or placeholder with ``require_live_jitter`` False.
     """
     reasons: list[str] = []
-    cpcv_pass = bool(evidence.cpcv.pbo_pass and evidence.cpcv.psr_pass)
+    cpcv_pass = bool(
+        evidence.cpcv.pbo_pass and evidence.cpcv.psr_pass and evidence.cpcv.loo_pbo_pass
+    )
     if not evidence.cpcv.pbo_pass:
         reasons.append("cpcv: PBO above threshold")
     if not evidence.cpcv.psr_pass:
         reasons.append("cpcv: PSR below threshold")
+    if not evidence.cpcv.loo_pbo_pass:
+        reasons.append("cpcv: LOO-grid PBO above threshold")
 
     null_pass = bool(evidence.null.all_families_pass)
     if not null_pass:

research/robustness/protocols/kuramoto_contract.py

@@ -31,11 +31,34 @@
 DEMO_RISK_REL: Final[str] = "results/cross_asset_kuramoto/demo/risk_metrics.csv"
 PARAM_LOCK_REL: Final[str] = "results/cross_asset_kuramoto/PARAMETER_LOCK.json"
 
+# Extension manifest: hash-verified auxiliary artifacts that are *outside*
+# the original 28-artifact SOURCE_HASHES.json contract. Adding a new
+# auxiliary input requires appending here AND in the inline hash constant
+# below — both must move together, so drift is caught at load time.
+LOO_GRID_REL: Final[str] = "results/cross_asset_kuramoto/offline_robustness/leave_one_asset_out.csv"
+LOO_GRID_SHA256: Final[str] = "9fdb19129630bddcda7499cd6a1ec20b68b34715d8c52c72bd286676e8156a61"
+
 
 class FrozenArtifactMismatch(RuntimeError):
     """Raised when a frozen artifact fails sha256 verification or is missing."""
 
 
+def _load_loo_grid_if_present(repo_root: Path) -> pd.DataFrame | None:
+    """Load + hash-verify the LOO grid; return None if the file is absent.
+
+    A present-but-mismatched file is fail-closed (raises
+    :class:`FrozenArtifactMismatch`); a missing file is tolerated so the
+    framework can run on a minimal frozen bundle.
+    """
+    path = repo_root / LOO_GRID_REL
+    if not path.is_file():
+        return None
+    sha = hashlib.sha256(path.read_bytes()).hexdigest()
+    if sha != LOO_GRID_SHA256:
+        raise FrozenArtifactMismatch(f"{LOO_GRID_REL}: got {sha}, expected {LOO_GRID_SHA256}")
+    return pd.read_csv(path)
+
+
 @dataclass(frozen=True)
 class FrozenArtifactManifest:
     """Parsed SOURCE_HASHES.json plus the repo root used to resolve rels."""
@@ -91,14 +114,22 @@ class KuramotoRobustnessContract:
     fold_metrics: pd.DataFrame
     risk_metrics: pd.DataFrame
     parameter_lock: dict[str, object]
+    loo_grid: pd.DataFrame | None = None
 
     @classmethod
     def from_frozen_artifacts(
         cls,
         manifest_path: Path = DEFAULT_MANIFEST,
         repo_root: Path = REPO_ROOT,
     ) -> KuramotoRobustnessContract:
-        """Load contract and verify hashes in one fail-closed step."""
+        """Load contract and verify hashes in one fail-closed step.
+
+        Also loads the optional leave-one-asset-out grid when the file
+        is present on disk; its sha256 is verified against the inline
+        :data:`LOO_GRID_SHA256` constant. A missing LOO file is tolerated
+        (``loo_grid`` stays None); a present-but-mismatched file is a
+        fail-closed error.
+        """
         manifest = FrozenArtifactManifest.load(manifest_path, repo_root)
         manifest.verify_all()
 
@@ -112,12 +143,14 @@ def from_frozen_artifacts(
         )
         risk = pd.read_csv(repo_root / DEMO_RISK_REL)
         param_lock = json.loads((repo_root / PARAM_LOCK_REL).read_text(encoding="utf-8"))
+        loo_grid = _load_loo_grid_if_present(repo_root)
         contract = cls(
             manifest=manifest,
             equity_curve=equity,
             fold_metrics=folds,
             risk_metrics=risk,
             parameter_lock=param_lock,
+            loo_grid=loo_grid,
         )
         contract.assert_frozen_consistency()
         return contract
@@ -136,6 +169,22 @@ def assert_frozen_consistency(self) -> None:
             raise FrozenArtifactMismatch(
                 f"fold_metrics.csv needs at least 2 folds, has {len(self.fold_metrics)}"
             )
+        if self.loo_grid is not None:
+            required_loo = {
+                "loo_type",
+                "omitted_asset",
+                "oos_sharpe",
+                "fold1",
+                "fold2",
+                "fold3",
+                "fold4",
+                "fold5",
+            }
+            missing = required_loo - set(self.loo_grid.columns)
+            if missing:
+                raise FrozenArtifactMismatch(
+                    f"leave_one_asset_out.csv missing columns: {sorted(missing)}"
+                )
 
     def daily_strategy_returns(self) -> pd.Series:
         """Strategy daily returns from ``strategy_cumret`` (pct_change)."""

research/robustness/protocols/kuramoto_cpcv_suite.py

@@ -8,13 +8,16 @@
 from typing import Final
 
 import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
 
 from research.robustness.cpcv import estimate_pbo, probabilistic_sharpe_ratio
 
 from .kuramoto_contract import KuramotoRobustnessContract
 
 PBO_PASS_THRESHOLD: Final[float] = 0.50
 PSR_PASS_THRESHOLD: Final[float] = 0.95
+LOO_PBO_PASS_THRESHOLD: Final[float] = 0.50
 
 
 @dataclass(frozen=True)
@@ -29,9 +32,12 @@ class KuramotoCPCVResult:
     annualised_sharpe: float
     n_bars: int
     n_folds: int
+    loo_pbo: float | None
+    loo_pbo_pass: bool
+    loo_n_strategies: int
 
 
-def _fold_oos_matrix(fold_sharpes: tuple[float, ...]) -> np.ndarray:
+def _fold_oos_matrix(fold_sharpes: tuple[float, ...]) -> NDArray[np.float64]:
     """Build an OOS matrix from per-fold Sharpe values for PBO estimation.
 
     The frozen evidence bundle ships one Sharpe per walk-forward fold
@@ -45,6 +51,23 @@ def _fold_oos_matrix(fold_sharpes: tuple[float, ...]) -> np.ndarray:
     return np.column_stack([arr, mirror])
 
 
+def _loo_oos_matrix(loo_grid: pd.DataFrame) -> NDArray[np.float64]:
+    """Build an OOS matrix of (folds × strategies) from the LOO grid.
+
+    Each non-baseline LOO row is one strategy variant whose per-fold
+    Sharpes live in columns ``fold1..fold5``. We transpose so rows are
+    CPCV paths (folds) and columns are strategies, matching
+    :func:`research.robustness.cpcv.estimate_pbo` shape expectations.
+    The baseline row is excluded: including it would guarantee best-IS
+    capture every time and trivialise the PBO.
+    """
+    perturbations = loo_grid[loo_grid["loo_type"] != "baseline_full"]
+    folds = perturbations[["fold1", "fold2", "fold3", "fold4", "fold5"]].to_numpy(dtype=np.float64)
+    # folds shape is (n_strategies, n_folds); transpose to (n_folds, n_strategies)
+    out: NDArray[np.float64] = folds.T
+    return out
+
+
 def run_kuramoto_cpcv_suite(
     contract: KuramotoRobustnessContract,
 ) -> KuramotoCPCVResult:
@@ -55,6 +78,10 @@ def run_kuramoto_cpcv_suite(
     pre-computed fold sharpes for PBO and the daily return stream for
     PSR. No re-simulation is performed — this suite is *read-only* on
     frozen artifacts by design.
+
+    When the contract carries the optional LOO grid, a *second* PBO is
+    computed on the real (folds × LOO-perturbations) OOS matrix — this
+    is the honest Bailey et al. PBO and is non-trivial by construction.
     """
     daily = contract.daily_strategy_returns().to_numpy(dtype=np.float64)
     fold_sharpes = tuple(float(s) for s in contract.fold_metrics["sharpe"].to_numpy())
@@ -67,6 +94,17 @@ def run_kuramoto_cpcv_suite(
     pbo = estimate_pbo(oos)
     std = float(np.std(daily, ddof=1))
     sr = float(np.mean(daily) / std * np.sqrt(252)) if std > 0 and np.isfinite(std) else 0.0
+
+    loo_pbo: float | None = None
+    loo_pbo_pass = True
+    loo_n_strategies = 0
+    if contract.loo_grid is not None:
+        loo_oos = _loo_oos_matrix(contract.loo_grid)
+        loo_n_strategies = int(loo_oos.shape[1])
+        if loo_oos.shape[0] >= 2 and loo_n_strategies >= 2:
+            loo_pbo = estimate_pbo(loo_oos)
+            loo_pbo_pass = loo_pbo < LOO_PBO_PASS_THRESHOLD
+
     return KuramotoCPCVResult(
         fold_sharpes=fold_sharpes,
         pbo=pbo,
@@ -76,4 +114,7 @@ def run_kuramoto_cpcv_suite(
         annualised_sharpe=sr,
         n_bars=int(daily.size),
         n_folds=len(fold_sharpes),
+        loo_pbo=loo_pbo,
+        loo_pbo_pass=loo_pbo_pass,
+        loo_n_strategies=loo_n_strategies,
     )

results/cross_asset_kuramoto/robustness_v1/ROBUSTNESS_v1.md

@@ -6,11 +6,12 @@ Terminal decision: **FAIL**
 
 | Suite | Metric | Value | Pass |
 |---|---|---:|:-:|
-| CPCV | PBO | 0.0000 | ✓ |
+| CPCV | PBO (fold mirror) | 0.0000 | ✓ |
 | CPCV | PSR (daily) | 1.0000 | ✓ |
 | CPCV | Annualised Sharpe (daily) | 0.5775 | n/a |
-| Null | iid_permutation p-value | 0.1095 | ✗ |
-| Null | stationary_bootstrap p-value | 0.4677 | ✗ |
+| CPCV | PBO (LOO grid, n=13) | 0.2000 | ✓ |
+| Null | iid_permutation p-value | 0.0878 | ✗ |
+| Null | stationary_bootstrap p-value | 0.5170 | ✗ |
 | Jitter | fraction_within_tol | 1.0000 | ✓ |
 | Jitter | evaluator_mode | `PLACEHOLDER_APPROXIMATION` | n/a |
 

results/cross_asset_kuramoto/robustness_v1/cpcv_summary.json

@@ -7,6 +7,9 @@
     0.942,
     0.8507
   ],
+  "loo_n_strategies": 13,
+  "loo_pbo": 0.2,
+  "loo_pbo_pass": true,
   "n_bars": 2166,
   "n_folds": 5,
   "pbo": 0.0,