neuron7xLab
diff --git a/‎.github/detect-secrets.baseline‎
Lines changed: 7164 additions & 84 deletions b/‎.github/detect-secrets.baseline‎
Lines changed: 7164 additions & 84 deletions
diff --git a/‎.secrets.baseline‎
Lines changed: 2452 additions & 305 deletions b/‎.secrets.baseline‎
Lines changed: 2452 additions & 305 deletions
diff --git a/‎.secretsignore‎
Lines changed: 5 additions & 0 deletions b/‎.secretsignore‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎config/research_line_registry.yaml‎
Lines changed: 111 additions & 0 deletions b/‎config/research_line_registry.yaml‎
Lines changed: 111 additions & 0 deletions
diff --git a/‎core/cross_asset_kuramoto/__init__.py‎
Lines changed: 47 additions & 0 deletions b/‎core/cross_asset_kuramoto/__init__.py‎
Lines changed: 47 additions & 0 deletions
diff --git a/‎core/cross_asset_kuramoto/engine.py‎
Lines changed: 191 additions & 0 deletions b/‎core/cross_asset_kuramoto/engine.py‎
Lines changed: 191 additions & 0 deletions
@@ -6,3 +6,8 @@ audit/artifacts/
 
 # Baseline for detected non-issues
 .secrets.baseline
