privateassets 0.1.0__tar.gz

privateassets-0.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.0.1 (2026-06)
+
+Initial release of the private-asset analytics package.
+
+- `matf`: multi-factor, money-weighted PME. Tradable multi-factor deflator,
+  KS-PME / Direct Alpha / Long-Nickels, panel-MLE unsmoothing, rolling EWMA
+  covariance, sign-coherent shrinkage betas, and the MATF Direct Alpha pipeline.
+- 14 illustration scripts under `matf/illustrations/` that regenerate the
+  precursor figures via `python -m privateassets.matf <id>`.
+- Built on `qis` and `factorlasso`. No dependency on `optimalportfolios`
+  (sibling, not child).
+- Flat package layout at the repository root, matching the `optimalportfolios`
+  house style.

privateassets-0.1.0/DATA_README.md

@@ -0,0 +1,17 @@
+# Data — licensed, not committed
+
+**No data files are stored in this repository.** Every input is obtained under
+licence and placed in `data/` locally; `data/` is git-ignored in full. The public
+package must never contain vendor or LP data, nor any derived file from which it
+could be reconstructed.
+
+| Source | Used by | Granularity | Publication status |
+|---|---|---|---|
+| **MSCI Private Capital — CFO dataset** | JFQA paper, SAA/CMA | Cohort (strategy × vintage), 1990+ | Aggregated derived results publishable **with MSCI attribution + standard pre-publication review** |
+| **Preqin (BlackRock) — fund-level cash flows** | FAJ paper, selection | Named fund-level | Publication terms **pending** (Boris Hamm / BlackRock) — confirm before use |
+| **Oaktree / Crown LP cash flows** | Precursor draft only | Fund-level | **Internal only — never publishable** |
+| MATF factor levels, rate series | all | — | LGT-internal; not for public release |
+
+Rule of thumb: code is public, data is not. Before committing anything, confirm
+it contains no vendor records and no intermediate file from which they could be
+recovered.

privateassets-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artur Sepp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

privateassets-0.1.0/MANIFEST.in

@@ -0,0 +1,11 @@
+include README.md
+include DATA_README.md
+include LICENSE.txt
+include CHANGELOG.md
+recursive-include privateassets *.py
+prune data
+prune outputs
+prune projects
+prune paper_code
+global-exclude *.py[cod]
+global-exclude __pycache__

