alphaengine 1.1.1__tar.gz → 1.1.2__tar.gz

{alphaengine-1.1.1 → alphaengine-1.1.2}/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to Semantic Versioning (with computed golden values
 treated as part of the public contract).
 
+## [1.1.2] - 2026-10-24
+
+### Fixed
+- **Array-like inputs across validation and metrics (`core/validation.py`, `core/performance.py`, `core/risk.py`):** Replaced truthiness checks (`returns or []`, `if equity_curve:`, `if benchmark_returns:`, `portfolio_returns or []`) with `np.asarray` conversion so `deflated_sharpe`, `min_track_record_length`, `combinatorial_oos_stability` / `cpcv_score`, `pbo_cscv`, `performance_report`, and `compute_var_cvar` accept Python `list`, NumPy `ndarray`, and pandas `Series` / `DataFrame` without raising `ValueError: The truth value of an array/Series is ambiguous`.
+- **Complete `_GATED_COMMANDS` and unified 401/403 refusal (`cli.py`):** Added `workflows`, `runs`, `gaps`, and `tonight` to `_GATED_COMMANDS` so every gated command goes through `require_firm_key()`, and replaced the separate `"Not authenticated"` refusal block with `FIRM_KEY_ERROR_MESSAGE`.
+- **Live-monitor trial accounting (`watch.py`):** `ae monitor <run> --live <file>` (`monitor_live`) now records `n_trials=0` (`already_counted_in_ledger=True`) so out-of-sample live drift checks never inflate the project's cumulative trial count `N`.
+- **Clean SLSQP bounds clipping (`core/process.py`, `core/allocate.py`):** Suppressed the benign SciPy SLSQP bounds-clipping `RuntimeWarning` during GARCH(1,1) and risk-parity optimization.
+
+### Changed
+- **Security policy (`SECURITY.md`):** Replaced personal email contact with [GitHub Private Vulnerability Reporting / Security Advisories](https://github.com/quantOSC/alphaengine/security/advisories/new).
+
 ## [1.1.1] - 2026-10-24
 
 ### Added

{alphaengine-1.1.1 → alphaengine-1.1.2}/PKG-INFO

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

{alphaengine-1.1.1 → alphaengine-1.1.2}/SECURITY.md

@@ -2,9 +2,8 @@
 
 ## Reporting a vulnerability
 
-Report privately through [GitHub Private Vulnerability Reporting / Security Advisories](https://github.com/quantOSC/alphaengine/security/advisories/new),
-or email **wfe818@gmail.com**. Please don't open a public issue for a
-suspected vulnerability.
+Report privately through [GitHub Private Vulnerability Reporting / Security Advisories](https://github.com/quantOSC/alphaengine/security/advisories/new).
+Please don't open a public issue for a suspected vulnerability.
 
 We'll acknowledge within **3 working days** and give an assessment within **10**.
 If we accept the report we'll agree a disclosure timeline with you and credit
@@ -13,8 +12,8 @@ you in the advisory unless you'd rather we didn't.
 ## What's in scope
 
 This repository: the library, its build, and its release pipeline. The hosted
-platform is a separate system, report issues there to the same address and say
-so.
+platform is a separate system; report issues there through the same private
+vulnerability reporting channel and say so.
 
 ## How this package is built and shipped
 

{alphaengine-1.1.1 → alphaengine-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "alphaengine"
-version = "1.1.1"
+version = "1.1.2"
 description = "Validated research tooling for investment strategies: deflation, overfitting detection, and honest trial counts."
 readme = "README.md"
 license = "Apache-2.0"

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/cli.py

@@ -3673,21 +3673,9 @@ def boot(url: str, *, project: str | None, data: Any, keyed: bool, session: Any
 
 
 def refused(exc: Any) -> None:
-    """Report a server refusal, and make an AUTH refusal actionable.
+    """Report a server refusal; 401/403 emit the canonical firm-key message."""
+    from .auth import FIRM_KEY_ERROR_MESSAGE
 
-    ── WHY THIS IS NOT JUST A RED LINE ────────────────────────────────────────
-
-    "The server refused: Authentication required" is true, useless, and actively
-    misleading to somebody who IS a paying user — they are signed into the
-    portal in a browser two windows away, so the natural reading is that
-    something is broken. It is not: a browser session is not a CLI credential
-    and never will be, because this process has no cookie jar and should not
-    acquire one.
-
-    So a 401 says what is actually wrong, where the key comes from, and offers
-    to take it right here. Every other status keeps the plain message, because
-    the fix for a 404 or a 422 is not a credential.
-    """
     status = getattr(exc, "status", None)
     detail = getattr(exc, "detail", str(exc))
 
@@ -3695,34 +3683,7 @@ def refused(exc: Any) -> None:
         say(red(f"The server refused: {detail}"))
         return
 
-    say("")
-    say(
-        yellow("  Not authenticated.")
-        + dim(
-            "  This command requires a portal-issued ae_live_ key; "
-            "your browser login does not reach this process."
-        )
-    )
-    say(dim("  A browser session is a cookie; this needs a key. They are different"))
-    say(dim("  credentials on purpose."))
-    say("")
-    say(
-        "  " + dim("Need one:") + " a portal-issued ae_live_ key (request access at https://qosai.app/access)"
-    )
-    say("  " + dim("Get one:") + f"  the portal {ARROW} Data {ARROW} API keys {ARROW} New key")
-    say("  " + dim("Then:") + "     " + bold("login") + dim(f"   (or export {_ENV_KEY}=ae_live_...)"))
-    say(
-        "  "
-        + dim("Offline:")
-        + "  "
-        + bold("alphaengine demo")
-        + dim(", ")
-        + bold("alphaengine process")
-        + dim(", and the Python API (")
-        + bold("import alphaengine")
-        + dim(") work without an account.")
-    )
-    say("")
+    say(red(FIRM_KEY_ERROR_MESSAGE))
 
 
 def offer_key(which: str = "quantos") -> bool:
@@ -5603,6 +5564,10 @@ _GATED_COMMANDS: frozenset[str] = frozenset(
     {
         "run",
         *QUESTION_VERBS.keys(),
+        "workflows",
+        "runs",
+        "gaps",
+        "tonight",
         "init",
         "log",
         "show",

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/allocate.py

@@ -13,6 +13,7 @@ test, not a hope.
 from __future__ import annotations
 
 import math
+import warnings
 from typing import Any
 
 import numpy as np
@@ -135,7 +136,13 @@ def risk_parity_weights(cov: np.ndarray, *, names: list[str] | None = None) -> d
 
     bounds = [(0.0, 1.0)] * n
     cons = {"type": "eq", "fun": lambda w: float(np.sum(w) - 1.0)}
-    result = minimize(objective, w0, method="SLSQP", bounds=bounds, constraints=cons, tol=1e-12)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message="Values in x were outside bounds during a minimize step",
+            category=RuntimeWarning,
+        )
+        result = minimize(objective, w0, method="SLSQP", bounds=bounds, constraints=cons, tol=1e-12)
     raw = np.clip(result.x if result.success else w0, 0.0, None)
     raw = raw / raw.sum()
     weights = _rounded_weights(raw, labels)

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/backtest.py

@@ -399,9 +399,9 @@ def _ar1_effective_n(returns: list) -> tuple:
     t-stat; this discounts it. Conservative convention: capped at n, so NEGATIVE
     autocorrelation is not credited (never claims more significance than the raw
     sample). Returns (n_eff, r1)."""
-    import numpy as np
+    from .validation import _as_1d_float
 
-    arr = np.asarray([float(r) for r in (returns or []) if r is not None], dtype=float)
+    arr = _as_1d_float(returns)
     n = arr.size
     if n < 3:
         return (float(n), 0.0)

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/pairs.py

@@ -113,7 +113,9 @@ def _series_to_list(s) -> list[float]:
     """A series is either a list of closes or a {date: close} dict (sorted by date)."""
     if isinstance(s, dict):
         return [float(s[k]) for k in sorted(s.keys())]
-    return [float(x) for x in (s or []) if x is not None]
+    if s is None:
+        return []
+    return [float(x) for x in np.asarray(s).ravel() if x is not None]
 
 
 def _align_pair(a, b) -> tuple[list[float], list[float]]:

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/performance.py

@@ -15,11 +15,15 @@ both decimal and percent; the sign convention is documented per field.
 from __future__ import annotations
 
 import math
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
+from numpy.typing import ArrayLike
 
 from .rates import cash_rate, rate_fields
 from .trace import record
+from .validation import _as_1d_float
 
 _PPY = 252  # trading periods per year
 
@@ -45,20 +49,20 @@ def wealth_from_returns(returns: np.ndarray) -> np.ndarray:
 
 
 def performance_report(
-    returns: list[float],
+    returns: ArrayLike | Sequence[float],
     *,
-    equity_curve: list[float] | None = None,
-    benchmark_returns: list[float] | None = None,
+    equity_curve: ArrayLike | Sequence[float] | None = None,
+    benchmark_returns: ArrayLike | Sequence[float] | None = None,
     risk_free_rate: float | None = None,
     periods_per_year: int = _PPY,
-) -> dict:
+) -> dict[str, Any]:
     """Risk-adjusted performance metrics for a daily return series (decimals).
 
     `risk_free_rate` is ANNUAL. Omitted, it is the pinned H.15 3-month
     Treasury (see ``core.rates``). The engine does not fetch a rate. Loss
     metrics are positive magnitudes.
     """
-    arr = np.asarray([float(r) for r in (returns or []) if r is not None], dtype=float)
+    arr = _as_1d_float(returns)
     n = arr.size
     if n < 30:
         return {"error": "need >= 30 observations", "n_obs": int(n)}
@@ -83,7 +87,8 @@ def performance_report(
     # Drawdown reads a marked account when one was supplied. Otherwise the
     # path is built from unit capital. Total return always comes from the
     # return product: a dollar curve's last mark minus one is not a return.
-    eq = np.asarray(equity_curve, dtype=float) if equity_curve else wealth_from_returns(arr)
+    eq_arr = _as_1d_float(equity_curve)
+    eq = eq_arr if eq_arr.size > 0 else wealth_from_returns(arr)
     peak = np.maximum.accumulate(eq)
     drawdown = eq / np.maximum(peak, 1e-18) - 1.0
     max_dd = float(drawdown.min()) if drawdown.size else 0.0
@@ -115,8 +120,8 @@ def performance_report(
         "alpha_annualization": "arithmetic",
     }
 
-    if benchmark_returns:
-        b = np.asarray([float(x) for x in benchmark_returns], dtype=float)
+    b = _as_1d_float(benchmark_returns)
+    if b.size > 0:
         m = min(len(b), n)
         if m >= 30:
             a2, b2 = arr[-m:] - rf_per, b[-m:] - rf_per

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/process.py

@@ -17,6 +17,7 @@ TRIAL COUNT HONESTY. A Monte Carlo stress records `n_trials = n_paths` with
 from __future__ import annotations
 
 import math
+import warnings
 from typing import Any
 
 import numpy as np
@@ -330,7 +331,13 @@ def garch_calibrate(values: Any) -> dict[str, Any]:
     x0 = np.array([var0 * 0.05, 0.05, 0.90], dtype=float)
     bounds = [(1e-18, None), (0.0, 0.999), (0.0, 0.999)]
     cons = {"type": "ineq", "fun": lambda p: 0.998 - p[1] - p[2]}
-    result = minimize(nll, x0, method="SLSQP", bounds=bounds, constraints=cons, tol=1e-12)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message="Values in x were outside bounds during a minimize step",
+            category=RuntimeWarning,
+        )
+        result = minimize(nll, x0, method="SLSQP", bounds=bounds, constraints=cons, tol=1e-12)
     omega, alpha, beta = result.x if result.success else x0
     omega, alpha, beta = float(omega), float(alpha), float(beta)
     persist = alpha + beta

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/risk.py

@@ -17,11 +17,15 @@ Pure numpy/scipy. Deterministic given inputs on the pinned stack.
 from __future__ import annotations
 
 import math
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
+from numpy.typing import ArrayLike
 from scipy import stats
 
 from .trace import record
+from .validation import _as_1d_float
 
 
 def _clean(val):
@@ -48,26 +52,20 @@ def _quantile_loss(point: float, mean: float, horizon: int) -> float:
 
 
 def compute_var_cvar(
-    portfolio_returns: list[float],
+    portfolio_returns: ArrayLike | Sequence[float],
     *,
     confidence: float = 0.95,
     horizon_days: int = 1,
     portfolio_value: float = 100_000.0,
     bootstrap_samples: int = 1000,
-) -> dict:
+) -> dict[str, Any]:
     """Portfolio VaR (parametric + Cornish-Fisher + historical) and CVaR.
 
     `portfolio_returns`: historical daily portfolio returns as decimals. VaR is
     reported as a positive loss fraction (and dollars at `portfolio_value`).
     """
-    arr = np.array(
-        [
-            r
-            for r in (portfolio_returns or [])
-            if r is not None and not (isinstance(r, float) and np.isnan(r))
-        ],
-        dtype=float,
-    )
+    raw = _as_1d_float(portfolio_returns)
+    arr = raw[~np.isnan(raw)]
     n_obs = arr.size
     if n_obs < 20:
         return {"error": "need >= 20 observations", "n_obs": int(n_obs)}

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/technical.py

@@ -54,7 +54,9 @@ def _extract(series: Any) -> tuple[np.ndarray, np.ndarray | None, np.ndarray | N
             lows = np.asarray([float(r["low"]) for r in rows], dtype=float)
             return closes, highs, lows
         return closes, None, None
-    closes = np.asarray([float(x) for x in (series or []) if x is not None], dtype=float)
+    from .validation import _as_1d_float
+
+    closes = _as_1d_float(series)
     return closes, None, None
 
 

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/core/validation.py

@@ -17,8 +17,11 @@ from __future__ import annotations
 import itertools
 import math
 import warnings
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
+from numpy.typing import ArrayLike
 from scipy import stats
 
 from .rates import cash_rate, rate_fields
@@ -27,6 +30,19 @@ from .trace import record
 _EULER = 0.5772156649015329
 
 
+def _as_1d_float(values: ArrayLike | Sequence[float] | None) -> np.ndarray:
+    """Convert any 1-D array-like (list, ndarray, pandas Series) to a 1-D float ndarray, dropping None."""
+    if values is None:
+        return np.empty(0, dtype=float)
+    raw = np.asarray(values)
+    if raw.ndim == 0:
+        item = raw.item()
+        return np.empty(0, dtype=float) if item is None else np.asarray([float(item)], dtype=float)
+    if raw.dtype.kind in ("f", "i", "u"):
+        return raw.astype(float, copy=False).ravel()
+    return np.asarray([float(r) for r in raw.ravel() if r is not None], dtype=float)
+
+
 # ── Sharpe statistics ───────────────────────────────────────────────────
 
 
@@ -78,13 +94,13 @@ def expected_max_sharpe(n_trials: int, trials_sharpe_std: float) -> float:
 
 
 def deflated_sharpe(
-    returns: list[float],
+    returns: ArrayLike | Sequence[float],
     *,
     n_trials: int,
     trials_sharpe_std: float | None = None,
     risk_free_rate: float | None = None,
     periods_per_year: int = 252,
-) -> dict:
+) -> dict[str, Any]:
     """Deflated Sharpe Ratio for a return stream.
 
     DSR = PSR(SR0), where SR0 = expected max Sharpe across `n_trials`. A DSR
@@ -93,7 +109,7 @@ def deflated_sharpe(
     caller's hypothesis ledger; when absent we estimate it from the result's
     own sampling error (a conservative lower bound on selection variance).
     """
-    arr = np.asarray([float(r) for r in (returns or []) if r is not None], dtype=float)
+    arr = _as_1d_float(returns)
     n = arr.size
     if n < 8:
         return {"error": "need >= 8 observations", "n_obs": int(n)}
@@ -170,13 +186,13 @@ def deflated_sharpe(
 
 
 def min_track_record_length(
-    returns: list[float],
+    returns: ArrayLike | Sequence[float],
     *,
     sr_benchmark: float = 0.0,
     confidence: float = 0.95,
     risk_free_rate: float | None = None,
     periods_per_year: int = 252,
-) -> dict:
+) -> dict[str, Any]:
     """Minimum Track Record Length (Bailey & López de Prado, 2012): the number of
     observations needed for the observed Sharpe to be statistically greater than
     `sr_benchmark` at `confidence`. Answers "is this backtest long enough to trust,
@@ -185,7 +201,7 @@ def min_track_record_length(
     MinTRL = 1 + [1 - γ3·SR + ((γ4-1)/4)·SR²] · (Z_α / (SR - SR*))²  (per-period).
     Returns the required count + whether the actual sample already clears it.
     """
-    arr = np.asarray([float(r) for r in (returns or []) if r is not None], dtype=float)
+    arr = _as_1d_float(returns)
     n = arr.size
     if n < 8:
         return {"error": "need >= 8 observations", "n_obs": int(n)}
@@ -257,6 +273,8 @@ def pbo_cscv(pnl_matrix, n_splits: int = 10, max_combos: int = 2000) -> dict:
             f"n_splits must be an even integer >= 2 (got {n_splits!r}); "
             "CSCV partitions blocks into equal in-sample and out-of-sample halves."
         )
+    if pnl_matrix is None:
+        return {"error": "need (T>=2S observations, N>=2 configs)", "shape": [0]}
     M = np.asarray(pnl_matrix, dtype=float)
     if M.ndim != 2 or M.shape[1] < 2 or M.shape[0] < n_splits * 2:
         return {"error": "need (T>=2S observations, N>=2 configs)", "shape": list(M.shape)}
@@ -313,7 +331,7 @@ def pbo_cscv(pnl_matrix, n_splits: int = 10, max_combos: int = 2000) -> dict:
 
 
 def combinatorial_oos_stability(
-    returns: list[float],
+    returns: ArrayLike | Sequence[float],
     *,
     n_groups: int = 8,
     n_test_groups: int = 2,
@@ -323,7 +341,7 @@ def combinatorial_oos_stability(
     max_paths: int = 2000,
     risk_free_rate: float | None = None,
     periods_per_year: int = 252,
-) -> dict:
+) -> dict[str, Any]:
     """Combinatorial out-of-sample stability over a single pre-computed return stream.
 
     WHAT THIS MEASURES (AND HOW IT DIFFERS FROM FULL CPCV):
@@ -342,7 +360,7 @@ def combinatorial_oos_stability(
     deflated Sharpe (haircut by `n_trials`) across all held-out sub-sample
     combinations.
     """
-    arr = np.asarray([float(r) for r in (returns or []) if r is not None], dtype=float)
+    arr = _as_1d_float(returns)
     n = arr.size
     if n < 8:
         return {"error": "need >= 8 observations", "n_obs": int(n)}
@@ -465,7 +483,7 @@ def combinatorial_oos_stability(
 
 
 def cpcv_score(
-    returns: list[float],
+    returns: ArrayLike | Sequence[float],
     *,
     n_groups: int = 8,
     n_test_groups: int = 2,
@@ -475,7 +493,7 @@ def cpcv_score(
     max_paths: int = 2000,
     risk_free_rate: float | None = None,
     periods_per_year: int = 252,
-) -> dict:
+) -> dict[str, Any]:
     """Deprecated alias for :func:`combinatorial_oos_stability`.
 
     Measures combinatorial out-of-sample sub-sample stability on a single return

{alphaengine-1.1.1 → alphaengine-1.1.2}/src/alphaengine/watch.py

@@ -248,12 +248,13 @@ def monitor_live_drift(
         command="monitor_live",
         params={"reference_run_id": run_rec.get("run_id"), "live_file": str(lp.name)},
         dataset_hashes=hash_dataset_any(live_list),
-        n_trials=1,
+        n_trials=0,
         n_trials_source="monitor_live",
         figures=figures,
         verdict=status,
         idea_id=run_rec.get("idea_id"),
         family=str(run_rec.get("family") or "monitor"),
+        already_counted_in_ledger=True,
     )
     return build_envelope(
         command="monitor_live",
@@ -265,7 +266,7 @@ def monitor_live_drift(
         family=str(rec["family"]),
         params_hash=str(rec["params_hash"]),
         dataset_hashes=rec["dataset_hashes"],
-        n_trials=1,
+        n_trials=int(rec["cumulative_trials"]),
         n_trials_source="monitor_live",
         cumulative_trials=int(rec["cumulative_trials"]),
         project_trials=int(rec["project_trials"]),

{alphaengine-1.1.1 → alphaengine-1.1.2}/tests/test_cli.py

@@ -238,7 +238,16 @@ def test_the_glyphs_are_the_real_ones_when_the_stream_can_take_them():
 def test_offline_names_the_host_and_the_half_that_still_works():
     """A workflow server being absent is not an error state for this package."""
     out = subprocess.run(
-        [sys.executable, "-m", "alphaengine.cli", "workflows", "--url", "http://127.0.0.1:9"],
+        [
+            sys.executable,
+            "-m",
+            "alphaengine.cli",
+            "workflows",
+            "--url",
+            "http://127.0.0.1:9",
+            "--key",
+            "ae_live_test",
+        ],
         capture_output=True,
         text=True,
     )
@@ -578,24 +587,20 @@ class _Refusal(RuntimeError):
 
 
 def test_a_401_explains_that_a_browser_login_is_not_a_cli_credential(capsys, monkeypatch):
-    """THE REPORTED BUG. A paying user, signed into the portal, read
-    "Authentication required" as the product being broken. It is not: this
-    process has no cookie jar and should never acquire one."""
+    from alphaengine.auth import FIRM_KEY_ERROR_MESSAGE
+
     monkeypatch.setattr(cli, "_tty", lambda: True)
     cli.refused(_Refusal(401, "Authentication required"))
     out = capsys.readouterr().out
-    assert "browser login does not reach this process" in out
-    assert "ae_live_" in out
-    assert "https://qosai.app/access" in out
-    assert "Data" in out and "API keys" in out, "it must say where the key comes from"
-    assert "Then:" in out and "QUANTOS_API_KEY" in out, "and how to enter one"
-    assert "alphaengine demo" in out and "alphaengine process" in out and "import alphaengine" in out
+    assert FIRM_KEY_ERROR_MESSAGE in out
 
 
 def test_a_403_is_treated_the_same_way(capsys, monkeypatch):
+    from alphaengine.auth import FIRM_KEY_ERROR_MESSAGE
+
     monkeypatch.setattr(cli, "_tty", lambda: True)
     cli.refused(_Refusal(403, "Forbidden"))
-    assert "Not authenticated" in capsys.readouterr().out
+    assert FIRM_KEY_ERROR_MESSAGE in capsys.readouterr().out
 
 
 def test_a_non_auth_refusal_keeps_the_plain_message(capsys, monkeypatch):

{alphaengine-1.1.1 → alphaengine-1.1.2}/tests/test_math_audit.py

@@ -349,3 +349,84 @@ def test_the_pair_screen_keeps_only_the_fdr_survivors() -> None:
     # One pair is the raw test.
     assert _benjamini_hochberg([0.04], 0.05) == [True]
     assert _benjamini_hochberg([0.06], 0.05) == [False]
+
+
+def test_array_like_list_ndarray_and_series_across_validation_and_metrics() -> None:
+    """deflated_sharpe, min_track_record_length, combinatorial_oos_stability,
+    cpcv_score, pbo_cscv, performance_report, and compute_var_cvar accept
+    Python lists, numpy ndarrays, and pandas Series (whose __bool__ raises
+    ValueError) and return identical figures.
+    """
+    from alphaengine.core import min_track_record_length
+
+    class _FakeSeries:
+        """Mimics pandas.Series: array-like via __array__, raises ValueError on bool()."""
+
+        def __init__(self, data: list[float]) -> None:
+            self._arr = np.asarray(data, dtype=float)
+
+        def __bool__(self) -> bool:
+            raise ValueError("The truth value of a Series is ambiguous.")
+
+        def __len__(self) -> int:
+            return int(self._arr.size)
+
+        def __iter__(self):
+            return iter(self._arr)
+
+        def __array__(self, dtype=None):
+            return np.asarray(self._arr, dtype=dtype)
+
+    try:
+        import pandas as pd
+
+        series_cls = pd.Series
+        df_cls = pd.DataFrame
+    except ImportError:
+        series_cls = _FakeSeries
+        df_cls = None
+
+    rng = np.random.default_rng(17)
+    as_list = rng.normal(0.0008, 0.012, 120).tolist()
+    as_ndarray = np.asarray(as_list, dtype=float)
+    as_series = series_cls(as_list)
+    as_fake_series = _FakeSeries(as_list)
+
+    bench_list = rng.normal(0.0004, 0.01, 120).tolist()
+    bench_ndarray = np.asarray(bench_list, dtype=float)
+    bench_series = series_cls(bench_list)
+
+    # 1. deflated_sharpe & min_track_record_length
+    dsr_list = deflated_sharpe(as_list, n_trials=9)
+    mart_list = min_track_record_length(as_list)
+    for candidate in (as_ndarray, as_series, as_fake_series):
+        assert deflated_sharpe(candidate, n_trials=9) == dsr_list
+        assert min_track_record_length(candidate) == mart_list
+
+    # 2. combinatorial_oos_stability & cpcv_score
+    stab_list = combinatorial_oos_stability(as_list, n_groups=6, n_test_groups=2, n_trials=9)
+    for candidate in (as_ndarray, as_series, as_fake_series):
+        assert combinatorial_oos_stability(candidate, n_groups=6, n_test_groups=2, n_trials=9) == stab_list
+        with pytest.deprecated_call(match="combinatorial_oos_stability"):
+            assert cpcv_score(candidate, n_groups=6, n_test_groups=2, n_trials=9) == stab_list
+
+    # 3. pbo_cscv (2-D list, 2-D ndarray, list of Series, and DataFrame if pandas present)
+    mat_list = rng.normal(0.0005, 0.01, size=(80, 6)).tolist()
+    mat_ndarray = np.asarray(mat_list, dtype=float)
+    mat_series_rows = [series_cls(row) for row in mat_list]
+    pbo_expected = pbo_cscv(mat_list, n_splits=8)
+    assert pbo_cscv(mat_ndarray, n_splits=8) == pbo_expected
+    assert pbo_cscv(mat_series_rows, n_splits=8) == pbo_expected
+    if df_cls is not None:
+        assert pbo_cscv(df_cls(mat_list), n_splits=8) == pbo_expected
+
+    # 4. performance_report & compute_var_cvar
+    perf_list = performance_report(as_list, benchmark_returns=bench_list)
+    risk_list = compute_var_cvar(as_list)
+    for candidate, bench in (
+        (as_ndarray, bench_ndarray),
+        (as_series, bench_series),
+        (as_fake_series, _FakeSeries(bench_list)),
+    ):
+        assert performance_report(candidate, benchmark_returns=bench) == perf_list
+        assert compute_var_cvar(candidate) == risk_list

{alphaengine-1.1.1 → alphaengine-1.1.2}/tests/test_project.py

@@ -935,6 +935,8 @@ def test_watch_pipeline_reruns_on_dataset_change_and_monitor_live_detects_drift(
     assert cli.main(["validate", "--data", str(bt_csv), "--input", "n_trials=3", "--json"]) == 0
     bt_env = json.loads(capsys.readouterr().out)
     bt_run_id = bt_env["run_id"]
+    bt_cum_n = bt_env["cumulative_trials"]
+    bt_proj_n = bt_env["project_trials"]
 
     # Calm live returns within the expected range -> `within_expected_range`
     calm_live = tmp_path / "live_calm.csv"
@@ -946,6 +948,15 @@ def test_watch_pipeline_reruns_on_dataset_change_and_monitor_live_detects_drift(
     calm_env = json.loads(capsys.readouterr().out)
     assert calm_env["verdict"] == "within_expected_range"
     assert calm_env["figures"]["drift_flags"] == []
+    assert calm_env["figures"]["run_n_trials"] == 0
+    assert calm_env["cumulative_trials"] == bt_cum_n
+    assert calm_env["project_trials"] == bt_proj_n
+
+    # Re-running live monitor on same or updated live file never inflates cumulative N
+    assert cli.main(["monitor", bt_run_id, "--live", str(calm_live), "--json"]) == 0
+    calm_env_2 = json.loads(capsys.readouterr().out)
+    assert calm_env_2["cumulative_trials"] == bt_cum_n
+    assert calm_env_2["project_trials"] == bt_proj_n
 
     # Severe drawdown live returns outside the backtest's bootstrapped interval -> `drift_flagged`
     crash_live = tmp_path / "live_crash.csv"
@@ -958,6 +969,11 @@ def test_watch_pipeline_reruns_on_dataset_change_and_monitor_live_detects_drift(
     assert "drift_flagged" in crash_out
     assert "Research tool, not investment advice." in crash_out
 
+    from alphaengine.ledger import cumulative_trials_for
+
+    _, final_proj_n = cumulative_trials_for(proj)
+    assert final_proj_n == bt_proj_n
+
 
 def test_require_firm_key_choke_point_keyring_and_no_key_leak(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
@@ -997,6 +1013,10 @@ def test_require_firm_key_choke_point_keyring_and_no_key_leak(
         ["overlap"],
         ["size"],
         ["monitor"],
+        ["workflows"],
+        ["runs"],
+        ["gaps"],
+        ["tonight"],
         ["run", "validate_study", "--url", "http://127.0.0.1:9"],
         ["init"],
         ["log"],