+
+# Frozen artefact identity pins (SHA-256 content-addresses, not secrets)
+results/cross_asset_kuramoto/offline_robustness/SOURCE_HASHES.json
+results/cross_asset_kuramoto/shadow_validation/daily/*/run_manifest.json
+results/wave1_fx/universe.json
@@ -0,0 +1,111 @@
+# GeoSync research-line registry
+# Purpose: machine-readable record of research lines and their terminal status.
+# Any line with status != OPEN is immutable and may NOT be revived on the same
+# substrate / family without starting a new line_id.
+#
+# Schema:
+#   lines:
+#     <line_id>:
+#       signal_family:                   string  (the signal the line tests)
+#       substrate:                       string  (data substrate key)
+#       universe:                        list[string]
+#       status:                          OPEN | REJECTED | SUPERSEDED
+#       verdict:                         PASS | FAIL | INCONCLUSIVE | null
+#       wave2_authorized:                bool
+#       parameter_rescue_allowed:        bool
+#       same_family_same_substrate_retest_allowed: bool
+#       allowed_next_action:             string (enum)
+#       evidence_path:                   string (repo-relative dir)
+#       lock_sha:                        string (git SHA at preregistration lock)
+#       complete_sha:                    string (git SHA at run completion)
+#       canonical_fail_note:             string (path to FAIL note, if any)
+#
+# Registry consumers:
+#   tests/test_research_line_registry.py — enforces rejected lines stay dead.
+
+schema_version: 1
+
+# Allowed next-action vocabulary (closed set, referenced by validator)
+allowed_next_actions:
+  - none
+  - continue_same_line
+  - new_fx_native_prereg_only
+  - new_equity_native_prereg_only
+  - new_substrate_prereg_only
+  - manual_review_required
+
+lines:
+
+  combo_v1_fx_wave1:
+    signal_family: combo_v1
+    signal_source: "research.askar.full_validation.build_signal"
+    signal_parameters:
+      window: 120
+      threshold: 0.30
+      col: combo
+    substrate: 8fx_daily_close_2100utc
+    universe:
+      - EURUSD
+      - GBPUSD
+      - USDJPY
+      - AUDUSD
+      - USDCAD
+      - USDCHF
+      - EURGBP
+      - EURJPY
+    oos_window:
+      start: "2008-01-02"
+      end: "2026-02-09"
+    oos_bars: 4704
+    folds: 222
+    position_rule:
+      type: cross_sectional_long_short
+      top_k: 2
+      bottom_k: 2
+      weight_per_leg: 0.5
+      lag_bars: 1
+      rebalance_utc: "21:00"
+    costs_bps_run_b:
+      EURUSD: 1.0
+      GBPUSD: 1.0
+      AUDUSD: 1.0
+      USDJPY: 1.5
+      USDCAD: 1.5
+      USDCHF: 1.5
+      EURGBP: 1.5
+      EURJPY: 1.5
+    status: REJECTED
+    verdict: FAIL
+    wave2_authorized: false
+    parameter_rescue_allowed: false
+    same_family_same_substrate_retest_allowed: false
+    allowed_next_action: new_fx_native_prereg_only
+    evidence_path: results/wave1_fx/
+    lock_sha: ef0b774bc4aeb093b843d9494d3b13612ab63e59
+    complete_sha: 3214612f59b56059c7b9a668baec047e1f0c793a
+    geosync_sha_at_lock: 8b68156df48f1d8ec7566a8db57fb71a66cf8622
+    canonical_fail_note: results/wave1_fx/CANONICAL_FAIL_NOTE.md
+    closed_on_utc: "2026-04-21"
+    # Metrics of record (Run B, verdict run)
+    metrics_of_record:
+      primary_median_fold_median_sharpe: -0.0457
+      primary_floor: 0.80
+      positive_folds_frac: 0.4324
+      positive_folds_floor: 0.60
+      median_2022_fold_sharpe: 0.1964
+      max_drawdown_oos: 0.4488
+      max_drawdown_ceil: 0.20
+      gates_passed_out_of_4: 1
+    # Diagnostic only — not verdict
+    metrics_run_a_gross:
+      primary_median_fold_median_sharpe: -0.0046
+      positive_folds_frac: 0.4595
+      max_drawdown_oos: 0.4061
+    baselines_run_b:
+      buy_and_hold_eq_weight_sharpe: -0.0427
+      buy_and_hold_eq_weight_maxdd: 0.1618
+      combo_two_bar_lag_sharpe: -0.1529
+      combo_two_bar_lag_maxdd: 0.4230
+
+# Future lines go below with status: OPEN.
+# Rejected lines MUST NOT be re-opened; any revival requires a new line_id.
@@ -0,0 +1,47 @@
+"""Cross-asset Kuramoto regime strategy — integrated module.
+
+Source spike: ``~/spikes/cross_asset_sync_regime/`` (composite SHA-256
+``9e76e3b511d31245239961e386901214ea3a4ccc549c87009e29b814f6576fe3``).
+Every numeric parameter is frozen at its spike value; see
+``results/cross_asset_kuramoto/PARAMETER_LOCK.json``. Any behaviour-
+affecting divergence requires a separate PR with full re-verification.
+
+Public API is intentionally narrow: callers import the top-level
+helpers listed in ``__all__`` and the strong-typed result containers
+from ``.types``. Lower-level functions remain addressable for tests.
+"""
+
+from __future__ import annotations
+
+from .engine import BacktestResult, compute_metrics, simulate_rp_strategy
+from .invariants import CAKInvariantError, assert_all_invariants, load_parameter_lock
+from .signal import (
+    build_panel,
+    build_returns_panel,
+    classify_regimes,
+    compute_log_returns,
+    extract_phase,
+    kuramoto_order,
+    load_asset_close,
+)
+from .types import PanelSpec, Regime, RegimeThresholds, StrategyParameters
+
+__all__ = [
+    "BacktestResult",
+    "CAKInvariantError",
+    "PanelSpec",
+    "Regime",
+    "RegimeThresholds",
+    "StrategyParameters",
+    "assert_all_invariants",
+    "build_panel",
+    "build_returns_panel",
+    "classify_regimes",
+    "compute_log_returns",
+    "compute_metrics",
+    "extract_phase",
+    "kuramoto_order",
+    "load_asset_close",
+    "load_parameter_lock",
+    "simulate_rp_strategy",
+]
@@ -0,0 +1,191 @@
+"""Risk-parity regime strategy — backtest simulator and performance metrics.
+
+Copy-ported from ``~/spikes/cross_asset_sync_regime/backtest_v2.py``
+with type annotations added. Numerics preserved bit-for-bit against the
+spike. No imports from ``backtest/``, ``execution/``, or ``strategies/``;
+this module is self-contained above ``core/``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+import numpy as np
+import pandas as pd
+
+from .invariants import CAKInvariantError
+from .types import BacktestResult
+
+__all__ = [
+    "BacktestResult",
+    "compute_metrics",
+    "drawdown_series",
+    "result_from_dataframe",
+    "rolling_vol",
+    "simulate_rp_strategy",
+]
+
+
+def rolling_vol(returns: pd.DataFrame, window: int, bars_per_year: int) -> pd.DataFrame:
+    """Annualised rolling standard deviation of log returns."""
+    std = returns.rolling(window=window, min_periods=window).std()
+    return cast(pd.DataFrame, std * np.sqrt(bars_per_year))
+
+
+def simulate_rp_strategy(
+    returns: pd.DataFrame,
+    regimes: pd.Series,
+    regime_buckets: Mapping[str, tuple[str, ...]],
+    vol_window: int,
+    vol_target: float,
+    vol_cap: float,
+    cost_bps: float,
+    return_clip_abs: float,
+    bars_per_year: int,
+    execution_lag_bars: int = 1,
+) -> pd.DataFrame:
+    """Daily risk-parity-in-bucket + vol-target strategy, no look-ahead.
+
+    Mirrors ``backtest_v2.simulate_rp_strategy`` step-for-step:
+
+    1. Lag ``regimes`` by ``execution_lag_bars`` to obtain the regime
+       visible at rebalance time.
+    2. Inverse-volatility risk-parity weights within the bucket assigned
+       to the visible regime (``regime_buckets``).
+    3. Vol-target overlay: scale total exposure to reach ``vol_target``
+       annualised, capped at ``vol_cap``.
+    4. Turnover cost applied on absolute weight change.
+    5. Per-bar log returns clipped to ``[-return_clip_abs, +return_clip_abs]``.
+
+    ``cost_bps`` is the round-trip bps applied to one unit of turnover
+    (consistent with spike definition). Setting ``cost_bps=0`` is allowed
+    but the caller is responsible for surfacing it to the user — the
+    module-level invariants register this as a warn-worthy event.
+    """
+    regimes_lag = regimes.shift(execution_lag_bars)
+    common_idx = returns.index.intersection(regimes_lag.index)
+    rets = returns.loc[common_idx]
+    regs = regimes_lag.loc[common_idx].dropna()
+    rets = rets.loc[regs.index]
+    if rets.empty:
+        raise CAKInvariantError("empty strategy window after regime lag")
+
+    asset_vols = rolling_vol(rets, vol_window, bars_per_year)
+    asset_vols_lag = asset_vols.shift(1)  # strict no-look-ahead
+
+    assets_all = list(rets.columns)
+    col_idx = {a: i for i, a in enumerate(assets_all)}
+    n = len(rets)
+
+    gross = np.zeros(n)
+    net = np.zeros(n)
+    turnover = np.zeros(n)
+    leverage = np.zeros(n)
+    regime_used: list[str] = []
+    prev_weights = np.zeros(len(assets_all))
+
+    for t in range(n):
+        regime = regs.iloc[t]
+        w = np.zeros(len(assets_all))
+        if regime in regime_buckets:
+            bucket = regime_buckets[regime]
+            vols_today = asset_vols_lag.iloc[t]
+            inv_vols: list[float] = []
+            valid_assets: list[str] = []
+            for a in bucket:
+                v = vols_today.get(a, np.nan)
+                if np.isfinite(v) and v > 0:
+                    inv_vols.append(1.0 / v)
+                    valid_assets.append(a)
+            if inv_vols:
+                inv_arr = np.asarray(inv_vols, dtype=float)
+                rp_weights = inv_arr / inv_arr.sum()
+                for a, rw in zip(valid_assets, rp_weights, strict=True):
+                    w[col_idx[a]] = rw
+
+        vols_vec = asset_vols_lag.iloc[t].to_numpy()
+        vols_vec = np.nan_to_num(vols_vec, nan=1e9)
+        port_vol = float(np.sqrt(np.sum((w * vols_vec) ** 2)))
+        lev = min(vol_target / port_vol, vol_cap) if port_vol > 0 else 0.0
+        leverage[t] = lev
+        w_scaled = w * lev
+
+        tov = float(np.abs(w_scaled - prev_weights).sum())
+        turnover[t] = tov
+        r_vec = rets.iloc[t].to_numpy()
+        r_vec = np.clip(r_vec, -return_clip_abs, return_clip_abs)
+        g = float((w_scaled * r_vec).sum())
+        gross[t] = g
+        cost = tov * (cost_bps / 10_000.0)
+        net[t] = g - cost
+        prev_weights = w_scaled
+        regime_used.append(regime)
+
+    out = pd.DataFrame(
+        {
+            "gross_ret": gross,
+            "net_ret": net,
+            "turnover": turnover,
+            "leverage": leverage,
+            "regime": regime_used,
+        },
+        index=rets.index,
+    )
+    return out
+
+
+def compute_metrics(net_returns: pd.Series, bars_per_year: int) -> dict[str, float]:
+    """Annualised performance metrics for a net-return series (log space)."""
+    r = net_returns.dropna().to_numpy()
+    if len(r) == 0:
+        return {}
+    ann_ret = float(np.mean(r) * bars_per_year)
+    ann_vol = float(np.std(r, ddof=1) * np.sqrt(bars_per_year))
+    sharpe = ann_ret / ann_vol if ann_vol > 0 else float("nan")
+    downside = r[r < 0]
+    dd_dev = (
+        float(np.std(downside, ddof=1) * np.sqrt(bars_per_year))
+        if len(downside) > 1
+        else float("nan")
+    )
+    sortino = ann_ret / dd_dev if dd_dev and dd_dev > 0 else float("nan")
+    eq = np.exp(np.cumsum(r))
+    peak = np.maximum.accumulate(eq)
+    dd = (eq - peak) / peak
+    max_dd = float(dd.min())
+    calmar = ann_ret / abs(max_dd) if max_dd < 0 else float("nan")
+    hit_rate = float((r > 0).mean())
+    total_log_ret = float(r.sum())
+    total_mult = float(np.exp(total_log_ret))
+    return {
+        "ann_return": ann_ret,
+        "ann_vol": ann_vol,
+        "sharpe": sharpe,
+        "sortino": sortino,
+        "max_drawdown": max_dd,
+        "calmar": calmar,
+        "hit_rate": hit_rate,
+        "total_log_return": total_log_ret,
+        "total_multiplier": total_mult,
+        "n_days": int(len(r)),
+    }
+
+
+def drawdown_series(net_returns: pd.Series) -> pd.Series:
+    """(equity - peak) / peak on the supplied log-return series."""
+    eq = np.exp(net_returns.fillna(0.0).cumsum())
+    peak = eq.cummax()
+    return cast(pd.Series, (eq - peak) / peak)
+
+
+def result_from_dataframe(df: pd.DataFrame) -> BacktestResult:
+    """Convert a spike-shaped strategy DataFrame to a frozen container."""
+    return BacktestResult(
+        gross_ret=tuple(df["gross_ret"].to_list()),
+        net_ret=tuple(df["net_ret"].to_list()),
+        turnover=tuple(df["turnover"].to_list()),
+        leverage=tuple(df["leverage"].to_list()),
+        regime=tuple(df["regime"].astype(str).to_list()),
+        index_iso=tuple(df.index.map(lambda ts: ts.isoformat()).to_list()),
+    )