privateassets-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: privateassets
+Version: 0.1.0
+Summary: Quantitative analytics for private-asset returns: multi-factor money-weighted PME (MATF), unsmoothing, and risk-adjusted performance estimation.
+Author: Artur Sepp
+Project-URL: Homepage, https://github.com/ArturSepp/privateassets
+Keywords: private equity,private credit,private assets,PME,direct alpha,risk-adjusted returns,unsmoothing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: cvxpy
+Requires-Dist: openpyxl
+Requires-Dist: qis
+Requires-Dist: factorlasso
+Dynamic: license-file
+
+# privateassets
+
+Quantitative analytics for **private-asset returns** — private equity, private
+credit, and other private-market strategies.
+
+Core method: **MATF** — a multi-factor, money-weighted PME that estimates
+risk-adjusted alpha and systematic factor exposures (β) directly from private-asset
+cash flows, generalising Direct Alpha / KS-PME / GPME from a single benchmark to a
+multi-factor deflator. Additional analytics (unsmoothing, volatility/beta
+estimation) currently live within `matf` and may be promoted to top-level
+submodules as they generalise.
+
+Built on [`qis`](https://pypi.org/project/qis/) and
+[`factorlasso`](https://pypi.org/project/factorlasso/); it does **not** depend on
+`optimalportfolios` (sibling, not child).
+
+## Install
+
+```bash
+pip install privateassets        # once published
+# or, from source:
+pip install -e .
+```
+
+```python
+import privateassets
+from privateassets.matf import ...   # estimator API
+```
+
+## Layout
+
+```
+privateassets/                 # MATF estimator engine (deflator, PME, panel-MLE
+│   ├── __init__.py            #   unsmoothing, rolling covar, shrinkage, pipeline)
+│   └── matf/
+│       └── illustrations/     # 14 figure scripts (python -m privateassets.matf <id>)
+scripts/                       # reproduction runners
+paper_code/                    # publication tracks: jfqa_matf_pme, faj_application (unwritten)
+data/                          # git-ignored, private: licensed inputs (see DATA_README.md)
+outputs/                       # git-ignored: generated artifacts
+projects/                      # git-ignored, private: mandate engagements (not part of the package)
+```
+
+## Papers
+
+`paper_code/` holds the clean, public publication tracks. The JFQA paper
+(estimator + theory, MSCI cohort data) and the FAJ paper (fund-level application,
+Preqin data) are not yet written. The precursor Oaktree manuscript runs on
+proprietary LP data and is kept in the private `projects/` tree, out of this
+public package.
+
+## Data
+
+No data is stored in this repository. All vendor / LP data is obtained under
+licence and placed in `data/` (git-ignored). See `DATA_README.md` for the
+per-source licensing rules before adding or committing anything.

privateassets-0.1.0/README.md

@@ -0,0 +1,56 @@
+# privateassets
+
+Quantitative analytics for **private-asset returns** — private equity, private
+credit, and other private-market strategies.
+
+Core method: **MATF** — a multi-factor, money-weighted PME that estimates
+risk-adjusted alpha and systematic factor exposures (β) directly from private-asset
+cash flows, generalising Direct Alpha / KS-PME / GPME from a single benchmark to a
+multi-factor deflator. Additional analytics (unsmoothing, volatility/beta
+estimation) currently live within `matf` and may be promoted to top-level
+submodules as they generalise.
+
+Built on [`qis`](https://pypi.org/project/qis/) and
+[`factorlasso`](https://pypi.org/project/factorlasso/); it does **not** depend on
+`optimalportfolios` (sibling, not child).
+
+## Install
+
+```bash
+pip install privateassets        # once published
+# or, from source:
+pip install -e .
+```
+
+```python
+import privateassets
+from privateassets.matf import ...   # estimator API
+```
+
+## Layout
+
+```
+privateassets/                 # MATF estimator engine (deflator, PME, panel-MLE
+│   ├── __init__.py            #   unsmoothing, rolling covar, shrinkage, pipeline)
+│   └── matf/
+│       └── illustrations/     # 14 figure scripts (python -m privateassets.matf <id>)
+scripts/                       # reproduction runners
+paper_code/                    # publication tracks: jfqa_matf_pme, faj_application (unwritten)
+data/                          # git-ignored, private: licensed inputs (see DATA_README.md)
+outputs/                       # git-ignored: generated artifacts
+projects/                      # git-ignored, private: mandate engagements (not part of the package)
+```
+
+## Papers
+
+`paper_code/` holds the clean, public publication tracks. The JFQA paper
+(estimator + theory, MSCI cohort data) and the FAJ paper (fund-level application,
+Preqin data) are not yet written. The precursor Oaktree manuscript runs on
+proprietary LP data and is kept in the private `projects/` tree, out of this
+public package.
+
+## Data
+
+No data is stored in this repository. All vendor / LP data is obtained under
+licence and placed in `data/` (git-ignored). See `DATA_README.md` for the
+per-source licensing rules before adding or committing anything.

privateassets-0.1.0/privateassets/__init__.py

@@ -0,0 +1,11 @@
+"""privateassets — quantitative analytics for private-asset returns.
+
+Core method: MATF — multi-factor, money-weighted PME (risk-adjusted alpha and
+factor exposures from private-asset cash flows). Additional analytics
+(unsmoothing, volatility/beta estimation) currently live under `matf` and may
+be promoted to top-level submodules as they generalise.
+
+Built on `qis` and `factorlasso`.
+"""
+
+__version__ = "0.0.1"

privateassets-0.1.0/privateassets/matf/__init__.py

@@ -0,0 +1,47 @@
+"""
+privateassets.matf — multi-factor, money-weighted PME.
+
+Estimates risk-adjusted alpha and systematic factor exposures (beta) directly
+from private-asset cash flows. Generalises Direct Alpha, KS-PME and GPME from a
+single benchmark to a tradable multi-factor deflator, with sign-coherent
+shrinkage betas (factorlasso / HCGL), panel-MLE AR(1) unsmoothing, and
+block-bootstrap inference.
+
+Modules
+-------
+  _pme.py            KS-PME, Direct Alpha, Long-Nickels, and XIRR
+  _pipeline.py       core estimator: shrinkage betas, deflator, Direct Alpha ladder
+  _deflator.py       rolling-Sigma multi-factor deflator
+  _unsmooth.py       fixed-theta AR(1) Getmansky-Lo-Makarov unsmoothing
+  _panel_mle.py      panel MLE for the AR(1) unsmoothing coefficient
+  _rolling_covar.py  qis-canonical rolling EWMA factor covariance
+
+Data and outputs
+----------------
+Run from the repository root. Inputs are read from data/ and results written to
+outputs/, both resolved against the current working directory (override with
+PRIVATEASSETS_ROOT). Input data is licensed and is never shipped with the
+package. See DATA_README.md.
+
+Built on qis and factorlasso. No dependency on optimalportfolios.
+"""
+from pathlib import Path
+import os
+
+# Repo root: where data/ and outputs/ live. Default is the current working
+# directory (run the CLI from the repo root); override with PRIVATEASSETS_ROOT.
+# Never resolved relative to the installed package, so a pip-installed copy
+# does not read from or write into site-packages.
+PROJECT_ROOT = Path(os.environ.get("PRIVATEASSETS_ROOT", os.getcwd())).resolve()
+DATA_DIR = PROJECT_ROOT / 'data'
+OUTPUT_DIR = PROJECT_ROOT / 'outputs'
+
+# Ensure outputs dir exists at import time
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Convenience handles to the three data files
+DATA_XLSX = DATA_DIR / 'data.xlsx'
+FACTORS_CSV = DATA_DIR / 'factors.csv'
+RF_CSV = DATA_DIR / 'rf_rate.csv'
+
+__version__ = "0.0.1"

privateassets-0.1.0/privateassets/matf/_deflator.py

@@ -0,0 +1,187 @@
+"""
+Rolling-Sigma multi-factor deflator.
+
+Builds the multi-factor PME deflator
+    R^b_h = exp{ rf*h + beta'r_h + (1/2)(beta'diag(Sigma_h) - beta'Sigma_h beta) }
+with a time-varying factor covariance Sigma_h. At each quarter-end the
+covariance is an EWMA estimate on a trailing window of monthly factor returns
+(span 36 months), so the deflator at a cash flow date uses only information
+available by that date.
+
+Specification:
+  - Monthly factor returns: end-of-month level to log excess return
+  - EWMA span: 36 months (about a 3-year half-life)
+  - Quarterly covariance: monthly Sigma times 3
+  - Burn-in: 36 months before the first cash flow date
+
+Author: A. Sepp / the desk
+"""
+from __future__ import annotations
+
+from typing import Dict
+
+import numpy as np
+import pandas as pd
+from factorlasso import compute_ewm_covar
+
+from privateassets.matf._pipeline import (
+    cf_with_terminal_for_vintage,
+    vintage_da_fast,
+)
+
+
+def factor_monthly_log_returns(levels_daily: pd.DataFrame) -> pd.DataFrame:
+    """End-of-month log returns from daily levels."""
+    me = levels_daily.resample('ME').last()
+    return np.log(me / me.shift(1)).dropna(how='all')
+
+
+def rolling_ewma_quarterly_covar(
+    levels_daily: pd.DataFrame,
+    quarter_ends: pd.DatetimeIndex,
+    span_months: int = 36,
+    burnin_months: int = 36,
+) -> Dict[pd.Timestamp, np.ndarray]:
+    """
+    Build a dict mapping each quarter-end to an EWMA covariance matrix
+    estimated on monthly factor returns with span = span_months.
+
+    The returned Σ are SCALED TO A QUARTERLY HORIZON: monthly Σ × 3
+    (the standard variance-time-scaling under iid). This is consistent
+    with how the deflator uses Σ_h (h = 1 quarter for adjacent cash flow
+    dates within the same quarter).
+    """
+    monthly_log = factor_monthly_log_returns(levels_daily)
+
+    sigmas = {}
+    for q in quarter_ends:
+        # Monthly returns up to and including this quarter end
+        m_end = q.to_period('M').to_timestamp(how='end').normalize()
+        window = monthly_log.loc[:m_end].dropna(how='any')
+        if len(window) < burnin_months:
+            continue
+        # EWMA covariance on monthly excess log returns, demean within the window
+        Xv = window.values
+        Xv_dm = Xv - Xv.mean(axis=0)
+        sigma_monthly = compute_ewm_covar(a=Xv_dm, span=span_months)
+        sigma_quarterly = sigma_monthly * 3.0  # variance-time scaling
+        sigmas[q] = sigma_quarterly
+    return sigmas
+
+
+def matf_deflator_rolling(
+    cf_dates: list,
+    t0: pd.Timestamp,
+    cum_log_factor_q: np.ndarray,    # (T, M) cumulative log factor returns at QE
+    cum_log_rf_q: np.ndarray,        # (T,) cumulative log(1+rf) at QE
+    quarters_q: pd.DatetimeIndex,
+    quarters_ns: np.ndarray,
+    beta_vec: np.ndarray,
+    sigma_h_dict: Dict[pd.Timestamp, np.ndarray],
+    sigma_h_default: np.ndarray,
+) -> np.ndarray:
+    """
+    Deflator with quarter-specific Σ_h pulled from sigma_h_dict.
+    For each cash flow date d, find the most recent quarter-end ≤ d,
+    look up Σ_h for that quarter (or use sigma_h_default if missing
+    due to burn-in), then evaluate Eq 3.
+    """
+    cf_ns = np.array([pd.Timestamp(t).value for t in cf_dates], dtype=np.int64)
+    t0_ns = pd.Timestamp(t0).value
+    n_q = len(quarters_ns)
+
+    idx_t = np.clip(np.searchsorted(quarters_ns, cf_ns, side='right') - 1,
+                    0, n_q - 1)
+    idx_t0 = int(np.clip(np.searchsorted(quarters_ns, t0_ns, side='right') - 1,
+                         0, n_q - 1))
+
+    rh = cum_log_factor_q[idx_t] - cum_log_factor_q[idx_t0]   # (n_cf, M)
+    rfh = cum_log_rf_q[idx_t] - cum_log_rf_q[idx_t0]           # (n_cf,)
+
+    h_years = np.array([max((pd.Timestamp(t) - pd.Timestamp(t0)).days, 1) / 365.25
+                        for t in cf_dates])
+    h_q = h_years * 4.0
+
+    out = np.empty(len(cf_dates), dtype=float)
+    for j, t in enumerate(cf_dates):
+        q_end = quarters_q[idx_t[j]]
+        sigma = sigma_h_dict.get(q_end, sigma_h_default)
+        diag_h = np.diag(sigma)
+        quad = float(beta_vec @ sigma @ beta_vec)
+        rb_j = (rfh[j]
+                + rh[j] @ beta_vec
+                + 0.5 * h_q[j] * (beta_vec @ diag_h)
+                - 0.5 * h_q[j] * quad)
+        out[j] = np.exp(rb_j)
+    return out
+
+
+def per_vintage_da_with_rolling_covar(
+    cf: pd.DataFrame,
+    navs: pd.DataFrame,
+    asof: pd.Timestamp,
+    cum_log_factor_q: np.ndarray,
+    cum_log_rf_q: np.ndarray,
+    quarters_q: pd.DatetimeIndex,
+    quarters_ns: np.ndarray,
+    beta_arr: np.ndarray,
+    sigma_h_dict: Dict[pd.Timestamp, np.ndarray],
+    sigma_h_default: np.ndarray,
+) -> pd.DataFrame:
+    rows = []
+    for v in sorted(cf['vintage_label'].unique()):
+        cf_g = cf[cf['vintage_label'] == v]
+        nav_g = navs[navs['vintage_label'] == v]
+        cf_v, rvpi_nav, _, dates = cf_with_terminal_for_vintage(cf_g, nav_g, asof)
+        defl = matf_deflator_rolling(
+            dates, dates[0], cum_log_factor_q, cum_log_rf_q,
+            quarters_q, quarters_ns, beta_arr, sigma_h_dict, sigma_h_default)
+        da = vintage_da_fast(cf_v, rvpi_nav, dates, defl)
+        contrib = -cf_v.loc[cf_v['amount'] < 0, 'amount'].sum()
+        distrib = cf_v.loc[cf_v['amount'] > 0, 'amount'].sum()
+        dpi = distrib / contrib if contrib > 0 else float('nan')
+        rows.append({'vintage_label': v, 'contribution': contrib, 'DPI': dpi,
+                     'DA': da})
+    return pd.DataFrame(rows)
+
+
+def per_vintage_da_with_constant_covar(
+    cf: pd.DataFrame,
+    navs: pd.DataFrame,
+    asof: pd.Timestamp,
+    cum_log_factor_q: np.ndarray,
+    cum_log_rf_q: np.ndarray,
+    quarters_q: pd.DatetimeIndex,
+    quarters_ns: np.ndarray,
+    beta_arr: np.ndarray,
+    sigma_h_const: np.ndarray,
+) -> pd.DataFrame:
+    rows = []
+    diag_h_q = np.diag(sigma_h_const)
+    quad = float(beta_arr @ sigma_h_const @ beta_arr)
+    for v in sorted(cf['vintage_label'].unique()):
+        cf_g = cf[cf['vintage_label'] == v]
+        nav_g = navs[navs['vintage_label'] == v]
+        cf_v, rvpi_nav, _, dates = cf_with_terminal_for_vintage(cf_g, nav_g, asof)
+        cf_ns = np.array([pd.Timestamp(t).value for t in dates], dtype=np.int64)
+        n_q = len(quarters_ns)
+        idx_t = np.clip(np.searchsorted(quarters_ns, cf_ns, side='right') - 1,
+                        0, n_q - 1)
+        idx_t0 = idx_t[0]
+        rh = cum_log_factor_q[idx_t] - cum_log_factor_q[idx_t0]
+        rfh = cum_log_rf_q[idx_t] - cum_log_rf_q[idx_t0]
+        h_years = np.array([
+            max((pd.Timestamp(t) - pd.Timestamp(dates[0])).days, 1) / 365.25
+            for t in dates])
+        h_q = h_years * 4.0
+        rb = (rfh + rh @ beta_arr
+              + 0.5 * h_q * (beta_arr @ diag_h_q)
+              - 0.5 * h_q * quad)
+        defl = np.exp(rb)
+        da = vintage_da_fast(cf_v, rvpi_nav, dates, defl)
+        contrib = -cf_v.loc[cf_v['amount'] < 0, 'amount'].sum()
+        distrib = cf_v.loc[cf_v['amount'] > 0, 'amount'].sum()
+        dpi = distrib / contrib if contrib > 0 else float('nan')
+        rows.append({'vintage_label': v, 'contribution': contrib, 'DPI': dpi,
+                     'DA': da})
+    return pd.DataFrame(rows)

privateassets-0.1.0/privateassets/matf/_panel_mle.py

@@ -0,0 +1,126 @@
+"""
+Panel MLE for common AR(1) coefficient across vintages.
+
+Model: each vintage i has quarterly NAV-implied returns r_{i,t} that
+follow:
+   r_{i,t} = θ · r_{i,t-1} + ε_{i,t},  ε_{i,t} ~ N(0, σ_i²)
+
+with COMMON AR coefficient θ shared across vintages, but idiosyncratic
+residual variances σ_i².
+
+Profile-out variances and reduce to a 1-D optimization in θ. With
+σ_i² profiled at MLE σ̂_i²(θ) = mean_t (r_{i,t} - θ r_{i,t-1})², the
+profile log-likelihood for θ is:
+
+   L_p(θ) = -(1/2) Σ_i n_i log σ̂_i²(θ)   + const
+
+Maximize over θ ∈ (-1, 1).
+
+Compare to:
+  - Production pooled AR(1): θ_pooled = 0.142
+  - Per-vintage average:     avg θ_i  = 0.136
+
+Author: A. Sepp / the desk
+"""
+from __future__ import annotations
+from typing import Dict
+import numpy as np
+from scipy.optimize import minimize_scalar
+
+
+def panel_ar1_neg_log_likelihood(
+    theta: float,
+    series_list: list,   # list of (label, np.ndarray) per vintage, demeaned
+) -> float:
+    """
+    Profile-out negative log-likelihood for panel AR(1) with common θ
+    and per-vintage idiosyncratic σ_i². Series are pre-demeaned.
+
+    Returns: -L_p(θ) where L_p is the profile log-likelihood.
+    """
+    nll = 0.0
+    for item in series_list:
+        r = item[1] if isinstance(item, tuple) else item
+        if len(r) < 3:
+            continue
+        eps = r[1:] - theta * r[:-1]
+        n_i = len(eps)
+        sigma2_hat = np.mean(eps ** 2)
+        if sigma2_hat <= 0:
+            return np.inf
+        nll += 0.5 * n_i * np.log(sigma2_hat)
+    return nll
+
+
+def panel_ar1_grad(theta: float, series_list: list) -> float:
+    """Numerical derivative of NLL wrt theta (used for diagnostics)."""
+    eps = 1e-6
+    return (panel_ar1_neg_log_likelihood(theta + eps, series_list)
+            - panel_ar1_neg_log_likelihood(theta - eps, series_list)) / (2 * eps)
+
+
+def fisher_info_panel_ar1(theta_hat: float, series_list: list) -> float:
+    """
+    Approximate Fisher information for theta from the panel.
+    For AR(1) with σ_i² known, the per-obs Fisher info is
+    Var(r_{i,t-1}) / σ_i². With σ_i² profiled at MLE this becomes
+    n_i · Var(r_{i,t-1}) / sum((r_{i,t} - θ r_{i,t-1})²).
+    """
+    fisher = 0.0
+    for item in series_list:
+        # series_list is list of (label, array)
+        r = item[1] if isinstance(item, tuple) else item
+        if len(r) < 3:
+            continue
+        eps = r[1:] - theta_hat * r[:-1]
+        sigma2_hat = np.mean(eps ** 2)
+        if sigma2_hat <= 0:
+            continue
+        var_lag = np.var(r[:-1])
+        n_i = len(eps)
+        fisher += n_i * var_lag / sigma2_hat
+    return fisher
+
+
+def fit_panel_ar1(series_list: list) -> Dict:
+    """
+    Fit common-θ panel AR(1) by profile MLE, return θ_hat and
+    asymptotic standard error.
+    """
+    res = minimize_scalar(
+        panel_ar1_neg_log_likelihood,
+        args=(series_list,),
+        bounds=(-0.95, 0.95),
+        method='bounded',
+        options={'xatol': 1e-6},
+    )
+    theta_hat = float(res.x)
+    fisher = fisher_info_panel_ar1(theta_hat, series_list)
+    se = float(1.0 / np.sqrt(fisher)) if fisher > 0 else float('nan')
+
+    # Also compute per-vintage MLE for comparison
+    per_vintage = {}
+    for v, r in series_list:
+        if len(r) < 5:
+            per_vintage[v] = None
+            continue
+        # Per-vintage AR(1) MLE = OLS of r_t on r_{t-1}
+        y = r[1:]; x = r[:-1]
+        if np.var(x) < 1e-10:
+            per_vintage[v] = None
+            continue
+        theta_i = float(np.cov(y, x)[0, 1] / np.var(x))
+        per_vintage[v] = theta_i
+
+    # n_total
+    n_total = sum(max(0, len(r) - 1) for _, r in series_list)
+
+    return {
+        'theta_hat': theta_hat,
+        'se': se,
+        'neg_log_lik': float(res.fun),
+        'fisher_info': fisher,
+        'per_vintage_theta': per_vintage,
+        'n_total': n_total,
+        'n_vintages': len([1 for _, r in series_list if len(r) >= 5]),
+    }