Duplicate from macrolens/MacroLens

.gitattributes

@@ -0,0 +1,13 @@
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.tar.zst filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.feather filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,35 @@
+# Python bytecode
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Editor / OS
+.DS_Store
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Build / dist artifacts
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.mypy_cache/
+.ruff_cache/
+
+# Notebook checkpoints
+.ipynb_checkpoints/
+
+# Logs
+*.log

DATASHEET.md

@@ -0,0 +1,224 @@
+# Datasheet for MacroLens
+
+This datasheet follows the *Datasheets for Datasets* framework (Gebru et al., *Communications of the ACM*, 2021).
+
+---
+
+## 1. Motivation
+
+**For what purpose was the dataset created?**
+MacroLens evaluates forecasting and valuation models that must reason over numerical history *and* contextual information — macroeconomic state, scenarios, and firm text — in a financial setting. It addresses gaps in three existing benchmark families: generic time-series forecasting benchmarks drop text and valuation tasks; financial language benchmarks drop forecasting and event reasoning; recent context-rich forecasting datasets are non-financial or omit valuation.
+
+**Who created the dataset and on behalf of which entity?**
+Anonymous (NeurIPS 2026 Datasets & Benchmarks Track double-blind submission). Authors and affiliations to be disclosed after author notification.
+
+**Who funded the creation of the dataset?**
+Anonymous (will be disclosed after notification).
+
+**Any other comments?**
+The benchmark targets the *intersection* of contextual time-series forecasting, valuation, and scenario-conditioned event prediction, which prior public benchmarks have not covered jointly.
+
+---
+
+## 2. Composition
+
+**What do the instances that comprise the dataset represent?**
+A MacroLens instance is the tuple ⟨ticker $i$, timestamp $t$, granularity $g$, lookback panel $x_{i,t-L:t,g}$, static covariates $z_i$, optional scenario $s_t$, optional text $u_{i,\le t}$⟩, paired with a task-specific target $y_{i,t}$.
+
+**How many instances are there in total?**
+- 4,841,094 daily panel rows (3,219,018 train / 1,622,076 test) over 4,416 tickers and 1,313 trading days.
+- 1,009,314 weekly panel rows.
+- 232,483 monthly panel rows.
+- 23,147 T2 valuation ground truths.
+- 23,147 T5 private-valuation ground truths (same 1,324 holdout tickers, price-stripped).
+- ~14,500 T3 (ticker, fiscal year, field) ground truth tuples (11-field curated dense panel).
+- 4,072,843 T4 scenario-forecast ground-truth rows from 1,622,076 test panel rows × 1,130 events.
+- 11,065 T6 generator-evaluation ground truths.
+- 23,367 T7 real-estate ground truth rows over 23,190 unique addresses.
+- 1,130 macroeconomic scenario events across 49 types.
+
+**Does the dataset contain all possible instances or is it a sample (e.g., a sample of a larger set)?**
+The 4,416-ticker universe is the union of: full Russell 2000 (1,923 IWM holdings), full S&P SmallCap 600 (72 IJR-only additions), iShares Micro-Cap (225 IWC additions), and the 2,196 small-cap NASDAQ/NYSE tickers outside all three indices, filtered to company market cap ≤ \$7.4B. This is **not** a sample — it is the complete enumeration of U.S. small/micro-cap equities meeting the universe spec on the trade dates 2021-01-04 through 2026-03-31.
+
+**What data does each instance consist of?**
+- **Numeric panel** (131 features per (ticker, date) coordinate): 6 OHLCV + 19 derived valuation ratios + 45 XBRL statement fields with TTM rolling-sum variants + 46 FRED macro + 7 EIA commodity + 1 days-since-filing + 7 index/membership flags.
+- **Static covariates**: ticker metadata (sector, industry, exchange), security_type (operating / fund / SPAC), index memberships.
+- **Scenario object** (optional, T4): event_type (49 categories), structured natural-language description, scenario_id.
+- **Text** (optional): SEC filings (markdown + PDF), financial news articles.
+- **Target**: per-task, see Section "Splits" below.
+
+**Is there a label or target associated with each instance?**
+Yes, per task (T1: horizon-length close trajectory; T2/T5: realized market cap; T3/T6: 11 canonical XBRL field values; T4: 63-day post-event return percentage; T7: rent + price).
+
+**Is any information missing from individual instances?**
+Yes, by point-in-time design. Quarterly XBRL facts apply a post-acceptance lag (so they appear in $x_{i,t,g}$ only after the publication timestamp). News articles enter only after publication. The 14 tickers without XBRL or yfinance fundamentals (5 FDIC-only banks + 9 SEC-empty stubs that yfinance also fails) are applicability-masked on T2/T3/T5/T6 (kept for T1, T4 with prices+filings only).
+
+**Are relationships between individual instances made explicit?**
+Yes. Tickers are linked to scenarios via dates and event_id. Real-estate addresses link to metros. Filings link to tickers via CIK. All keys are stored as identifier columns, not derived joins.
+
+**Are there recommended data splits?**
+- **T1, T4 (forecasting)**: chronological 70/30 split at **2024-09-03** (1,622,076 daily test rows).
+- **T2, T3, T5, T6 (valuation + generation)**: 30% company-level holdout = **1,324 tickers, seed = 42**. Each ticker contributes its latest valid snapshot. T3, T6 add a per-ticker temporal split (latest fiscal year for test, prior years for train).
+- **T7 (real-estate)**: 30% address-level holdout (random, seeded).
+
+**Are there any errors, sources of noise, or redundancies in the dataset?**
+- yfinance occasionally yields stale or misaligned quarter-close fundamentals; the loader applies a one-day lag for safety.
+- The 14 fundamentals-empty tickers are applicability-masked, not excluded.
+- T4 events with pre-event price below SEC penny-stock threshold ($0.50) are dropped at build time (~140 rows) because percentage-return arithmetic blows up at the noise floor.
+- T7 has 854 duplicate-address rows in the train pool (53,804 unique vs 54,658 raw); deduplicated at canonical-index time.
+
+**Is the dataset self-contained, or does it link to or otherwise rely on external resources?**
+The Hugging Face release is bundled-self-contained for SEC EDGAR (filings + XBRL facts), FRED + EIA macro series, yfinance-derived prices + fundamentals, and the curated benchmark parquets — no user credentials needed for these. Two sources are **gated by external licensing** and ship as derived features + reconstruction scripts only:
+
+| Source | Bundled in HF release? | User credentials required for raw re-fetch? |
+|---|---|---|
+| SEC EDGAR (filings, XBRL) | Yes (public domain) | No (free) |
+| FRED, EIA (macro) | Yes (public domain) | No (free; FRED API key recommended for high rate) |
+| yfinance (prices, fundamentals) | Yes (derived features) | No (free) |
+| Macroeconomic event scenarios | Yes (curated by us, CC-BY-4.0) | No |
+| **RentCast** (real estate raw) | **NO — derived features only** | **YES — user's own RentCast subscription** for `collect_real_estate.py` |
+| **Financial news** (~215k articles) | **NO — derived counts only** | **YES — user's own news-API key** for `collect_news.py` |
+
+**Does the dataset contain data that might be considered confidential?**
+No. All sources are public regulatory filings (SEC EDGAR), public market data (yfinance), public macroeconomic series (FRED, EIA), and licensed real-estate listings (RentCast, used under their terms).
+
+**Does the dataset contain data that, if viewed directly, might be offensive, insulting, threatening, or might otherwise cause anxiety?**
+No, beyond standard financial-news content (corporate disputes, lawsuits, layoffs) which is part of public regulatory disclosure.
+
+**Does the dataset relate to people?**
+Indirectly — SEC filings name corporate officers and directors as part of public regulatory disclosure (the same information that appears on EDGAR). No private individuals; no PII beyond what is in public regulatory filings.
+
+**Does the dataset identify any subpopulations?**
+The dataset records `security_type` (operating, fund, SPAC) and Global Industry Classification Standard (GICS) sector for every ticker. No protected demographic categories.
+
+---
+
+## 3. Collection Process
+
+**How was the data associated with each instance acquired?**
+- **Universe**: iShares IWM/IJR/IWC ETF holdings + NASDAQ Trader symbol directory (filtered to market cap ≤ \$7.4B).
+- **Prices**: Yahoo Finance.
+- **Fundamentals**: yfinance (3.22M rows) + SEC EDGAR XBRL company-facts API (46.79M facts, 92.6% coverage).
+- **Macro**: FRED + EIA via the publicly documented APIs.
+- **Filings**: SEC EDGAR (10-K, 10-Q, 8-K, 20-F, 6-K, N-CSR, N-CSRS).
+- **News**: provider feed + entity linking.
+- **Real estate**: RentCast API (100 U.S. metros, 139,855 properties × 544 RentCast variants).
+
+**What mechanisms or procedures were used to collect the data?**
+Custom Python scripts (`collect_*.py`) using each source's official documented API. Rate limits were honored. All scripts are included in the release.
+
+**If the dataset is a sample from a larger set, what was the sampling strategy?**
+Not a sample — full enumeration of the universe spec over 2021-01-04 → 2026-03-31. Within that, the 30% company-level valuation holdout uses **stratified sampling** on (sector, market-cap quartile) at fixed seed = 42.
+
+**Who was involved in the data collection process?**
+Anonymous authors. No human annotators (the dataset uses programmatic API queries).
+
+**Over what timeframe was the data collected?**
+Source data was published over 2021-01-04 — 2026-03-31. Collection scripts were run in 2025-2026 to assemble the panel.
+
+**Were any ethical review processes conducted?**
+N/A — public-records data only.
+
+---
+
+## 4. Preprocessing / Cleaning / Labeling
+
+**Was any preprocessing/cleaning/labeling of the data done?**
+Yes:
+- **Point-in-time alignment**: every observation aligns to publication timestamp (filings post-acceptance lag, quarterly XBRL post-acceptance, news post-publication).
+- **Algebraic-leakage scrubbing for T2/T5**: every input column is auto-tested against $\log y$; any column with $|\text{Pearson}| > 0.99$ to the target is excluded. Largest residual T2 correlation post-scrub is shares-outstanding at $\rho = 0.30$, a legitimate size proxy.
+- **APE clipping at 10×** (1,000%) on all valuation tasks to prevent a single mispredicted outlier from dominating MAPE-style metrics.
+- **Outlier cleanup at source for T4**: rows with pre-event price below SEC penny-stock threshold (\$0.50) dropped at build time.
+- **Address deduplication for T7** at canonical-index time (854 duplicates in train pool, 177 in eval pool removed).
+- **TTM rolling-sum variants** computed for flow-style XBRL fields (revenue, net income, etc.).
+
+**Was the "raw" data saved in addition to the preprocessed/cleaned/labeled data?**
+Yes. The release bundles raw XBRL facts (`xbrl/`), raw prices (`prices/`), raw fundamentals (`fundamentals/`) alongside the curated `benchmark/` parquets so downstream researchers can re-derive features.
+
+**Is the software that was used to preprocess/clean/label the data available?**
+Yes — `preprocess.py`, `assemble_benchmark.py`, `build_ontology.py`, `enrich_benchmark.py`, `generate_scenarios.py`, `build_valuation_tasks.py`, `validate_all.py`. All under MIT.
+
+---
+
+## 5. Uses
+
+**Has the dataset been used for any tasks already?**
+Yes — the accompanying paper reports a 17-method baseline panel across 7 families on T1–T7.
+
+**Is there a repository that links to any or all papers or systems that use the dataset?**
+The HF dataset card (this README) will track citations. Currently: the accompanying NeurIPS 2026 D&B paper.
+
+**What (other) tasks could the dataset be used for?**
+- Multi-modal time-series forecasting research.
+- Macroeconomic-event impact studies.
+- LLM evaluation under domain-specific (financial) tasks.
+- Private-market valuation modeling.
+- Cross-domain transfer (real-estate vs equity valuation).
+- Scenario reasoning + counterfactual forecasting.
+
+**Is there anything about the composition of the dataset or the way it was collected that might impact future uses?**
+- U.S.-only and English-only — international generalizability not supported.
+- Survivorship bias is partially mitigated by including delisted tickers, but pre-2021 history is not covered.
+- The 30% company-level holdout for T2/T3/T5/T6 evaluates OOD-ticker generalization but not OOD-sector or OOD-industry by construction.
+
+**Are there tasks for which the dataset should not be used?**
+- **Trading decisions**: the dataset is a research benchmark; metrics do not include transaction costs, slippage, or execution modeling. Direct trading use is **not recommended**.
+- **International generalizability claims**: U.S. equities only.
+- **Deployment safety**: no adversarial-robustness testing.
+
+---
+
+## 6. Distribution
+
+**Will the dataset be distributed to third parties outside of the entity on behalf of which the dataset was created?**
+Yes — Hugging Face Datasets, public.
+
+**How will the dataset be distributed?**
+- Primary: `huggingface.co/datasets/macrolens/MacroLens` (Croissant-validated, NeurIPS-D&B compliant).
+- Code: same repo.
+- Reconstruction scripts: same repo (raw filings + news re-fetched from official sources).
+
+**When will the dataset be distributed?**
+Public at time of NeurIPS 2026 D&B-track submission.
+
+**Will the dataset be distributed under a copyright or other intellectual property license, and/or under applicable terms of use (ToU)?**
+- Derived features + curated panel: **CC-BY-4.0**.
+- Code: **MIT**.
+- Vendored libraries (under `methods/_vendored/`): TSLib (MIT), ModernTCN (Apache 2.0).
+- Reconstruction scripts: MIT.
+
+**Have any third parties imposed IP-based or other restrictions on the data associated with the instances?**
+- yfinance, FRED, EIA, RentCast: each has its own ToU; the release ships derived features and reconstruction scripts.
+- SEC EDGAR: public domain.
+
+**Do any export controls or other regulatory restrictions apply to the dataset or to individual instances?**
+No.
+
+---
+
+## 7. Maintenance
+
+**Who is supporting/hosting/maintaining the dataset?**
+Anonymous (NeurIPS 2026 D&B submission). Maintainer-of-record will be disclosed after author notification.
+
+**How can the owner / curator / manager of the dataset be contacted?**
+Through the Hugging Face dataset discussions tab (`huggingface.co/datasets/macrolens/MacroLens/discussions`) or via the corresponding-author email (post-notification).
+
+**Is there an erratum?**
+None at submission. Errata will be tracked in the dataset card's `Changelog` section.
+
+**Will the dataset be updated?**
+Yes — minor versioned updates planned to extend the time window and refresh upstream sources. Versioning follows semver; each release tags a Git-style snapshot in the HF repo.
+
+**If the dataset relates to people, are there applicable limits on the retention of the data associated with the instances?**
+N/A — public regulatory filings only.
+
+**Will older versions of the dataset continue to be supported/hosted/maintained?**
+Yes — older revisions remain accessible via HF dataset revision tags (commit SHAs).
+
+**If others want to extend/augment/build on/contribute to the dataset, is there a mechanism for them to do so?**
+Yes — pull requests via the HF dataset repo or the GitHub mirror. Contributions are reviewed for license compatibility (CC-BY-4.0 compatible only) and benchmark protocol consistency.
+
+---
+
+*This datasheet was prepared at the time of NeurIPS 2026 D&B-track submission. The Croissant metadata file (auto-generated by Hugging Face) at `https://huggingface.co/api/datasets/macrolens/MacroLens/croissant` is the machine-readable counterpart to this human-readable datasheet.*

LICENSE

@@ -0,0 +1,154 @@
+                              MacroLens License
+
+This MacroLens release is distributed under a dual-license:
+
+  * Curated data artifacts under CC-BY-4.0 (Creative Commons Attribution 4.0)
+  * Code under the MIT License
+  * Vendored third-party libraries retain their upstream licenses (see
+    "Vendored Library Acknowledgements" below)
+
+================================================================================
+                                  DATA LICENSE
+                       Creative Commons Attribution 4.0
+                                   (CC-BY-4.0)
+================================================================================
+
+The following directories distribute curated data artifacts under
+Creative Commons Attribution 4.0 International (CC-BY-4.0):
+
+  data/{daily,weekly,monthly}/      curated panel + ground-truth parquets
+  data/real_estate/                 RentCast-derived address features
+  data/xbrl/                        standardized XBRL facts
+  data/fundamentals/                yfinance-derived quarterly statements
+  data/macro/                       FRED + EIA series
+  data/prices/                      yfinance-derived OHLCV
+  data/processed/                   derived features (TTM, ratios, scenarios)
+
+Use of these data artifacts is permitted for any purpose (research, commercial,
+modification, redistribution) provided that the user gives appropriate credit
+to MacroLens and indicates changes made.
+
+Full CC-BY-4.0 text: https://creativecommons.org/licenses/by/4.0/legalcode
+
+================================================================================
+                                  CODE LICENSE
+                                 (MIT License)
+================================================================================
+
+Copyright (c) 2026 The MacroLens Authors
+
+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.
+
+The MIT License applies to the following code directories and files:
+
+  macrolens/         public unified API (load, score, methods, _types)
+  dataloader/        canonical loaders + provenance + ablation feature filter
+  methods/           registered method classes (excluding _vendored/)
+  experiments/       runner + aggregator + re_evaluate
+  tools/             provenance + environment verification
+  notebooks/         demonstration notebooks
+  eval.py            per-task scoring functions (T1-T7)
+  config.py          paths and constants
+  benchmark_loader.py
+  collect_*.py       reconstruction scripts (universe, fundamentals, prices,
+                     filings, news, real_estate, macro)
+  preprocess.py, build_ontology.py, assemble_benchmark.py,
+  generate_scenarios.py, enrich_benchmark.py, build_valuation_tasks.py,
+  validate_all.py, run_pipeline.py
+
+================================================================================
+                       VENDORED LIBRARY ACKNOWLEDGEMENTS
+================================================================================
+
+The following libraries are vendored (verbatim or with documented patches)
+under methods/_vendored/. Each retains its upstream copyright notice and
+license. Local patches are documented in methods/_vendored/CHANGES.md.
+
+--------------------------------------------------------------------------------
+methods/_vendored/tslib/      DLinear, iTransformer source
+--------------------------------------------------------------------------------
+
+Original: https://github.com/thuml/Time-Series-Library
+License: MIT License
+
+  Copyright (c) 2022 THUML
+
+  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.
+
+--------------------------------------------------------------------------------
+methods/_vendored/moderntcn/  ModernTCN source
+--------------------------------------------------------------------------------
+
+Original: https://github.com/luodhhh/ModernTCN
+License: Apache License, Version 2.0
+
+  Copyright 2024 Luo Donghao and Wang Xue
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+================================================================================
+                        UPSTREAM-DATA-PROVIDER NOTICES
+================================================================================
+
+Reconstruction scripts re-fetch from sources whose terms apply to redistribution
+of *raw* artifacts. The MacroLens release ships only derived / curated features:
+
+  * SEC EDGAR: public domain (US government work). Filings (markdown + PDF,
+    295,860 documents) and XBRL company facts (46.8M) are bundled in the
+    HF release. `collect_filings.py` and `collect_fundamentals.py` provided
+    for re-fetch.
+  * FRED (Federal Reserve Bank of St. Louis): public domain. 46 series
+    bundled. `collect_macro.py` provided.
+  * EIA (U.S. Energy Information Administration): public domain. 7 series
+    bundled. `collect_macro.py` provided.
+  * Yahoo Finance (yfinance): non-commercial ToU. The release ships derived
+    features (OHLCV + adjusted close + quarterly fundamentals). Users
+    redistributing further should respect yfinance ToU. `collect_prices.py`
+    + `collect_fundamentals.py` provided for re-fetch.
+  * RentCast: GATED — proprietary. Raw listings NOT redistributable; the
+    release ships derived address-level features (rent + price targets,
+    property attributes) only. To re-fetch raw, users must obtain their own
+    RentCast subscription and run `collect_real_estate.py`.
+  * Financial-news provider: GATED — provider ToU prohibits redistribution.
+    The release ships derived counts (`filing_8k_count_30d`, `news_count_7d`,
+    `has_press_release_7d`) only. To re-fetch raw articles, users must
+    provide their own news-API key and run `collect_news.py`.
+
+================================================================================
+
+By using MacroLens, you agree to honor the upstream-data-provider terms above
+in addition to the CC-BY-4.0 / MIT licenses for the curated artifacts.

README.md

@@ -0,0 +1,232 @@
+---
+license: cc-by-4.0
+task_categories:
+  - time-series-forecasting
+  - tabular-regression
+  - text-generation
+  - question-answering
+language:
+  - en
+size_categories:
+  - 1M<n<10M
+tags:
+  - finance
+  - macroeconomic
+  - multimodal
+  - benchmark
+  - sec-edgar
+  - xbrl
+  - rentcast
+  - small-cap
+  - russell-2000
+  - private-valuation
+  - scenario-conditioned-forecasting
+pretty_name: MacroLens
+configs:
+  - config_name: panel_daily
+    data_files:
+      - split: train
+        path: data/daily/panel_train.parquet
+      - split: test
+        path: data/daily/panel_test.parquet
+  - config_name: panel_weekly
+    data_files:
+      - split: train
+        path: data/weekly/panel_train.parquet
+      - split: test
+        path: data/weekly/panel_test.parquet
+  - config_name: panel_monthly
+    data_files:
+      - split: train
+        path: data/monthly/panel_train.parquet
+      - split: test
+        path: data/monthly/panel_test.parquet
+  - config_name: scenarios_daily
+    data_files: data/daily/scenarios.parquet
+  - config_name: valuation_inputs_daily
+    data_files: data/daily/valuation_inputs.parquet
+  - config_name: private_valuation_inputs_daily
+    data_files: data/daily/private_valuation_inputs.parquet
+  - config_name: generation_inputs_daily
+    data_files: data/daily/generation_inputs.parquet
+  - config_name: generation_ground_truth_daily
+    data_files: data/daily/generation_ground_truth.parquet
+  - config_name: generator_eval_inputs_daily
+    data_files: data/daily/generator_eval_inputs.parquet
+  - config_name: generator_eval_ground_truth_daily
+    data_files: data/daily/generator_eval_ground_truth.parquet
+  - config_name: scenario_forecast_ground_truth_daily
+    data_files: data/daily/scenario_forecast_ground_truth.parquet
+  - config_name: real_estate_train
+    data_files: data/real_estate/re_train_properties.parquet
+  - config_name: real_estate_eval
+    data_files: data/real_estate/re_eval_inputs.parquet
+---
+
+# MacroLens
+
+A benchmarking corpus for **contextual financial reasoning under macroeconomic scenarios** across **4,416 U.S. small- and micro-cap equities (2021-01-04 — 2026-03-31)**. MacroLens unifies seven tasks over a single point-in-time panel: contextual time-series forecasting, public valuation, financial-statement generation, scenario-conditioned return forecasting, private-company valuation, generator evaluation from natural-language descriptions, and real-estate valuation.
+
+![visual_summary](https://cdn-uploads.huggingface.co/production/uploads/65dff6bdd546250b182edb86/KXknSZ-_zv23FYNLDkZnu.png)
+
+| Task | Type | Output |
+|---|---|---|
+| **T1** Contextual Forecasting | Time-series | Horizon-length close trajectory |
+| **T2** Public Valuation | Tabular regression | Equity market cap |
+| **T3** Financial Statement Generation | Structured generation | 11 canonical XBRL fields per (ticker, fiscal year) |
+| **T4** Scenario-Conditioned Return | Event forecasting | 63-day post-event return percentage |
+| **T5** Private-Company Valuation | Tabular regression (price-stripped) | Equity value w/o market data |
+| **T6** Generator Evaluation | NL→ structured | Same 11 fields from a natural-language company description |
+| **T7** Real-Estate Valuation | Cross-domain regression | Rent + price per RentCast address |
+
+Every instance carries a 131-numeric / 141-column point-in-time panel (prices, 46.8M XBRL accounting facts, 53 macroeconomic series, filing recency, derived ratios), an optional macroeconomic scenario object (1,130 events across 49 types), and optional SEC filings + financial-news context. Temporal alignment is strictly point-in-time: every observation visible at prediction timestamp $t$ was publicly available by $t$.
+
+## Quickstart
+
+```python
+import macrolens as ml
+
+# 1. Load (X, y, meta) — identical schema across train/test
+X_train, y_train, meta_train = ml.load("T1", "train", granularity="daily")
+X_test,  y_test,  meta_test  = ml.load("T1", "test")
+
+# 2. Fit + Predict
+model = ml.methods.LightGBMRegressor(task="T1")
+model.fit(X_train, y_train, seed=42)
+y_pred = model.predict(X_test)
+
+# 3. Score (cluster-bootstrap CIs by ticker for T1; adaptive n_boot)
+metrics = ml.score("T1", y_test, y_pred)
+print(metrics["mse"]["value"], metrics["mse"]["ci_lo"], metrics["mse"]["ci_hi"])
+```
+
+10 lines per task; swap the model class to compare methods.
+## Dataset structure
+
+```
+data/
+├── daily/                     # primary granularity (4.84M panel rows)
+│   ├── panel_train.parquet                       # T1, T4 train side
+│   ├── panel_test.parquet                        # T1, T4 eval side
+│   ├── scenarios.parquet                         # 1,130 macroeconomic events
+│   ├── valuation_inputs.parquet                  # T2 features
+│   ├── valuation_ground_truth.parquet            # T2 ground truth (market cap)
+│   ├── private_valuation_inputs.parquet          # T5 features (price-stripped)
+│   ├── private_valuation_ground_truth.parquet    # T5 ground truth
+│   ├── generation_inputs.parquet                 # T3 fundamentals snapshot
+│   ├── generation_ground_truth.parquet           # T3 long-form (ticker, FY, field, value)
+│   ├── generator_eval_inputs.parquet             # T6 NL company descriptions
+│   ├── generator_eval_ground_truth.parquet       # T6 long-form
+│   └── scenario_forecast_ground_truth.parquet    # T4 ground truth
+├── weekly/                    # Friday-close resampled (1.01M rows) — same file set as daily/
+├── monthly/                   # Last-trading-day resampled (232k rows) — same file set as daily/
+├── real_estate/
+│   ├── re_train_properties.parquet   # T7 train (53,804 unique addresses)
+│   ├── re_eval_inputs.parquet        # T7 eval (23,190 unique addresses)
+│   └── re_eval_ground_truth.parquet  # T7 ground truth (rent + price)
+├── xbrl/                      # 46.8M standardized XBRL facts, 92.6% ticker coverage
+├── filings/                   # 295,860 SEC filings (10-K, 10-Q, 8-K, 20-F, 6-K, N-CSR, N-CSRS) — markdown + PDF
+├── prices/                    # OHLCV + adjusted close (yfinance)
+├── fundamentals/              # README placeholder only; raw CSVs reproducible via code/collect_fundamentals.py (see note below)
+└── macro/                     # 46 FRED + 6 EIA series
+
+manifest.json                  # SHA-256 over every parquet (provenance)
+```
+
+> **Note on `data/fundamentals/`**: Raw per-ticker fundamentals CSVs (~12,000 files: `{TICKER}_balance.csv`, `{TICKER}_income.csv`, `{TICKER}_cashflow.csv`) are **not shipped directly** here because HF enforces a hard cap of 10,000 files per directory. They are reproducible end-to-end via the released pipeline:
+>
+> ```bash
+> python code/collect_fundamentals.py
+> ```
+>
+> The aggregated/processed versions used by the benchmark API (e.g. `valuation_inputs.parquet`, `private_valuation_inputs.parquet`, `generation_inputs.parquet`) are shipped directly under `data/daily/`, `data/weekly/`, `data/monthly/`, and `data/real_estate/`.
+
+## Data sources & access requirements
+
+**What's bundled in this HF release** (no user credentials required):
+
+| Source | Bundled artifact | License |
+|---|---|---|
+| SEC EDGAR | `filings/` (295k docs), `xbrl/` (46.8M facts) | Public domain (US gov) |
+| FRED | 46 macroeconomic series | Public domain |
+| EIA | 7 commodity series | Public domain |
+| yfinance | `prices/` (OHLCV), `fundamentals/` (quarterly) — derived features | Non-commercial (yfinance ToU) |
+| RentCast | `real_estate/` (address-level derived features only — rent + price targets, property attributes) | RentCast ToU — derived only |
+| Macroeconomic events | `scenarios.parquet` (1,130 events × 49 types) | Curated by us, CC-BY-4.0 |
+
+**What's NOT bundled** (gated — user credentials required for raw re-fetch via `collect_*.py`):
+
+| Source | Status | User-side requirement |
+|---|---|---|
+| **Financial-news provider** | **Excluded** — provider ToU prohibits redistribution. The release ships derived counts (`filing_8k_count_30d`, `news_count_7d`, `has_press_release_7d`) only. | **User's own news-API key required** for `collect_news.py` |
+| **RentCast raw listings** | **Excluded raw** — proprietary. Derived features bundled. | **User's own RentCast subscription** required for `collect_real_estate.py` raw mode |
+
+## Universe
+
+The 4,416-ticker universe combines: full Russell 2000 (1,923 IWM holdings), full S&P SmallCap 600 (72 IJR-only additions), iShares Micro-Cap (225 IWC additions), and 2,196 small-cap NASDAQ/NYSE tickers outside all three indices. The split is **3,857 operating companies + 333 funds + 226 SPACs**, with `security_type` recorded for applicability-aware stratification.
+
+## Splits
+
+- **Forecasting (T1, T4)**: chronological 70/30 split at **2024-09-03**.
+- **Valuation + generation (T2, T3, T5, T6)**: **30% company-level holdout = 1,324 tickers** (seed = 42), each contributing its latest valid snapshot.
+- **Real-estate (T7)**: 30% address-level holdout (random, seeded), with per-property time-axis features.
+
+Cluster-bootstrap 95% CIs are computed per task: by `ticker` (T1/T2/T3/T5/T6), `scenario_id` (T4), or `address` (T7). Number of bootstrap resamples is adaptive in [1k, 10k] until `(ci_hi - ci_lo) / |mean| < 0.05`.
+
+## Methods (panel)
+
+The release ships a 18-method baseline panel across 7 families: 4 naive, 2 classical, 3 deep sequence, 3 zero-shot TSFM, 2 LLM-adapted multi-task systems, 3 zero-shot frontier LLMs (gpt-oss-120b, gpt-5.1, gemini-3-flash + qwen35). Every method registers via `@register(name=…, family=…, tasks=…)` and exposes the sklearn-style `(fit, predict, save, load)` contract.
+
+```python
+ml.list_methods()                 # all registered methods
+ml.list_methods(task="T1")        # methods that support T1
+ml.list_methods(family="naive")   # naive baselines
+```
+
+## License
+
+- **Data**: CC-BY-4.0 (derived features + curated panel)
+- **Code**: MIT (`code/macrolens/`, `code/dataloader/`, `code/methods/`, `code/eval.py`, `code/experiments/`)
+- **Vendored libraries** (under `code/methods/_vendored/`):
+  - `tslib/` — MIT (DLinear, iTransformer source)
+  - `moderntcn/` — Apache 2.0 (ModernTCN source)
+- **Reconstruction scripts** (`collect_*.py`) provided for sources with redistribution restrictions: SEC filings (re-fetch from EDGAR), financial news (re-fetch from provider), real-estate (re-fetch from RentCast).
+
+## Citation
+
+```bibtex
+@inproceedings{macrolens2026,
+  title = {{MacroLens}: A Multi-Task Benchmark for Contextual Financial Reasoning under Macroeconomic Scenarios},
+  author = {<authors>},
+  booktitle = {NeurIPS 2026 Evaluations & Datasets Track submission},
+  year = {2026}
+}
+```
+
+## Reproducibility
+
+When `code/experiments/run_all.py` is executed, each method run produces a `RunRecord` JSON under `code/experiments/results/` recording: `git_sha`, `lib_versions`, `hardware`, `artifact_sha256` (SHA-256 of every parquet read), `timestamp`, and `deterministic_mode`. Predictions are also persisted at `code/experiments/predictions/<method>_<task>_seed<seed>.pkl` so eval logic can be re-applied via `code/experiments/re_evaluate.py` without re-running the models. These output directories are not shipped on Hugging Face — reviewers reproduce them by running the released code.
+
+## Reconstruction (raw filings + news)
+
+The release ships derived features and reconstruction scripts; raw artifacts subject to redistribution restrictions remain re-fetchable:
+
+```bash
+python collect_universe.py        # iShares ETF holdings + NASDAQ Trader directory
+python collect_filings.py         # SEC EDGAR (10-K, 10-Q, 8-K, 20-F, 6-K, N-CSR, N-CSRS)
+python collect_fundamentals.py    # XBRL company facts via SEC EDGAR
+python collect_prices.py          # yfinance OHLCV + adjusted close
+python collect_news.py            # provider-specific (~215k articles)
+python collect_real_estate.py     # RentCast (100 metros, 139,855 properties)
+python collect_macro.py           # FRED + EIA series
+python preprocess.py
+python assemble_benchmark.py
+python generate_scenarios.py
+python enrich_benchmark.py
+python build_valuation_tasks.py
+python validate_all.py
+```
+
+## Authors / Contact
+
+Anonymous (NeurIPS 2026 Evaluations & Datasets Track submission). Contact at `<email>` after author notification.

code/assemble_benchmark.py

@@ -0,0 +1,228 @@
+"""Layer 3 – Step 8: Assemble benchmark artifacts from the processed panel.
+
+Reads ``data/processed/{granularity}/panel.parquet`` and produces:
+
+    data/benchmark/{granularity}/panel_train.parquet
+    data/benchmark/{granularity}/panel_test.parquet
+    data/benchmark/{granularity}/panel_full.csv      (CSV compatibility)
+    data/benchmark/{granularity}/task_definition.json
+    data/benchmark/{granularity}/filing_corpus.parquet
+    data/benchmark/{granularity}/metadata.json
+
+Does NOT re-process raw data.  All heavy lifting happened in
+``preprocess.py`` (Layer 2).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------------------
+# Filing corpus
+# ------------------------------------------------------------------
+
+def _build_filing_corpus() -> pd.DataFrame:
+    """Build a filing corpus index from ``data/filings/{TICKER}/*.md``.
+
+    Stores only **metadata** (ticker, filing_type, filing_date, filing_path)
+    -- NOT the full text -- to avoid OOM with thousands of large filings.
+    Text is loaded on-demand by ``benchmark_loader.py`` using ``filing_path``.
+
+    Columns: ticker, filing_type, filing_date, filing_path, text_length.
+    """
+    import re as _re
+
+    rows: list[dict] = []
+    if not config.FILINGS_DIR.is_dir():
+        logger.warning("Filings directory does not exist: %s", config.FILINGS_DIR)
+        return pd.DataFrame(columns=["ticker", "filing_type", "filing_date", "filing_path", "text_length"])
+
+    for ticker_dir in sorted(config.FILINGS_DIR.iterdir()):
+        if not ticker_dir.is_dir():
+            continue
+        ticker = ticker_dir.name
+        for md_file in sorted(ticker_dir.glob("*.md")):
+            ftype = "10-K" if "10-K" in md_file.name else "10-Q" if "10-Q" in md_file.name else "8-K" if "8-K" in md_file.name else "other"
+            match = _re.search(r"(\d{4}-\d{2}-\d{2})", md_file.name)
+            fdate = match.group(1) if match else None
+            # Only measure length (not load entire text into memory)
+            try:
+                text_len = md_file.stat().st_size
+            except Exception:
+                text_len = 0
+            rows.append({
+                "ticker": ticker,
+                "filing_type": ftype,
+                "filing_date": fdate,
+                "filing_path": str(md_file.relative_to(config.DATA_DIR)),
+                "text_length": text_len,
+            })
+
+    df = pd.DataFrame(rows)
+    if not df.empty and "filing_date" in df.columns:
+        df["filing_date"] = pd.to_datetime(df["filing_date"], errors="coerce")
+    logger.info("Filing corpus index: %d documents across %d tickers.",
+                 len(df), df["ticker"].nunique() if not df.empty else 0)
+    return df
+
+
+# ------------------------------------------------------------------
+# Task definition
+# ------------------------------------------------------------------
+
+def _build_task_definition(panel: pd.DataFrame, granularity: str) -> dict:
+    """Create the formal forecasting-task contract."""
+    # Read column roles from the processed output
+    col_roles_path = config.DATA_DIR / "processed" / granularity / "columns.json"
+    if col_roles_path.exists():
+        column_roles = json.loads(col_roles_path.read_text())
+    else:
+        column_roles = {}
+
+    return {
+        "benchmark_name": "MacroLens",
+        "version": "1.0",
+        "granularity": granularity,
+        "targets": {
+            "primary": "close",
+            "secondary": "volume",
+        },
+        "horizons": config.get_horizons(granularity),
+        "lookback_windows": config.get_lookback_windows(granularity),
+        "column_roles": column_roles,
+        "context_taxonomy": {
+            "historical": "10-K / 10-Q filing text (nearest filing as-of each date)",
+            "covariate": "FRED / EIA macro indicators (exogenous_macro + exogenous_commodity)",
+            "causal": "Fundamental ratios derived from statements + price (exogenous_fundamental)",
+            "future_scenario": "Natural experiment events detected from macro data (scenarios.parquet)",
+            "intemporal": "Sector / industry knowledge (metadata columns)",
+        },
+        "evaluation": {
+            "metrics": ["MSE", "MAE", "RMSE", "directional_accuracy"],
+            "baseline": "naive_last_value",
+            "primary_metric": "MSE",
+        },
+        "scenario_method": "natural_experiments",
+    }
+
+
+# ------------------------------------------------------------------
+# Public API
+# ------------------------------------------------------------------
+
+def run(granularity: str | None = None) -> None:
+    """Execute Layer 3 benchmark assembly."""
+    if granularity is None:
+        granularity = config.GRANULARITY
+
+    panel_path = config.DATA_DIR / "processed" / granularity / "panel.parquet"
+    if not panel_path.exists():
+        raise FileNotFoundError(f"Run Step 7 (preprocess) first: {panel_path}")
+
+    out_dir = config.DATA_DIR / "benchmark" / granularity
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # ---- Load processed panel ------------------------------------------------
+    panel = pd.read_parquet(panel_path)
+    logger.info("Loaded processed panel: %d rows, %d tickers, %d columns.",
+                 len(panel), panel["ticker"].nunique(), len(panel.columns))
+
+    # ---- Temporal split ------------------------------------------------------
+    if config.TEMPORAL_SPLIT_DATE is not None:
+        split_date = pd.Timestamp(config.TEMPORAL_SPLIT_DATE)
+    else:
+        unique_dates = np.sort(panel["date"].unique())
+        split_idx = int(len(unique_dates) * config.TEMPORAL_SPLIT_RATIO)
+        split_idx = max(1, min(split_idx, len(unique_dates) - 1))
+        split_date = pd.Timestamp(unique_dates[split_idx])
+        logger.info("Ratio-based split (%.0f:%.0f): split date = %s (%d/%d unique dates)",
+                     config.TEMPORAL_SPLIT_RATIO * 100,
+                     (1 - config.TEMPORAL_SPLIT_RATIO) * 100,
+                     split_date.date(), split_idx, len(unique_dates))
+
+    panel["split"] = np.where(panel["date"] < split_date, "train", "test")
+    train = panel[panel["split"] == "train"]
+    test = panel[panel["split"] == "test"]
+
+    # Cold-start tickers: IPOs that appear only in the test period.
+    # Kept intentionally — tests model generalisation to unseen companies.
+    train_tickers = set(train["ticker"].unique())
+    test_only = set(test["ticker"].unique()) - train_tickers
+    if test_only:
+        logger.info("%d cold-start tickers in test (IPOs).", len(test_only))
+
+    train.to_parquet(out_dir / "panel_train.parquet", index=False)
+    test.to_parquet(out_dir / "panel_test.parquet", index=False)
+    panel.to_csv(out_dir / "panel_full.csv", index=False)
+    logger.info("Saved train (%d rows) + test (%d rows) + CSV.", len(train), len(test))
+
+    # ---- Task definition -----------------------------------------------------
+    task_def = _build_task_definition(panel, granularity)
+    (out_dir / "task_definition.json").write_text(json.dumps(task_def, indent=2, default=str))
+    logger.info("Saved task_definition.json.")
+
+    # ---- Filing corpus -------------------------------------------------------
+    corpus = _build_filing_corpus()
+    if not corpus.empty:
+        corpus.to_parquet(out_dir / "filing_corpus.parquet", index=False)
+    logger.info("Saved filing_corpus.parquet (%d documents).", len(corpus))
+
+    # ---- Metadata ------------------------------------------------------------
+    metadata = {
+        "format": "panel_data",
+        "granularity": granularity,
+        "primary_key": ["ticker", "date"],
+        "total_rows": len(panel),
+        "total_tickers": int(panel["ticker"].nunique()),
+        "date_range": {
+            "start": str(panel["date"].min().date()),
+            "end": str(panel["date"].max().date()),
+        },
+        "temporal_split": {
+            "split_date": str(split_date.date()),
+            "split_method": (
+                "fixed_date" if config.TEMPORAL_SPLIT_DATE
+                else f"ratio_{config.TEMPORAL_SPLIT_RATIO}"
+            ),
+            "train_rows": len(train),
+            "test_rows": len(test),
+            "train_date_range": {
+                "start": str(train["date"].min().date()) if len(train) > 0 else None,
+                "end": str(train["date"].max().date()) if len(train) > 0 else None,
+            },
+            "test_date_range": {
+                "start": str(test["date"].min().date()) if len(test) > 0 else None,
+                "end": str(test["date"].max().date()) if len(test) > 0 else None,
+            },
+        },
+        "label_distribution": panel["label"].value_counts().to_dict() if "label" in panel.columns else {},
+        "columns": list(panel.columns),
+        "column_count": len(panel.columns),
+        "column_roles": task_def.get("column_roles", {}),
+        "filing_corpus_stats": {
+            "total_documents": len(corpus),
+            "tickers_with_filings": int(corpus["ticker"].nunique()) if not corpus.empty else 0,
+        },
+        "evaluation_protocol": task_def.get("evaluation", {}),
+    }
+    (out_dir / "metadata.json").write_text(json.dumps(metadata, indent=2, default=str))
+    logger.info("Saved metadata.json.  Base benchmark assembly complete -> %s", out_dir)
+
+    # ---- Valuation benchmark (Tasks A–F) ---------------------------------
+    try:
+        from .build_valuation_tasks import build_valuation_benchmark
+        logger.info("Building valuation benchmark artifacts (%s) …", granularity)
+        val_summary = build_valuation_benchmark(granularity=granularity)
+        logger.info("Valuation benchmark: %s", val_summary)
+    except Exception:
+        logger.warning("Valuation benchmark build skipped or failed", exc_info=True)

code/benchmark_loader.py

@@ -0,0 +1,522 @@
+"""Runtime: Hybrid DataLoader for the MacroLens benchmark.
+
+Provides ``WhatIfTSFDataset`` -- a lightweight, on-the-fly instance
+generator that reads from pre-built benchmark artifacts
+(``panel_train.parquet`` / ``panel_test.parquet``, ``scenarios.parquet``,
+``filing_corpus.parquet``).
+
+One "instance" = a tuple of:
+    (lookback_window, forecast_target, context_dict)
+
+where ``context_dict`` holds metadata, filing text, macro, and any scenario
+information that falls within the instance's time window.
+
+Usage example
+-------------
+.. code-block:: python
+
+    from whatif_bench.benchmark_loader import WhatIfTSFDataset
+
+    # Defaults to granularity-appropriate lookback/horizon from config
+    ds = WhatIfTSFDataset(split="train")
+    print(len(ds))          # total number of sliding-window instances
+    sample = ds[0]          # dict with 'lookback', 'target', 'context'
+
+    # Each scenario in context["scenarios"] has a "scenario_role" field:
+    #   "observed" = already happened (in lookback window)
+    #   "hypothetical" = in forecast horizon (the "what-if" condition)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+class WhatIfTSFDataset:
+    """Sliding-window dataset over the MacroLens benchmark panel.
+
+    Parameters
+    ----------
+    split : str
+        ``"train"`` or ``"test"``.
+    lookback : int, optional
+        Number of past time-steps visible to the model (in panel periods).
+        Defaults to the first entry of ``config.LOOKBACK_WINDOWS_BY_GRANULARITY``
+        for the chosen granularity (63 for daily, 13 for weekly, 3 for monthly).
+    horizon : int, optional
+        Number of future time-steps to predict (in panel periods).
+        Defaults to the first entry of ``config.HORIZONS_BY_GRANULARITY``
+        for the chosen granularity (5 for daily, 4 for weekly, 1 for monthly).
+    granularity : str, optional
+        Defaults to ``config.GRANULARITY``.
+    target_col : str
+        Column name of the prediction target. Default: ``"close"``.
+    load_text : bool
+        If True, load ``filing_corpus.parquet`` and attach filing text to
+        context.  Set to False for fast iteration.
+    """
+
+    def __init__(
+        self,
+        split: str = "train",
+        lookback: int | None = None,
+        horizon: int | None = None,
+        granularity: str | None = None,
+        target_col: str = "close",
+        load_text: bool = True,
+    ) -> None:
+        if granularity is None:
+            granularity = config.GRANULARITY
+        self.granularity = granularity
+        self.split = split
+
+        # Granularity-aware defaults from config
+        if lookback is None:
+            lookback = config.get_lookback_windows(granularity)[0]
+        if horizon is None:
+            horizon = config.get_horizons(granularity)[0]
+        self.lookback = lookback
+        self.horizon = horizon
+        self.target_col = target_col
+
+        bench_dir = config.DATA_DIR / "benchmark" / granularity
+
+        # ---- Load panel split ------------------------------------------------
+        panel_path = bench_dir / f"panel_{split}.parquet"
+        if not panel_path.exists():
+            raise FileNotFoundError(f"Benchmark not assembled: {panel_path}")
+        self._panel = pd.read_parquet(panel_path)
+        self._panel["date"] = pd.to_datetime(self._panel["date"])
+        self._panel = self._panel.sort_values(["ticker", "date"]).reset_index(drop=True)
+
+        # ---- Validate target column exists -----------------------------------
+        if target_col not in self._panel.columns:
+            available = [c for c in self._panel.columns if self._panel[c].dtype.kind in "fiub"]
+            raise ValueError(
+                f"target_col={target_col!r} not in panel columns. "
+                f"Available numeric columns: {available}"
+            )
+
+        # ---- Build instance index (ticker, start_idx, end_idx) ---------------
+        self._instances: list[tuple[str, int, int]] = []
+        required_len = lookback + horizon
+        for ticker, grp in self._panel.groupby("ticker"):
+            n = len(grp)
+            if n < required_len:
+                continue
+            start_positions = range(n - required_len + 1)
+            grp_idx = grp.index.tolist()
+            for s in start_positions:
+                self._instances.append((ticker, grp_idx[s], grp_idx[s + required_len - 1]))
+
+        # ---- Scenarios -------------------------------------------------------
+        scenarios_path = bench_dir / "scenarios.parquet"
+        if scenarios_path.exists():
+            self._scenarios = pd.read_parquet(scenarios_path)
+            self._scenarios["event_date"] = pd.to_datetime(self._scenarios["event_date"])
+        else:
+            self._scenarios = pd.DataFrame()
+
+        # ---- Filing corpus index (optional, text loaded on-demand) -----------
+        self._corpus: pd.DataFrame | None = None
+        self._corpus_by_ticker: dict[str, pd.DataFrame] = {}
+        if load_text:
+            corpus_path = bench_dir / "filing_corpus.parquet"
+            if corpus_path.exists():
+                self._corpus = pd.read_parquet(corpus_path)
+                self._corpus["filing_date"] = pd.to_datetime(
+                    self._corpus["filing_date"], errors="coerce",
+                )
+                self._corpus = self._corpus.sort_values("filing_date")
+                # Pre-build per-ticker index for O(1) lookup
+                for ticker, grp in self._corpus.groupby("ticker"):
+                    self._corpus_by_ticker[str(ticker)] = grp
+
+        # ---- Task definition -------------------------------------------------
+        task_path = bench_dir / "task_definition.json"
+        self.task_definition: dict = {}
+        if task_path.exists():
+            self.task_definition = json.loads(task_path.read_text())
+
+        n_tickers = self._panel["ticker"].nunique()
+        logger.info(
+            "WhatIfTSFDataset(%s/%s, lookback=%d, horizon=%d): %d instances from %d tickers.",
+            split, granularity, lookback, horizon, len(self._instances), n_tickers,
+        )
+        if len(self._instances) == 0 and n_tickers > 0:
+            max_len = self._panel.groupby("ticker").size().max()
+            logger.warning(
+                "ZERO instances generated! lookback(%d) + horizon(%d) = %d periods required, "
+                "but longest ticker has only %d periods. "
+                "Consider using smaller lookback/horizon values for %s granularity. "
+                "Suggested defaults: lookback=%d, horizon=%d.",
+                lookback, horizon, lookback + horizon, max_len, granularity,
+                config.get_lookback_windows(granularity)[0],
+                config.get_horizons(granularity)[0],
+            )
+
+    # ------------------------------------------------------------------
+    # Sequence protocol
+    # ------------------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._instances)
+
+    def canonical_indices(self, task: str = "T1") -> list[int]:
+        """Return the dataset-instance indices matching the canonical
+        ``(ticker, anchor_date)`` pairs from
+        ``dataloader.canonical_indices.get_canonical_indices(task)``.
+
+        For T1, ``anchor_date`` is the lookback-end date (i.e. the latest
+        date in the window). Every T1 baseline must iterate exactly these
+        indices so cross-method comparison is on identical instances.
+        """
+        from .dataloader.canonical_indices import get_canonical_indices
+
+        canonical = get_canonical_indices(
+            task, "eval", granularity=self.granularity,
+        )
+        canonical_set = {
+            (str(t), pd.Timestamp(a))
+            for t, a in zip(
+                canonical["ticker"].astype(str),
+                pd.to_datetime(canonical["anchor_date"]),
+            )
+        }
+        out: list[int] = []
+        for i, (ticker, row_start, _row_end) in enumerate(self._instances):
+            lookback_end_date = pd.Timestamp(
+                self._panel.loc[row_start + self.lookback - 1, "date"]
+            )
+            if (str(ticker), lookback_end_date) in canonical_set:
+                out.append(i)
+        return out
+
+    def __getitem__(self, idx: int) -> dict[str, Any]:
+        if idx < 0 or idx >= len(self._instances):
+            raise IndexError(f"Index {idx} out of range [0, {len(self._instances)})")
+        ticker, row_start, row_end = self._instances[idx]
+
+        window = self._panel.loc[row_start: row_end].copy()
+        lookback_df = window.iloc[: self.lookback]
+        target_df = window.iloc[self.lookback:]
+
+        date_start = lookback_df["date"].iloc[0]
+        date_end = target_df["date"].iloc[-1]
+
+        # Numeric feature columns
+        exclude = {"ticker", "date", "label", "split",
+                   "nearest_filing_type", "nearest_filing_date", "nearest_filing_path"}
+        feat_cols = [c for c in lookback_df.columns if c not in exclude and lookback_df[c].dtype.kind in "fiub"]
+
+        # Context
+        context: dict[str, Any] = {
+            "ticker": ticker,
+            "date_start": str(date_start.date()),
+            "date_end": str(date_end.date()),
+            "sector": lookback_df.get("sector", pd.Series()).iloc[0] if "sector" in lookback_df.columns else None,
+            "industry": lookback_df.get("industry", pd.Series()).iloc[0] if "industry" in lookback_df.columns else None,
+            "label": lookback_df["label"].iloc[0] if "label" in lookback_df.columns else None,
+        }
+
+        # Macro state summary for LLM agents -- human-readable snapshot of the
+        # latest macro values at the lookback end.
+        _MACRO_LABELS = {
+            "fred_FEDFUNDS": "Fed Funds Rate",
+            "fred_DGS2": "2Y Treasury",
+            "fred_DGS10": "10Y Treasury",
+            "fred_VIXCLS": "VIX",
+            "fred_SP500": "S&P 500",
+            "fred_NASDAQCOM": "NASDAQ",
+            "fred_DTWEXBGS": "USD Index",
+            "eia_crude_spot": "WTI Crude ($/bbl)",
+            "eia_ng_spot": "Nat Gas ($/MMBtu)",
+        }
+        macro_snapshot: dict[str, float | str] = {}
+        last_row = lookback_df.iloc[-1]
+        for col, label in _MACRO_LABELS.items():
+            if col in lookback_df.columns:
+                val = last_row[col]
+                if pd.notna(val):
+                    macro_snapshot[label] = round(float(val), 2)
+        if macro_snapshot:
+            context["macro_state"] = macro_snapshot
+
+        # Filing text (nearest 10-K/10-Q as-of the lookback end) -- O(1) dict lookup
+        if self._corpus_by_ticker:
+            lookback_end = lookback_df["date"].iloc[-1]
+            ticker_filings = self._corpus_by_ticker.get(ticker)
+            if ticker_filings is not None:
+                valid = ticker_filings[ticker_filings["filing_date"] <= lookback_end]
+                if not valid.empty:
+                    # Nearest 10-K/10-Q for primary filing context
+                    annual_q = valid[valid["filing_type"].isin(["10-K", "10-Q"])]
+                    if not annual_q.empty:
+                        latest = annual_q.iloc[-1]
+                        context["filing_type"] = latest.get("filing_type", "")
+                        context["filing_date"] = str(latest.get("filing_date", ""))
+                        filing_path = latest.get("filing_path", "")
+                        if filing_path:
+                            full_path = config.DATA_DIR / filing_path
+                            try:
+                                context["filing_text"] = full_path.read_text(
+                                    encoding="utf-8", errors="replace"
+                                )
+                            except Exception:
+                                context["filing_text"] = ""
+                        else:
+                            context["filing_text"] = ""
+
+                    # 8-K filings within the lookback window
+                    lookback_start = lookback_df["date"].iloc[0]
+                    eightk = valid[
+                        (valid["filing_type"] == "8-K")
+                        & (valid["filing_date"] >= lookback_start)
+                    ]
+                    if not eightk.empty:
+                        eightk_texts = []
+                        for _, row in eightk.iterrows():
+                            fp = row.get("filing_path", "")
+                            if fp:
+                                full_path = config.DATA_DIR / fp
+                                try:
+                                    eightk_texts.append(full_path.read_text(
+                                        encoding="utf-8", errors="replace"
+                                    ))
+                                except Exception:
+                                    pass
+                        if eightk_texts:
+                            context["filing_8k_texts"] = eightk_texts
+
+        # Recent news from yfinance per-ticker JSON
+        news_path = config.NEWS_DIR / "tickers" / f"{ticker}.json"
+        if news_path.exists():
+            try:
+                all_news = json.loads(news_path.read_text(encoding="utf-8"))
+                lookback_end_dt = lookback_df["date"].iloc[-1]
+                lookback_start_dt = lookback_df["date"].iloc[0]
+                recent = []
+                for art in all_news:
+                    pub = art.get("pubDate") or art.get("pub_date") or art.get("providerPublishTime")
+                    if pub is None:
+                        continue
+                    try:
+                        ts = pd.Timestamp(pub)
+                    except Exception:
+                        continue
+                    if lookback_start_dt <= ts <= lookback_end_dt:
+                        recent.append(art)
+                if recent:
+                    context["recent_news"] = recent
+            except Exception:
+                pass
+
+        # Scenario overlay -- label each as "observed" (in lookback) or
+        # "hypothetical" (in forecast horizon), which is the core semantic
+        # distinction for what-if evaluation.
+        if not self._scenarios.empty:
+            lookback_end = lookback_df["date"].iloc[-1]
+            overlapping = self._scenarios[
+                (self._scenarios["event_date"] >= date_start)
+                & (self._scenarios["event_date"] <= date_end)
+            ].copy()
+            if not overlapping.empty:
+                overlapping["scenario_role"] = np.where(
+                    overlapping["event_date"] <= lookback_end,
+                    "observed",       # Already happened -- model should know this
+                    "hypothetical",   # In forecast window -- the "what-if" condition
+                )
+                sc_cols = [
+                    "scenario_id", "event_type", "event_date",
+                    "event_description", "scenario_role",
+                ]
+                # Include news_context if available
+                if "news_context" in self._scenarios.columns:
+                    sc_cols.append("news_context")
+                context["scenarios"] = overlapping[
+                    [c for c in sc_cols if c in overlapping.columns]
+                ].to_dict("records")
+
+        return {
+            "lookback": lookback_df[feat_cols].values.astype(np.float32),
+            "lookback_dates": lookback_df["date"].dt.strftime("%Y-%m-%d").tolist(),
+            "target": target_df[self.target_col].values.astype(np.float32),
+            "target_dates": target_df["date"].dt.strftime("%Y-%m-%d").tolist(),
+            "context": context,
+            "feature_names": feat_cols,
+        }
+
+    # ------------------------------------------------------------------
+    # Convenience
+    # ------------------------------------------------------------------
+
+    def summary(self) -> dict[str, Any]:
+        """Quick dataset summary statistics."""
+        return {
+            "split": self.split,
+            "granularity": self.granularity,
+            "lookback": self.lookback,
+            "horizon": self.horizon,
+            "num_instances": len(self._instances),
+            "num_tickers": self._panel["ticker"].nunique(),
+            "date_range": [
+                str(self._panel["date"].min().date()),
+                str(self._panel["date"].max().date()),
+            ],
+            "num_scenarios": len(self._scenarios),
+            "corpus_loaded": self._corpus is not None and not self._corpus.empty,
+        }
+
+
+# ===================================================================
+# ValuationDataset: point-in-time valuation benchmark loader
+# ===================================================================
+
+class ValuationDataset:
+    """Dataset for valuation benchmark tasks (A–F).
+
+    Each instance is a point-in-time snapshot suitable for:
+      Task A: estimate equity value given observable financials (public company)
+      Task B: generate financial statements given company profile
+      Task C: forecast scenario impact given pre-event data
+      Task D: estimate equity value given only financials + sector (PE simulation)
+      Task E: generate financial statements for unseen companies (Generator eval)
+      Task F: estimate rent/price for properties (RE valuation)
+
+    Parameters
+    ----------
+    task : str
+        ``"A"``–``"F"`` (or full name like ``"valuation_accuracy"``).
+    granularity : str
+        Defaults to ``config.GRANULARITY``.
+    """
+
+    _TASK_MAP = {
+        "A": "A_valuation_accuracy",
+        "B": "B_statement_generation",
+        "C": "C_scenario_forecast",
+        "D": "D_private_valuation",
+        "E": "E_generator_evaluation",
+        "F": "F_real_estate_valuation",
+        "valuation_accuracy": "A_valuation_accuracy",
+        "statement_generation": "B_statement_generation",
+        "scenario_forecast": "C_scenario_forecast",
+        "private_valuation": "D_private_valuation",
+        "generator_evaluation": "E_generator_evaluation",
+        "real_estate_valuation": "F_real_estate_valuation",
+    }
+
+    def __init__(
+        self,
+        task: str = "A",
+        granularity: str | None = None,
+    ) -> None:
+        if granularity is None:
+            granularity = config.GRANULARITY
+        self.granularity = granularity
+        self.task = self._TASK_MAP.get(task, task)
+
+        bench_dir = config.DATA_DIR / "benchmark" / granularity
+
+        # Load task definitions
+        task_path = bench_dir / "valuation_tasks.json"
+        if task_path.exists():
+            self.task_definitions = json.loads(task_path.read_text())
+        else:
+            self.task_definitions = {}
+
+        task_def = self.task_definitions.get("tasks", {}).get(self.task, {})
+        input_file = task_def.get("input")
+        gt_file = task_def.get("ground_truth")
+
+        # Load inputs
+        self._inputs = pd.DataFrame()
+        if input_file:
+            p = bench_dir / input_file
+            if p.exists():
+                self._inputs = pd.read_parquet(p) if p.suffix == ".parquet" else pd.read_csv(p)
+
+        # Load ground truth
+        self._ground_truth = pd.DataFrame()
+        if gt_file:
+            p = bench_dir / gt_file
+            if p.exists():
+                self._ground_truth = pd.read_parquet(p) if p.suffix == ".parquet" else pd.read_csv(p)
+
+        # Holdout tickers
+        self.holdout_tickers = self.task_definitions.get("holdout_tickers", [])
+
+        logger.info(
+            "ValuationDataset(task=%s, gran=%s): %d inputs, %d ground_truth rows",
+            self.task, granularity, len(self._inputs), len(self._ground_truth),
+        )
+
+    @property
+    def inputs(self) -> pd.DataFrame:
+        return self._inputs
+
+    @property
+    def ground_truth(self) -> pd.DataFrame:
+        return self._ground_truth
+
+    def __len__(self) -> int:
+        return len(self._inputs)
+
+    def __getitem__(self, idx: int) -> dict[str, Any]:
+        if idx < 0 or idx >= len(self._inputs):
+            raise IndexError(f"Index {idx} out of range [0, {len(self._inputs)})")
+
+        row = self._inputs.iloc[idx]
+        item: dict[str, Any] = {"input": row.to_dict()}
+
+        # Attach ground truth if available
+        if not self._ground_truth.empty:
+            if self.task in ("A_valuation_accuracy", "D_private_valuation"):
+                tk = row.get("ticker")
+                dt = row.get("date")
+                match = self._ground_truth[
+                    (self._ground_truth["ticker"] == tk)
+                    & (self._ground_truth["date"] == dt)
+                ]
+                if not match.empty:
+                    item["ground_truth"] = match.iloc[0].to_dict()
+            elif self.task in ("B_statement_generation", "E_generator_evaluation"):
+                tk = row.get("ticker")
+                match = self._ground_truth[self._ground_truth["ticker"] == tk]
+                if not match.empty:
+                    item["ground_truth"] = match.to_dict("records")
+            elif self.task == "C_scenario_forecast":
+                sid = row.get("scenario_id")
+                if sid:
+                    match = self._ground_truth[self._ground_truth["scenario_id"] == sid]
+                    if not match.empty:
+                        item["ground_truth"] = match.to_dict("records")
+            elif self.task == "F_real_estate_valuation":
+                # Match by index position (inputs and GT are aligned)
+                if idx < len(self._ground_truth):
+                    item["ground_truth"] = self._ground_truth.iloc[idx].to_dict()
+
+        return item
+
+    def summary(self) -> dict[str, Any]:
+        """Quick dataset summary."""
+        s: dict[str, Any] = {
+            "task": self.task,
+            "granularity": self.granularity,
+            "n_inputs": len(self._inputs),
+            "n_ground_truth": len(self._ground_truth),
+            "n_holdout_tickers": len(self.holdout_tickers),
+        }
+        if not self._inputs.empty and "ticker" in self._inputs.columns:
+            s["n_tickers"] = self._inputs["ticker"].nunique()
+        return s

code/build_ontology.py

@@ -0,0 +1,438 @@
+"""Build industry-level XBRL ontology + company-level extracted fields.
+
+Reads raw XBRL company facts (``data/xbrl/raw/{TICKER}.json``) and the
+universe file to:
+
+1. **Parse** all 10-K / 10-Q facts into a normalised table.
+2. **Group** by sector and industry (from ``company_info.csv``).
+3. **Classify** each tag per industry:
+   - **core**   – appears in ≥70 % of companies in the industry
+   - **common** – appears in ≥30 %
+   - **extension** – appears in <30 % (often company-specific XBRL extensions)
+4. **Output**:
+   - ``data/xbrl/parsed/company_facts.parquet`` – all extracted facts
+   - ``data/xbrl/parsed/company_tags.parquet``  – per-company tag list (latest value)
+   - ``data/xbrl/ontology/industry_ontology.json`` – per-industry tag classification
+   - ``data/xbrl/ontology/tag_catalog.parquet``    – master tag catalog with labels
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+_RAW_DIR = config.XBRL_DIR / "raw"
+_PARSED_DIR = config.XBRL_DIR / "parsed"
+_ONTOLOGY_DIR = config.XBRL_DIR / "ontology"
+
+
+# ---------------------------------------------------------------------------
+# Step 1: Parse raw company facts into a flat table
+# ---------------------------------------------------------------------------
+
+def _parse_single_company(
+    ticker: str,
+    path: Path,
+    allowed_forms: set[str],
+) -> tuple[list[dict], dict[str, dict]]:
+    """Parse one company's raw XBRL JSON.
+
+    Returns
+    -------
+    facts : list[dict]
+        Flat rows of (ticker, taxonomy, tag, label, unit, period_start,
+        period_end, value, form, fiscal_year, fiscal_period, filed).
+    tag_meta : dict[str, dict]
+        ``{taxonomy:tag: {label, description, taxonomy}}``
+    """
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        logger.warning("Corrupt JSON for %s, skipping", ticker)
+        return [], {}
+
+    if raw.get("_no_xbrl"):
+        return [], {}
+
+    facts_root = raw.get("facts", {})
+    rows: list[dict] = []
+    tag_meta: dict[str, dict] = {}
+
+    for taxonomy, tags in facts_root.items():
+        for tag_name, tag_data in tags.items():
+            label = tag_data.get("label") or tag_name
+            description = tag_data.get("description") or ""
+
+            meta_key = f"{taxonomy}:{tag_name}"
+            if meta_key not in tag_meta:
+                tag_meta[meta_key] = {
+                    "taxonomy": taxonomy,
+                    "tag": tag_name,
+                    "label": label,
+                    "description": str(description),
+                }
+
+            units = tag_data.get("units", {})
+            for unit_name, entries in units.items():
+                for entry in entries:
+                    form = entry.get("form", "")
+                    if form not in allowed_forms:
+                        continue
+
+                    rows.append({
+                        "ticker": ticker,
+                        "taxonomy": taxonomy,
+                        "tag": tag_name,
+                        "label": label,
+                        "unit": unit_name,
+                        "period_start": entry.get("start"),
+                        "period_end": entry.get("end"),
+                        "value": entry.get("val"),
+                        "form": form,
+                        "fiscal_year": entry.get("fy"),
+                        "fiscal_period": entry.get("fp"),
+                        "filed": entry.get("filed"),
+                        "accession": entry.get("accn", ""),
+                    })
+
+    return rows, tag_meta
+
+
+def _parse_all_companies() -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Parse all raw XBRL JSON files.
+
+    Returns ``(facts_df, tag_catalog_df)``
+    """
+    if not _RAW_DIR.exists():
+        raise FileNotFoundError(
+            f"XBRL raw directory not found: {_RAW_DIR}. Run collect_filings first (Step 4)."
+        )
+
+    json_files = sorted(_RAW_DIR.glob("*.json"))
+    if not json_files:
+        raise FileNotFoundError("No XBRL JSON files found in " + str(_RAW_DIR))
+
+    allowed_forms = set(config.XBRL_FORMS)
+    all_rows: list[dict] = []
+    all_meta: dict[str, dict] = {}
+
+    for i, path in enumerate(json_files):
+        ticker = path.stem
+        rows, meta = _parse_single_company(ticker, path, allowed_forms)
+        all_rows.extend(rows)
+        all_meta.update(meta)
+
+        if (i + 1) % 500 == 0:
+            logger.info("  Parsed %d / %d companies (%d facts so far)",
+                        i + 1, len(json_files), len(all_rows))
+
+    logger.info(
+        "Parsed %d companies → %d facts, %d unique tags",
+        len(json_files), len(all_rows), len(all_meta),
+    )
+
+    facts_df = pd.DataFrame(all_rows)
+    if not facts_df.empty:
+        for col in ("period_start", "period_end", "filed"):
+            facts_df[col] = pd.to_datetime(facts_df[col], errors="coerce")
+
+    tag_catalog = pd.DataFrame(list(all_meta.values()))
+    return facts_df, tag_catalog
+
+
+# ---------------------------------------------------------------------------
+# Step 2: Build per-industry ontology
+# ---------------------------------------------------------------------------
+
+def _load_industry_map() -> dict[str, tuple[str, str]]:
+    """Load ticker → (sector, industry) from company_info.csv."""
+    ci_path = config.FUNDAMENTALS_DIR / "company_info.csv"
+    if not ci_path.exists():
+        logger.warning("company_info.csv not found; falling back to universe sectors")
+        u_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+        if not u_path.exists():
+            return {}
+        u = pd.read_csv(u_path)
+        return {
+            row["ticker"]: (str(row.get("sector", "Unknown")), "Unknown")
+            for _, row in u.iterrows()
+        }
+
+    ci = pd.read_csv(ci_path)
+    return {
+        row["ticker"]: (
+            str(row.get("sector", "Unknown")),
+            str(row.get("industry", "Unknown")),
+        )
+        for _, row in ci.iterrows()
+    }
+
+
+def _build_ontology(
+    facts_df: pd.DataFrame,
+    industry_map: dict[str, tuple[str, str]],
+) -> dict:
+    """Build the industry-level ontology.
+
+    Returns a nested dict::
+
+        {
+          "by_sector": {
+            "Healthcare": {
+              "company_count": 515,
+              "tag_count": 1234,
+              "tags": {
+                "us-gaap:Revenue": {
+                  "label": "Revenue",
+                  "coverage": 0.95,
+                  "classification": "core",
+                  "median_value": 123456789,
+                  "industries": ["Biotechnology", "Medical Devices", ...]
+                },
+                ...
+              }
+            },
+            ...
+          },
+          "by_industry": {
+            "Biotechnology": {
+              "sector": "Healthcare",
+              "company_count": 238,
+              "tag_count": 567,
+              "tags": { ... }
+            },
+            ...
+          }
+        }
+    """
+    if facts_df.empty:
+        return {"by_sector": {}, "by_industry": {}}
+
+    # Attach sector/industry
+    facts_df = facts_df.copy()
+    facts_df["sector"] = facts_df["ticker"].map(
+        lambda t: industry_map.get(t, ("Unknown", "Unknown"))[0]
+    )
+    facts_df["industry"] = facts_df["ticker"].map(
+        lambda t: industry_map.get(t, ("Unknown", "Unknown"))[1]
+    )
+
+    # Build a full tag key
+    facts_df["tag_key"] = facts_df["taxonomy"] + ":" + facts_df["tag"]
+
+    core_thresh = config.XBRL_CORE_THRESHOLD
+    common_thresh = config.XBRL_COMMON_THRESHOLD
+
+    def _classify_tags(
+        group_facts: pd.DataFrame,
+        group_name: str,
+    ) -> dict:
+        """Classify tags within a group (sector or industry)."""
+        company_count = group_facts["ticker"].nunique()
+        if company_count == 0:
+            return {
+                "company_count": 0,
+                "tag_count": 0,
+                "tags": {},
+            }
+
+        # For each tag: how many companies have reported it
+        tag_company_counts = (
+            group_facts.groupby("tag_key")["ticker"]
+            .nunique()
+            .to_dict()
+        )
+        # Tag labels (modal) — via value_counts + idxmax (vectorized)
+        lab_vc = group_facts.groupby(["tag_key", "label"]).size().reset_index(name="n")
+        lab_idx = lab_vc.groupby("tag_key")["n"].idxmax()
+        tag_labels = dict(
+            zip(lab_vc.loc[lab_idx, "tag_key"].values, lab_vc.loc[lab_idx, "label"].values)
+        )
+        # Median value per (tag, latest fiscal year) — single vectorized groupby
+        val_numeric = pd.to_numeric(group_facts["value"], errors="coerce")
+        gf = group_facts.assign(_vn=val_numeric).dropna(subset=["_vn"])
+        median_values: dict = {}
+        if not gf.empty:
+            med_by_fy = gf.groupby(["tag_key", "fiscal_year"])["_vn"].median()
+            latest_fy_series = gf.groupby("tag_key")["fiscal_year"].max()
+            for tk, fy in latest_fy_series.items():
+                if (tk, fy) in med_by_fy.index:
+                    median_values[tk] = float(med_by_fy.loc[(tk, fy)])
+
+        tags: dict[str, dict] = {}
+        for tag_key, n_companies in tag_company_counts.items():
+            coverage = n_companies / company_count
+            if coverage >= core_thresh:
+                classification = "core"
+            elif coverage >= common_thresh:
+                classification = "common"
+            else:
+                classification = "extension"
+
+            tags[tag_key] = {
+                "label": tag_labels.get(tag_key, ""),
+                "company_count": int(n_companies),
+                "coverage": round(coverage, 4),
+                "classification": classification,
+                "median_value": median_values.get(tag_key),
+            }
+
+        return {
+            "company_count": int(company_count),
+            "tag_count": len(tags),
+            "tags": dict(sorted(
+                tags.items(),
+                key=lambda x: (-x[1]["coverage"], x[0]),
+            )),
+        }
+
+    # By sector
+    ontology_by_sector: dict = {}
+    for sector, sector_facts in facts_df.groupby("sector"):
+        logger.info("  Building ontology for sector: %s", sector)
+        ontology_by_sector[sector] = _classify_tags(sector_facts, sector)
+
+    # By industry
+    ontology_by_industry: dict = {}
+    for industry, ind_facts in facts_df.groupby("industry"):
+        sector = ind_facts["sector"].mode()
+        sector_name = sector.iloc[0] if len(sector) > 0 else "Unknown"
+        result = _classify_tags(ind_facts, industry)
+        result["sector"] = sector_name
+        ontology_by_industry[industry] = result
+
+    return {
+        "by_sector": ontology_by_sector,
+        "by_industry": ontology_by_industry,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Step 3: Extract company-level tag summaries
+# ---------------------------------------------------------------------------
+
+def _build_company_tags(facts_df: pd.DataFrame) -> pd.DataFrame:
+    """For each company, extract the latest value per tag.
+
+    Returns a DataFrame with columns:
+        ticker, taxonomy, tag, label, unit, value, fiscal_year, fiscal_period, filed
+    """
+    if facts_df.empty:
+        return pd.DataFrame()
+
+    # Keep only the latest filing per ticker × tag × unit
+    idx = facts_df.groupby(["ticker", "taxonomy", "tag", "unit"])["filed"].idxmax()
+    latest = facts_df.loc[idx].copy()
+    latest = latest.sort_values(["ticker", "taxonomy", "tag"])
+    return latest[
+        ["ticker", "taxonomy", "tag", "label", "unit", "value",
+         "fiscal_year", "fiscal_period", "filed"]
+    ].reset_index(drop=True)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def run() -> dict[str, int]:
+    """Build XBRL ontology from collected company facts.
+
+    Returns summary dict with counts.
+    """
+    _PARSED_DIR.mkdir(parents=True, exist_ok=True)
+    _ONTOLOGY_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Skip if already built (resume-safe). The ontology only needs rebuilding
+    # if the raw XBRL files change, which only happens after collect_filings.
+    ontology_path = _ONTOLOGY_DIR / "industry_ontology.json"
+    facts_path = _PARSED_DIR / "company_facts.parquet"
+    if ontology_path.exists() and ontology_path.stat().st_size > 1000 and facts_path.exists() and facts_path.stat().st_size > 1000:
+        ont = json.loads(ontology_path.read_text())
+        # The ontology JSON has top-level keys {by_sector, by_industry}; sector
+        # and industry counts are the lengths of THOSE inner dicts, not of the
+        # top-level dict itself.
+        if isinstance(ont, dict):
+            n_sectors = len(ont.get("by_sector", {}))
+            n_industries = len(ont.get("by_industry", {}))
+        else:
+            n_sectors = 0
+            n_industries = 0
+        logger.info("Ontology already exists (%d sectors, %d industries). Skipping rebuild.",
+                    n_sectors, n_industries)
+        tags = pd.read_parquet(_ONTOLOGY_DIR / "tag_catalog.parquet") if (_ONTOLOGY_DIR / "tag_catalog.parquet").exists() else pd.DataFrame()
+        facts = pd.read_parquet(facts_path)
+        return {
+            "facts": len(facts),
+            "unique_tags": len(tags),
+            "companies": facts["ticker"].nunique() if "ticker" in facts.columns else 0,
+            "sectors": n_sectors,
+            "industries": n_industries,
+        }
+
+    # ── Step 1: Parse raw JSON ──────────────────────────────────────────
+    logger.info("Parsing raw XBRL company facts…")
+    facts_df, tag_catalog = _parse_all_companies()
+
+    # Save parsed facts
+    facts_path = _PARSED_DIR / "company_facts.parquet"
+    if not facts_df.empty:
+        facts_df.to_parquet(facts_path, index=False)
+        logger.info("Saved %d facts to %s", len(facts_df), facts_path)
+    else:
+        logger.warning("No facts parsed — empty output")
+        return {"facts": 0, "tags": 0, "sectors": 0, "industries": 0}
+
+    # Save tag catalog
+    catalog_path = _ONTOLOGY_DIR / "tag_catalog.parquet"
+    tag_catalog.to_parquet(catalog_path, index=False)
+    logger.info("Saved %d unique tags to %s", len(tag_catalog), catalog_path)
+
+    # ── Step 2: Build industry ontology ─────────────────────────────────
+    logger.info("Building industry ontology…")
+    industry_map = _load_industry_map()
+    ontology = _build_ontology(facts_df, industry_map)
+
+    ontology_path = _ONTOLOGY_DIR / "industry_ontology.json"
+    with open(ontology_path, "w", encoding="utf-8") as fh:
+        json.dump(ontology, fh, indent=2, ensure_ascii=False, default=str)
+    logger.info("Saved ontology to %s", ontology_path)
+
+    # ── Step 3: Company-level tag summary ───────────────────────────────
+    logger.info("Building company-level tag summaries…")
+    company_tags = _build_company_tags(facts_df)
+    company_tags_path = _PARSED_DIR / "company_tags.parquet"
+    company_tags.to_parquet(company_tags_path, index=False)
+    logger.info("Saved %d company-tag rows to %s", len(company_tags), company_tags_path)
+
+    n_sectors = len(ontology.get("by_sector", {}))
+    n_industries = len(ontology.get("by_industry", {}))
+
+    summary = {
+        "facts": len(facts_df),
+        "unique_tags": len(tag_catalog),
+        "companies": facts_df["ticker"].nunique(),
+        "sectors": n_sectors,
+        "industries": n_industries,
+    }
+    logger.info("Ontology build complete: %s", summary)
+
+    # Print top-level ontology summary
+    for sector, data in sorted(ontology.get("by_sector", {}).items()):
+        core = sum(1 for t in data["tags"].values() if t["classification"] == "core")
+        common = sum(1 for t in data["tags"].values() if t["classification"] == "common")
+        ext = sum(1 for t in data["tags"].values() if t["classification"] == "extension")
+        logger.info(
+            "  %s: %d companies, %d tags (core=%d, common=%d, extension=%d)",
+            sector, data["company_count"], data["tag_count"], core, common, ext,
+        )
+
+    return summary

code/build_valuation_tasks.py

@@ -0,0 +1,956 @@
+"""Valuation benchmark: task definitions and ground-truth construction.
+
+Produces the artifacts required for the benchmark tasks T2-T7:
+  T2 - Company Valuation Accuracy (public company, all observables)
+  T3 - Financial Statement Generation Quality
+  T4 - Scenario-Conditioned Forecasting (ground truth only; scenarios
+       themselves are produced by `generate_scenarios.py`)
+  T5 - Private Company Valuation (PE simulation, financials + sector only)
+  T6 - Generator Evaluation (NL description -> XBRL fields)
+  T7 - Real Estate Valuation
+
+Called from `assemble_benchmark.py` as the final Layer-3 build step.
+
+Lives at the top level of `whatif_bench/` -- a peer of the other
+benchmark builders (`assemble_benchmark.py`, `generate_scenarios.py`,
+`enrich_benchmark.py`, `build_ontology.py`). NOT under `agents/`:
+agents USE the benchmark, they don't BUILD it.
+
+Usage:
+    from projects.agent_builder.scripts.whatif_bench.build_valuation_tasks import (
+        build_valuation_benchmark,
+    )
+    summary = build_valuation_benchmark(granularity="daily")
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+# Columns that are algebraically equivalent to (or directly reveal)
+# market capitalisation. These MUST be excluded from any valuation-task
+# input whose target is actual_market_cap, otherwise the task degenerates
+# into trivial recovery. Used by Task A (and Task D's broader strip).
+#   derived_pe              = market_cap / earnings
+#   derived_ev              = market_cap + debt - cash
+#   derived_ev_to_revenue   = ev / revenue                (reveals mcap)
+#   derived_ev_to_ebitda    = ev / ebitda                 (reveals mcap)
+#   derived_pb              = market_cap / book_equity
+#   derived_price_to_book   = alias for derived_pb
+#   derived_fcf_yield       = fcf / market_cap
+_MARKET_CAP_LEAKAGE_COLS: frozenset[str] = frozenset({
+    "derived_market_cap",
+    "derived_pe",
+    "derived_ev",
+    "derived_ev_to_revenue",
+    "derived_ev_to_ebitda",
+    "derived_pb",
+    "derived_price_to_book",
+    "derived_fcf_yield",
+})
+
+
+# ===================================================================
+# Task A: Company Valuation Ground Truth
+# ===================================================================
+
+def _build_task_a(
+    panel: pd.DataFrame,
+    company_info: pd.DataFrame,
+    holdout_tickers: list[str],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task A: estimate intrinsic value of public companies.
+
+    For each quarterly boundary × ticker, create:
+      - input:  company description, sector, industry, recent financials
+      - target: actual market cap (hidden)
+    """
+    # Quarterly boundaries (resample to quarter-end dates)
+    if "derived_market_cap" not in panel.columns:
+        logger.warning("derived_market_cap not in panel; skipping Task A")
+        return {"error": "No market cap data"}
+
+    # Use panel data at quarterly frequency
+    quarterly = panel.copy()
+    quarterly["date"] = pd.to_datetime(quarterly["date"])
+    quarterly["quarter"] = quarterly["date"].dt.to_period("Q")
+
+    # Take last observation per ticker × quarter
+    quarterly = quarterly.sort_values("date").drop_duplicates(
+        subset=["ticker", "quarter"], keep="last",
+    )
+
+    # Split: holdout tickers = evaluation, rest = context
+    eval_mask = quarterly["ticker"].isin(holdout_tickers)
+    eval_df = quarterly[eval_mask].copy()
+
+    if eval_df.empty:
+        return {"error": "No holdout tickers found in panel"}
+
+    # Build inputs (observable data). derived_* columns that are
+    # algebraic functions of market_cap are excluded -- they would let any
+    # model recover the target trivially. See _MARKET_CAP_LEAKAGE_COLS
+    # at the top of this module for the rationale per column.
+    input_cols = ["ticker", "date", "sector", "industry"]
+    for c in quarterly.columns:
+        if c in _MARKET_CAP_LEAKAGE_COLS:
+            continue
+        if c.startswith("derived_") or c.startswith("stmt_"):
+            input_cols.append(c)
+    input_cols = [c for c in input_cols if c in eval_df.columns]
+    inputs = eval_df[input_cols].copy()
+
+    # Build ground truth (hidden)
+    gt = eval_df[["ticker", "date", "derived_market_cap"]].copy()
+    gt = gt.rename(columns={"derived_market_cap": "actual_market_cap"})
+    gt = gt.dropna(subset=["actual_market_cap"])
+
+    # Save
+    inputs.to_parquet(output_dir / "valuation_inputs.parquet", index=False)
+    gt.to_parquet(output_dir / "valuation_ground_truth.parquet", index=False)
+
+    return {
+        "n_tickers": gt["ticker"].nunique(),
+        "n_instances": len(gt),
+        "date_range": [str(gt["date"].min()), str(gt["date"].max())],
+    }
+
+
+# ===================================================================
+# Task B: Financial Statement Generation Ground Truth
+# ===================================================================
+
+def _build_task_b(
+    company_info: pd.DataFrame,
+    holdout_tickers: list[str],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task B: generate plausible financial statements.
+
+    For holdout tickers, the latest XBRL filings serve as ground truth.
+    Input: company profile (sector, industry, size description).
+    Target: actual XBRL financial statements.
+    """
+    # Load XBRL company tags (latest values)
+    tags_path = config.XBRL_DIR / "parsed" / "company_tags.parquet"
+    if not tags_path.exists():
+        logger.warning("XBRL company_tags not found; skipping Task B")
+        return {"error": "No XBRL data"}
+
+    tags = pd.read_parquet(tags_path)
+    holdout_tags = tags[tags["ticker"].isin(holdout_tickers)]
+
+    if holdout_tags.empty:
+        return {"error": "No XBRL tags for holdout tickers"}
+
+    # Input: company descriptions
+    inputs = company_info[company_info["ticker"].isin(holdout_tickers)].copy()
+    if inputs.empty:
+        inputs = pd.DataFrame({"ticker": holdout_tickers})
+
+    # Ground truth: XBRL tags (field/value pairs)
+    gt_rows = []
+    for _, row in holdout_tags.iterrows():
+        gt_rows.append({
+            "ticker": row["ticker"],
+            "field": row["tag"],
+            "value": row["value"],
+            "taxonomy": row.get("taxonomy", ""),
+            "unit": row.get("unit", ""),
+            "fiscal_year": row.get("fiscal_year"),
+        })
+
+    gt = pd.DataFrame(gt_rows)
+
+    # Save
+    inputs.to_parquet(output_dir / "generation_inputs.parquet", index=False)
+    gt.to_parquet(output_dir / "generation_ground_truth.parquet", index=False)
+
+    return {
+        "n_tickers": gt["ticker"].nunique(),
+        "n_fields": gt["field"].nunique(),
+        "n_instances": len(gt),
+    }
+
+
+# ===================================================================
+# Task C: Scenario-Conditioned Forecasting Ground Truth
+# ===================================================================
+
+def _build_task_c(
+    panel: pd.DataFrame,
+    scenarios: pd.DataFrame,
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task C: forecast financial impact of what-if scenarios.
+
+    Extends existing scenarios with actual post-event changes in:
+      - price return (already in scenarios)
+      - revenue change (from panel statements)
+      - market cap change
+
+    Vectorised: pre-groups panel by ticker, then uses numpy searchsorted
+    to avoid O(scenarios × tickers × rows) repeated DataFrame filtering.
+    """
+    if scenarios.empty:
+        return {"error": "No scenarios"}
+
+    panel = panel.copy()
+    panel["date"] = pd.to_datetime(panel["date"])
+    has_mcap = "derived_market_cap" in panel.columns
+
+    # Pre-group: store sorted arrays per ticker (avoids repeated filtering)
+    ticker_arrays: dict[str, dict] = {}
+    for ticker, grp in panel.groupby("ticker", sort=False):
+        grp = grp.sort_values("date")
+        td = {
+            "dates": grp["date"].values.astype("int64"),
+            "close": grp["close"].values,
+        }
+        if has_mcap:
+            td["mcap"] = grp["derived_market_cap"].values
+        ticker_arrays[ticker] = td
+
+    # Pre-extract scenario arrays
+    n_sc = len(scenarios)
+    sc_ids = scenarios["scenario_id"].values
+    sc_types = scenarios["event_type"].values if "event_type" in scenarios.columns else [""] * n_sc
+    sc_event_dates = pd.to_datetime(scenarios["event_date"]).values.astype("int64")
+    sc_pre_starts = pd.to_datetime(
+        scenarios.get("pre_window_start", scenarios["event_date"])
+    ).values.astype("int64")
+    sc_post_ends = pd.to_datetime(
+        scenarios.get("post_window_end", scenarios["event_date"])
+    ).values.astype("int64")
+
+    gt_rows = []
+    for ticker, td in ticker_arrays.items():
+        dates = td["dates"]
+        close = td["close"]
+        mcap = td.get("mcap")
+
+        for i in range(n_sc):
+            ev_ns = sc_event_dates[i]
+            pre_ns = sc_pre_starts[i]
+            post_ns = sc_post_ends[i]
+
+            # Pre: last index where pre_start <= date < event_date
+            pre_lo = np.searchsorted(dates, pre_ns, side="left")
+            pre_hi = np.searchsorted(dates, ev_ns, side="left")
+            if pre_hi <= pre_lo:
+                continue
+            pre_idx = pre_hi - 1
+
+            # Post: last index where event_date < date <= post_end
+            post_lo = np.searchsorted(dates, ev_ns, side="right")
+            post_hi = np.searchsorted(dates, post_ns, side="right")
+            if post_hi <= post_lo:
+                continue
+            post_idx = post_hi - 1
+
+            pre_price = float(close[pre_idx])
+            post_price = float(close[post_idx])
+            # Exclude penny-stock data points (pre-event price < $0.50): a
+            # one-cent move at $0.001 produces a 1000% "return" that's
+            # float noise rather than scenario response. The cutoff matches
+            # the SEC's penny-stock threshold and removes ~145 of 4.1M rows
+            # that account for all returns >|10000%|.
+            if pre_price < 0.50:
+                continue
+            price_return = (post_price / pre_price - 1) * 100
+
+            mcap_return = np.nan
+            if mcap is not None:
+                pre_m = float(mcap[pre_idx])
+                post_m = float(mcap[post_idx])
+                if not np.isnan(pre_m) and pre_m > 0:
+                    mcap_return = (post_m / pre_m - 1) * 100
+
+            gt_rows.append({
+                "scenario_id": sc_ids[i],
+                "event_type": sc_types[i],
+                "event_date": str(pd.Timestamp(ev_ns).date()),
+                "ticker": ticker,
+                "actual_return_pct": round(price_return, 3) if not np.isnan(price_return) else None,
+                "actual_mcap_change_pct": round(mcap_return, 3) if not np.isnan(mcap_return) else None,
+                "pre_price": round(pre_price, 2),
+                "post_price": round(post_price, 2),
+            })
+
+    if not gt_rows:
+        return {"error": "No scenario × ticker pairs with data"}
+
+    gt = pd.DataFrame(gt_rows)
+    gt.to_parquet(output_dir / "scenario_forecast_ground_truth.parquet", index=False)
+
+    return {
+        "n_scenarios": gt["scenario_id"].nunique(),
+        "n_tickers": gt["ticker"].nunique(),
+        "n_instances": len(gt),
+        "event_types": gt["event_type"].value_counts().to_dict(),
+    }
+
+
+# ===================================================================
+# Task E: Generator Evaluation (Financial Generation Quality)
+# ===================================================================
+
+# Maps Generator output columns to XBRL ground-truth tag names.
+# The Generator produces columns like "revenue", "net_income", etc.
+# while XBRL ground truth uses US-GAAP tag names like "Revenues",
+# "NetIncomeLoss", etc.  This mapping bridges the two.
+_GENERATOR_TO_XBRL: dict[str, list[str]] = {
+    "revenue": ["Revenues", "RevenueFromContractWithCustomerExcludingAssessedTax", "SalesRevenueNet"],
+    "net_income": ["NetIncomeLoss"],
+    "gross_profit": ["GrossProfit"],
+    "operating_income": ["OperatingIncomeLoss"],
+    "total_assets": ["Assets"],
+    "total_equity": ["StockholdersEquity", "StockholdersEquityIncludingPortionAttributableToNoncontrollingInterest"],
+    "total_debt": ["LongTermDebt", "LongTermDebtNoncurrent"],
+    "cash_and_equivalents": ["CashAndCashEquivalentsAtCarryingValue", "CashCashEquivalentsRestrictedCashAndRestrictedCashEquivalents"],
+    "operating_cash_flow": ["NetCashProvidedByUsedInOperatingActivities"],
+    "capital_expenditure": ["PaymentsToAcquirePropertyPlantAndEquipment"],
+    "interest_expense": ["InterestExpense"],
+    "ebitda": ["EBITDA"],  # often not a direct XBRL tag; may need derivation
+}
+
+
+def _build_task_e(
+    company_info: pd.DataFrame,
+    holdout_tickers: list[str],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task E: evaluate financial generation quality.
+
+    For each holdout ticker, the task is: given only the company's sector,
+    industry, and a text description → generate plausible financial
+    statements.  Ground truth comes from actual XBRL filings.
+
+    This task evaluates the Generator agent's ability to produce realistic
+    financials for an unseen company, measured by per-field MAPE against
+    the latest actual filings.
+
+    The difference from Task B: Task B evaluates any model's field-level
+    predictions using raw XBRL tags.  Task E specifically provides inputs
+    in the format the Generator agent expects (company description, sector)
+    and maps its output columns to XBRL ground truth, so the Generator
+    agent can be directly evaluated.
+    """
+    # Load XBRL company tags (latest values)
+    tags_path = config.XBRL_DIR / "parsed" / "company_tags.parquet"
+    if not tags_path.exists():
+        logger.warning("XBRL company_tags not found; skipping Task E")
+        return {"error": "No XBRL data"}
+
+    tags = pd.read_parquet(tags_path)
+    holdout_tags = tags[tags["ticker"].isin(holdout_tickers)]
+
+    if holdout_tags.empty:
+        return {"error": "No XBRL tags for holdout tickers"}
+
+    # Build inputs: company profile in Generator-compatible format
+    input_rows = []
+    for ticker in holdout_tickers:
+        info_row = company_info[company_info["ticker"] == ticker]
+        if info_row.empty:
+            sector = "Unknown"
+            industry = "Unknown"
+            description = f"A company with ticker {ticker}"
+        else:
+            r = info_row.iloc[0]
+            sector = str(r.get("sector", "Unknown"))
+            industry = str(r.get("industry", "Unknown"))
+            employees = r.get("fullTimeEmployees", "")
+            description = (
+                f"A {sector} company in the {industry} industry"
+                + (f" with approximately {int(employees)} employees" if employees and not pd.isna(employees) else "")
+            )
+
+        input_rows.append({
+            "ticker": ticker,
+            "sector": sector,
+            "industry": industry,
+            "company_description": description,
+        })
+
+    inputs = pd.DataFrame(input_rows)
+
+    # Build ground truth: map XBRL tags to Generator column names
+    gt_rows = []
+    for ticker in holdout_tickers:
+        tk_tags = holdout_tags[holdout_tags["ticker"] == ticker]
+        if tk_tags.empty:
+            continue
+        for gen_col, xbrl_tags in _GENERATOR_TO_XBRL.items():
+            for xbrl_tag in xbrl_tags:
+                match = tk_tags[tk_tags["tag"] == xbrl_tag]
+                if not match.empty:
+                    # Take the latest value
+                    latest = match.sort_values("fiscal_year", ascending=False).iloc[0]
+                    gt_rows.append({
+                        "ticker": ticker,
+                        "generator_field": gen_col,
+                        "xbrl_tag": xbrl_tag,
+                        "value": latest["value"],
+                        "fiscal_year": latest.get("fiscal_year"),
+                        "unit": latest.get("unit", ""),
+                    })
+                    break  # take first matching XBRL tag (priority order)
+
+    if not gt_rows:
+        return {"error": "No matching XBRL tags for Generator fields"}
+
+    gt = pd.DataFrame(gt_rows)
+
+    # Save
+    inputs.to_parquet(output_dir / "generator_eval_inputs.parquet", index=False)
+    gt.to_parquet(output_dir / "generator_eval_ground_truth.parquet", index=False)
+
+    logger.info(
+        "Task E (Generator Eval): %d tickers, %d field-value pairs, %d unique fields",
+        gt["ticker"].nunique(), len(gt), gt["generator_field"].nunique(),
+    )
+
+    return {
+        "n_tickers": gt["ticker"].nunique(),
+        "n_field_value_pairs": len(gt),
+        "n_unique_fields": gt["generator_field"].nunique(),
+        "fields": gt["generator_field"].value_counts().to_dict(),
+    }
+
+
+# ===================================================================
+# Task F: Real Estate Valuation (Rent/Price Estimation)
+# ===================================================================
+
+def _normalise_address(addr: str) -> str:
+    """Normalise an address string for matching: lowercase, strip whitespace."""
+    if not isinstance(addr, str):
+        return ""
+    return " ".join(addr.lower().strip().split())
+
+
+def _merge_rentals(
+    props: pd.DataFrame,
+    rentals: pd.DataFrame,
+) -> pd.DataFrame:
+    """Merge rental data into properties by normalised address or lat/lon proximity.
+
+    For each property row, attempt to find a matching rental listing.
+    Match strategy:
+      1. Exact normalised address match.
+      2. Lat/lon proximity (< 0.0005 degrees, roughly 50 m) for unmatched rows
+         that share the same zip code.
+
+    Returns the properties DataFrame with an added ``rent`` column.
+    """
+    # --- Prepare normalised keys ---
+    props = props.copy()
+    rentals = rentals.copy()
+
+    # Identify the address column in each DataFrame
+    for col in ("formatted_address", "addressLine1", "addressFull", "address"):
+        if col in props.columns:
+            props["_norm_addr"] = props[col].apply(_normalise_address)
+            break
+    else:
+        props["_norm_addr"] = ""
+
+    for col in ("formatted_address", "addressLine1", "addressFull", "address"):
+        if col in rentals.columns:
+            rentals["_norm_addr"] = rentals[col].apply(_normalise_address)
+            break
+    else:
+        rentals["_norm_addr"] = ""
+
+    # Rename the rentals price column to rent
+    rent_price_col = "price"  # rentals.csv uses "price" for monthly rent
+    if rent_price_col not in rentals.columns:
+        logger.warning("rentals.csv has no 'price' column; no rent data to merge")
+        props["rent"] = np.nan
+        props.drop(columns=["_norm_addr"], inplace=True)
+        return props
+
+    rentals["rent"] = pd.to_numeric(rentals[rent_price_col], errors="coerce")
+
+    # De-duplicate rentals: keep first (latest listing) per normalised address
+    rentals_dedup = (
+        rentals[rentals["_norm_addr"] != ""]
+        .drop_duplicates(subset=["_norm_addr"], keep="first")
+    )
+
+    # --- Strategy 1: exact normalised address merge ---
+    rent_lookup = rentals_dedup.set_index("_norm_addr")["rent"]
+    props["rent"] = props["_norm_addr"].map(rent_lookup)
+
+    n_addr_matched = props["rent"].notna().sum()
+    logger.info("Task F rent merge: %d/%d matched by address", n_addr_matched, len(props))
+
+    # --- Strategy 2: lat/lon proximity for unmatched rows ---
+    unmatched_mask = props["rent"].isna()
+    has_coords_props = (
+        unmatched_mask
+        & props.get("latitude", pd.Series(dtype=float)).notna()
+        & props.get("longitude", pd.Series(dtype=float)).notna()
+    )
+
+    if has_coords_props.any() and "latitude" in rentals.columns and "longitude" in rentals.columns:
+        # Build a lookup of rentals by zip for faster spatial matching
+        zip_col_r = "zip_code" if "zip_code" in rentals.columns else None
+        zip_col_p = "zip_code" if "zip_code" in props.columns else None
+
+        rentals_with_coords = rentals[
+            rentals["latitude"].notna() & rentals["longitude"].notna() & rentals["rent"].notna()
+        ].copy()
+
+        if not rentals_with_coords.empty and zip_col_r and zip_col_p:
+            rental_groups = {
+                z: grp[["latitude", "longitude", "rent"]].values
+                for z, grp in rentals_with_coords.groupby(zip_col_r)
+            }
+
+            proximity_threshold = 0.0005  # ~50 m
+
+            for idx in props.index[has_coords_props]:
+                z = props.at[idx, zip_col_p] if zip_col_p else None
+                if z not in rental_groups:
+                    continue
+                candidates = rental_groups[z]  # shape (N, 3): lat, lon, rent
+                dlat = candidates[:, 0] - props.at[idx, "latitude"]
+                dlon = candidates[:, 1] - props.at[idx, "longitude"]
+                dist = np.sqrt(dlat ** 2 + dlon ** 2)
+                best = np.argmin(dist)
+                if dist[best] < proximity_threshold:
+                    props.at[idx, "rent"] = candidates[best, 2]
+
+        n_geo_matched = props["rent"].notna().sum() - n_addr_matched
+        logger.info("Task F rent merge: %d additional matched by lat/lon proximity", n_geo_matched)
+
+    props.drop(columns=["_norm_addr"], inplace=True)
+    return props
+
+
+def _build_task_f(
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task F: evaluate real estate rent and price estimation.
+
+    Uses collected RentCast data as ground truth.  Loads both
+    ``properties.csv`` (sale prices) and ``rentals.csv`` (monthly rents),
+    merges them by normalised address (with lat/lon proximity fallback),
+    and produces a combined dataset with both ``price`` and ``rent``
+    target columns.
+
+    For each property the task is: given location (metro), property type,
+    size (sqft, beds, baths), and year built, predict rent and/or price.
+
+    The holdout is a random 30 % of combined properties (seeded).
+    Training properties serve as the comps database.
+    """
+    properties_path = config.REAL_ESTATE_DIR / "properties.csv"
+    rentals_path = config.REAL_ESTATE_DIR / "rentals.csv"
+
+    if not properties_path.exists() and not rentals_path.exists():
+        logger.warning("Neither properties.csv nor rentals.csv found; skipping Task F")
+        return {"error": "No real estate data"}
+
+    # ------------------------------------------------------------------
+    # 1. Load and standardise properties (sale price data)
+    # ------------------------------------------------------------------
+    if properties_path.exists():
+        props = pd.read_csv(properties_path)
+    else:
+        props = pd.DataFrame()
+
+    _rename_priority = [
+        ("square_footage", "sqft"),
+        ("squareFootage", "sqft"),
+        ("propertyType", "property_type"),
+        ("yearBuilt", "year_built"),
+        ("last_sale_price", "price"),
+        ("lastSalePrice", "price"),
+        ("zipCode", "zip_code"),
+        ("lotSize", "lot_size"),
+        # Address: prefer formatted_address > addressLine1
+        ("formatted_address", "address"),
+        ("addressLine1", "address"),
+        ("addressFull", "address"),
+    ]
+    for old_name, new_name in _rename_priority:
+        if old_name in props.columns and new_name not in props.columns:
+            props = props.rename(columns={old_name: new_name})
+
+    # Ensure numeric price
+    if "price" in props.columns:
+        props["price"] = pd.to_numeric(props["price"], errors="coerce")
+        # Remove non-positive prices (data errors)
+        neg_price = props["price"] <= 0
+        if neg_price.any():
+            logger.info("Task F: removing %d rows with non-positive price", neg_price.sum())
+            props = props[~neg_price | props["price"].isna()]
+
+    # Deduplicate by address (keep first occurrence)
+    if "address" in props.columns:
+        before = len(props)
+        props = props.drop_duplicates(subset=["address"], keep="first")
+        deduped = before - len(props)
+        if deduped > 0:
+            logger.info("Task F: deduplicated %d rows by address", deduped)
+
+    # ------------------------------------------------------------------
+    # 2. Load rentals and merge rent into properties
+    # ------------------------------------------------------------------
+    if rentals_path.exists():
+        rentals_raw = pd.read_csv(rentals_path)
+        if not rentals_raw.empty:
+            # Standardise rental column names the same way
+            for old_name, new_name in _rename_priority:
+                if old_name in rentals_raw.columns and new_name not in rentals_raw.columns:
+                    rentals_raw = rentals_raw.rename(columns={old_name: new_name})
+
+            if not props.empty:
+                props = _merge_rentals(props, rentals_raw)
+            else:
+                # No properties file -- use rentals as the base
+                props = rentals_raw.copy()
+                props["rent"] = pd.to_numeric(props.get("price", pd.Series(dtype=float)), errors="coerce")
+                props["price"] = np.nan  # no sale price available
+
+            # Append rental-only rows (addresses not already in props)
+            if not props.empty and "address" in props.columns:
+                existing_addrs = set(props["address"].apply(_normalise_address))
+                if "address" in rentals_raw.columns:
+                    rentals_raw["_norm_addr"] = rentals_raw["address"].apply(_normalise_address)
+                    new_rentals = rentals_raw[~rentals_raw["_norm_addr"].isin(existing_addrs)].copy()
+                    new_rentals.drop(columns=["_norm_addr"], inplace=True)
+                    if not new_rentals.empty:
+                        new_rentals["rent"] = pd.to_numeric(
+                            new_rentals.get("price", pd.Series(dtype=float)), errors="coerce",
+                        )
+                        # Avoid column clash: rentals "price" is rent, not sale price
+                        if "price" in new_rentals.columns:
+                            new_rentals = new_rentals.drop(columns=["price"])
+                        new_rentals["price"] = np.nan  # no sale price for rental-only rows
+                        props = pd.concat([props, new_rentals], ignore_index=True)
+                        logger.info("Task F: appended %d rental-only rows", len(new_rentals))
+    else:
+        # No rentals file -- price-only (existing behaviour)
+        props["rent"] = np.nan
+
+    if props.empty:
+        return {"error": "Empty real estate data after merge"}
+
+    # Ensure rent column exists
+    if "rent" not in props.columns:
+        props["rent"] = np.nan
+
+    # ------------------------------------------------------------------
+    # 3. Filter to properties with at least one target (rent or price)
+    # ------------------------------------------------------------------
+    props = props.dropna(subset=["price", "rent"], how="all")
+
+    if len(props) < 10:
+        return {"error": f"Too few properties with rent/price data ({len(props)})"}
+
+    # ------------------------------------------------------------------
+    # 3b. Per-property TIME-AXIS features
+    # ------------------------------------------------------------------
+    # Each property in the RentCast snapshot carries a `last_sale_date`
+    # (when it last changed hands). This timestamp is the per-property
+    # historical observation that gives T7 a time axis even though the
+    # train/test split itself is geographic (by address). Methods can use
+    # `last_sale_date` and `years_since_last_sale` as features alongside
+    # static attributes.
+    SCRAPE_DATE = pd.Timestamp("2026-04-11", tz="UTC")
+    if "last_sale_date" in props.columns:
+        props["last_sale_date"] = pd.to_datetime(
+            props["last_sale_date"], errors="coerce", utc=True,
+        )
+        props["years_since_last_sale"] = (
+            (SCRAPE_DATE - props["last_sale_date"]).dt.total_seconds() / (365.25 * 86400)
+        )
+
+    # ------------------------------------------------------------------
+    # 4. Address-holdout 70/30 split (seeded). T7 is a static valuation
+    #    task -- the OOD signal is across properties, not across time --
+    #    so the train/test cutoff is geographic. The time axis lives in
+    #    the per-property features added in step 3b.
+    # ------------------------------------------------------------------
+    rng = np.random.RandomState(config.BENCHMARK_SEED)
+    holdout_mask = rng.random(len(props)) < 0.3
+    train_props = props[~holdout_mask].copy()
+    test_props = props[holdout_mask].copy()
+
+    # ------------------------------------------------------------------
+    # 5. Build inputs and ground truth
+    # ------------------------------------------------------------------
+    input_candidates = [
+        "address", "city", "state", "zip_code",
+        "property_type", "bedrooms", "bathrooms", "sqft",
+        "lotSize", "lot_size", "year_built", "county",
+        "latitude", "longitude",
+        # Per-property time-axis features (Option B: time-aware features
+        # alongside the static attributes; address-holdout split):
+        "last_sale_date", "years_since_last_sale",
+    ]
+    input_cols = [c for c in input_candidates if c in test_props.columns]
+    inputs = test_props[input_cols].copy()
+
+    # Ground truth: address + both targets
+    gt_cols = []
+    if "address" in test_props.columns:
+        gt_cols.append("address")
+    gt_cols.extend(["price", "rent"])
+    gt = test_props[gt_cols].copy()
+
+    # ------------------------------------------------------------------
+    # 6. Save
+    # ------------------------------------------------------------------
+    train_props.to_parquet(output_dir / "re_train_properties.parquet", index=False)
+    inputs.to_parquet(output_dir / "re_eval_inputs.parquet", index=False)
+    gt.to_parquet(output_dir / "re_eval_ground_truth.parquet", index=False)
+
+    n_price = gt["price"].notna().sum()
+    n_rent = gt["rent"].notna().sum()
+    n_both = (gt["price"].notna() & gt["rent"].notna()).sum()
+
+    logger.info(
+        "Task F (RE Eval): %d train, %d test; price=%d, rent=%d, both=%d",
+        len(train_props), len(test_props), n_price, n_rent, n_both,
+    )
+
+    return {
+        "n_train": len(train_props),
+        "n_test": len(test_props),
+        "n_price": int(n_price),
+        "n_rent": int(n_rent),
+        "n_both": int(n_both),
+        "target_cols": ["price", "rent"],
+        "input_cols": input_cols,
+    }
+
+
+# ===================================================================
+# Task D: Private Company Valuation (PE Simulation)
+# ===================================================================
+
+# Columns derived from market price — must be stripped for private-company
+# simulation because a PE analyst would not have access to market data.
+_PRICE_DERIVED_COLS = {
+    "derived_market_cap", "derived_pe", "derived_ev", "derived_ev_to_revenue",
+    "derived_ev_to_ebitda", "derived_fcf_yield", "derived_pb",
+    "derived_price_to_book", "derived_debt_to_equity",
+    "close", "open", "high", "low", "volume", "adj_close",
+    "shares_outstanding",
+}
+
+
+def _build_task_d(
+    panel: pd.DataFrame,
+    company_info: pd.DataFrame,
+    holdout_tickers: list[str],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Build Task D: value an unseen company as if it were private.
+
+    Simulates the PE use case: the model trains on public companies where
+    all data (including market price) is available, but at test time it
+    receives ONLY what a PE analyst would have — financial statements,
+    sector, and industry.  All price-derived columns are stripped from
+    the test inputs.
+
+    Same holdout tickers and ground truth as Task A, different input
+    columns.
+    """
+    if "derived_market_cap" not in panel.columns:
+        logger.warning("derived_market_cap not in panel; skipping Task D")
+        return {"error": "No market cap data"}
+
+    # Use panel data at quarterly frequency
+    quarterly = panel.copy()
+    quarterly["date"] = pd.to_datetime(quarterly["date"])
+    quarterly["quarter"] = quarterly["date"].dt.to_period("Q")
+
+    # Take last observation per ticker × quarter
+    quarterly = quarterly.sort_values("date").drop_duplicates(
+        subset=["ticker", "quarter"], keep="last",
+    )
+
+    # Split: holdout tickers = evaluation
+    eval_mask = quarterly["ticker"].isin(holdout_tickers)
+    eval_df = quarterly[eval_mask].copy()
+
+    if eval_df.empty:
+        return {"error": "No holdout tickers found in panel"}
+
+    # Build inputs — ONLY what a PE analyst would have (no market data)
+    input_cols = ["ticker", "date", "sector", "industry"]
+    for c in quarterly.columns:
+        if c.startswith("stmt_"):
+            input_cols.append(c)
+        # Include non-price-derived fundamentals (e.g. derived_effective_tax_rate,
+        # derived_cost_of_debt, derived_beta, derived_wacc are computable from
+        # financial statements + macro data without market price — but beta and
+        # wacc require stock returns, so strip them too for a clean PE simulation)
+    input_cols = [c for c in input_cols if c in eval_df.columns
+                  and c not in _PRICE_DERIVED_COLS]
+    inputs = eval_df[input_cols].copy()
+
+    # Ground truth — same as Task A
+    gt = eval_df[["ticker", "date", "derived_market_cap"]].copy()
+    gt = gt.rename(columns={"derived_market_cap": "actual_market_cap"})
+    gt = gt.dropna(subset=["actual_market_cap"])
+
+    # Save
+    inputs.to_parquet(output_dir / "private_valuation_inputs.parquet", index=False)
+    gt.to_parquet(output_dir / "private_valuation_ground_truth.parquet", index=False)
+
+    logger.info(
+        "Task D (Private Valuation): %d tickers, %d instances, %d input cols (no price data)",
+        gt["ticker"].nunique(), len(gt), len(input_cols),
+    )
+
+    return {
+        "n_tickers": gt["ticker"].nunique(),
+        "n_instances": len(gt),
+        "n_input_cols": len(input_cols),
+        "input_cols": input_cols,
+        "date_range": [str(gt["date"].min()), str(gt["date"].max())],
+    }
+
+
+# ===================================================================
+# Main entry point
+# ===================================================================
+
+def build_valuation_benchmark(
+    granularity: str = "daily",
+) -> dict[str, Any]:
+    """Build all valuation benchmark artifacts for a given granularity.
+
+    Reads from existing processed panel and benchmark data.
+    Writes to ``benchmark/{granularity}/``.
+
+    Returns summary dict with per-task statistics.
+    """
+    bench_dir = config.get_benchmark_dir(granularity)
+    bench_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load existing data
+    proc_dir = config.get_processed_dir(granularity)
+    panel_path = proc_dir / "panel.parquet"
+    if not panel_path.exists():
+        # Try CSV fallback
+        panel_path = proc_dir / "panel.csv"
+    if not panel_path.exists():
+        return {"error": f"No panel data at {proc_dir}"}
+
+    panel = pd.read_parquet(panel_path) if panel_path.suffix == ".parquet" else pd.read_csv(panel_path)
+
+    # Company info
+    info_path = config.FUNDAMENTALS_DIR / "company_info.csv"
+    company_info = pd.read_csv(info_path) if info_path.exists() else pd.DataFrame()
+
+    # Scenarios
+    scenarios_path = bench_dir / "scenarios.parquet"
+    scenarios = pd.read_parquet(scenarios_path) if scenarios_path.exists() else pd.DataFrame()
+
+    # Holdout tickers (random subset, seeded for reproducibility)
+    all_tickers = sorted(panel["ticker"].unique().tolist())
+    rng = np.random.RandomState(config.BENCHMARK_SEED)
+    n_holdout = max(1, int(len(all_tickers) * config.VALUATION_HOLDOUT_RATIO))
+    holdout_tickers = rng.choice(all_tickers, size=n_holdout, replace=False).tolist()
+
+    logger.info(
+        "Building valuation benchmark: %d total tickers, %d holdout",
+        len(all_tickers), len(holdout_tickers),
+    )
+
+    # Build each task
+    summary: dict[str, Any] = {
+        "granularity": granularity,
+        "n_tickers_total": len(all_tickers),
+        "n_holdout": len(holdout_tickers),
+        "holdout_tickers": holdout_tickers,
+    }
+
+    summary["task_a"] = _build_task_a(panel, company_info, holdout_tickers, bench_dir)
+    summary["task_b"] = _build_task_b(company_info, holdout_tickers, bench_dir)
+    summary["task_c"] = _build_task_c(panel, scenarios, bench_dir)
+    summary["task_d"] = _build_task_d(panel, company_info, holdout_tickers, bench_dir)
+    summary["task_e"] = _build_task_e(company_info, holdout_tickers, bench_dir)
+    summary["task_f"] = _build_task_f(bench_dir)
+
+    # Task definition JSON
+    task_def = {
+        "benchmark_name": "whatif_valuation_v1",
+        "tasks": {
+            "A_valuation_accuracy": {
+                "description": "Estimate intrinsic equity value of public companies",
+                "input": "valuation_inputs.parquet",
+                "ground_truth": "valuation_ground_truth.parquet",
+                "metrics": ["MAPE", "median_APE", "rank_correlation", "directional_accuracy"],
+                "primary_metric": "MAPE",
+                "target_col": "actual_market_cap",
+            },
+            "B_statement_generation": {
+                "description": "Generate plausible financial statements from company description",
+                "input": "generation_inputs.parquet",
+                "ground_truth": "generation_ground_truth.parquet",
+                "metrics": ["per_field_MAPE", "balance_equation_accuracy", "ontology_compliance"],
+                "primary_metric": "per_field_MAPE",
+            },
+            "C_scenario_forecast": {
+                "description": "Forecast financial impact of what-if scenarios",
+                "input": "scenarios.parquet",
+                "ground_truth": "scenario_forecast_ground_truth.parquet",
+                "metrics": ["return_MAE", "directional_accuracy", "CI_calibration"],
+                "primary_metric": "return_MAE",
+            },
+            "D_private_valuation": {
+                "description": "Value an unseen company using only financials + sector (PE simulation)",
+                "input": "private_valuation_inputs.parquet",
+                "ground_truth": "private_valuation_ground_truth.parquet",
+                "metrics": ["MAPE", "median_APE", "rank_correlation", "directional_accuracy"],
+                "primary_metric": "median_APE",
+                "target_col": "actual_market_cap",
+                "note": "Same holdout tickers as Task A but all price-derived columns stripped from inputs",
+            },
+            "E_generator_evaluation": {
+                "description": "Generate financial statements for unseen companies and compare to actual XBRL filings",
+                "input": "generator_eval_inputs.parquet",
+                "ground_truth": "generator_eval_ground_truth.parquet",
+                "metrics": ["per_field_MAPE", "balance_equation_accuracy"],
+                "primary_metric": "per_field_MAPE",
+                "note": "Evaluates the Generator agent's output against actual company financials",
+            },
+            "F_real_estate_valuation": {
+                "description": "Estimate rent and price for unseen properties given location and features",
+                "input": "re_eval_inputs.parquet",
+                "ground_truth": "re_eval_ground_truth.parquet",
+                "train_data": "re_train_properties.parquet",
+                "metrics": ["rent_MAPE", "price_MAPE"],
+                "primary_metric": "rent_MAPE",
+                "note": "70/30 random split of RentCast properties; train set serves as comps database",
+            },
+        },
+        "holdout_tickers": holdout_tickers,
+    }
+    (bench_dir / "valuation_tasks.json").write_text(
+        json.dumps(task_def, indent=2, default=str),
+    )
+
+    logger.info("Valuation benchmark complete: %s", summary)
+    return summary

code/collect_filings.py

@@ -0,0 +1,425 @@
+"""Step 4: Download SEC filings (PDF + Markdown) and XBRL company facts.
+
+Uses:
+  - SecEdgarDownloader  from projects.tools.sec_edgar.downloader
+  - playwright.html_to_pdf  from projects.tools.utils.playwright
+  - html2text (project dependency) for HTML -> Markdown conversion
+  - SEC XBRL CompanyFacts API for structured financial data
+
+Pipeline per ticker:
+  1. Resolve CIK (direct ticker lookup, then fuzzy match by company name)
+  2. Download HTML filings to a temp dir via SecEdgarDownloader.download()
+  3. Convert HTML -> PDF via playwright.html_to_pdf()  (human-readable)
+  4. Convert HTML -> Markdown via html2text              (LLM-friendly)
+  5. Download XBRL company facts JSON from SEC CompanyFacts API
+
+CIK resolution strategy (every US-listed company MUST have a CIK):
+  1. Direct ticker → CIK lookup via SEC company_tickers.json
+  2. If that fails, fuzzy match by company name via SEC company_tickers_exchange.json
+  3. Only if both fail is the ticker skipped (logged as warning)
+
+Parallel tickers via asyncio.Semaphore.
+
+Output:
+  data/filings/{TICKER}/*.pdf       -- human-readable PDFs
+  data/filings/{TICKER}/*.md        -- LLM-friendly Markdown
+  data/xbrl/raw/{TICKER}.json       -- structured XBRL facts
+  data/xbrl/cik_map.json            -- ticker → CIK mapping
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import tempfile
+from pathlib import Path
+
+import html2text
+import httpx
+import pandas as pd
+from bs4 import BeautifulSoup
+
+from projects.tools.sec_edgar.downloader import SecEdgarDownloader
+from projects.tools.utils.playwright import html_to_pdf
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+# Shared html2text converter configuration
+_h2t = html2text.HTML2Text()
+_h2t.ignore_links = False
+_h2t.ignore_images = True
+_h2t.body_width = 0  # no line wrapping -- let the consumer handle it
+_h2t.protect_links = True
+_h2t.wrap_links = False
+
+# Inline XBRL tag names to strip (they contain machine-readable noise)
+_XBRL_STRIP_TAGS = ["ix:header", "ix:hidden"]
+
+
+def _html_to_markdown(html_path: Path, md_path: Path) -> None:
+    """Convert an SEC filing HTML directly to Markdown using html2text.
+
+    Strips inline XBRL metadata (ix:header, ix:hidden) before conversion
+    so the resulting Markdown contains only the human-readable filing text.
+    """
+    html_content = html_path.read_text(encoding="utf-8", errors="replace")
+    soup = BeautifulSoup(html_content, "html.parser")
+    for tag_name in _XBRL_STRIP_TAGS:
+        for tag in soup.find_all(tag_name):
+            tag.decompose()
+    markdown_text: str = _h2t.handle(str(soup))
+    _ = md_path.write_text(markdown_text, encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# XBRL Company Facts helpers
+# ---------------------------------------------------------------------------
+
+_XBRL_RAW_DIR = config.XBRL_DIR / "raw"
+
+
+def _atomic_json_write(data: dict, dest: Path) -> None:
+    """Write JSON atomically (tempfile + os.replace)."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(suffix=".json", dir=dest.parent)
+    try:
+        os.close(fd)
+        with open(tmp, "w", encoding="utf-8") as fh:
+            json.dump(data, fh, ensure_ascii=False)
+        os.replace(tmp, dest)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+async def _resolve_cik_map(
+    client: httpx.AsyncClient,
+    tickers: list[str],
+) -> dict[str, str]:
+    """Build ticker → zero-padded CIK mapping (single API call, cached)."""
+    url = "https://www.sec.gov/files/company_tickers.json"
+    resp = await client.get(url)
+    resp.raise_for_status()
+    await asyncio.sleep(0.1)
+
+    raw: dict = resp.json()
+    sec_map: dict[str, str] = {}
+    for entry in raw.values():
+        t = str(entry.get("ticker", "")).upper()
+        cik = str(entry.get("cik_str", ""))
+        if t and cik:
+            sec_map[t] = cik.zfill(10)
+
+    result: dict[str, str] = {}
+    missing: list[str] = []
+    for ticker in tickers:
+        cik = sec_map.get(ticker.upper())
+        if cik:
+            result[ticker] = cik
+        else:
+            missing.append(ticker)
+
+    if missing:
+        logger.info(
+            "CIK map: %d resolved, %d missing (will try fuzzy match during filing download)",
+            len(result), len(missing),
+        )
+    return result
+
+
+async def _download_xbrl_facts(
+    client: httpx.AsyncClient,
+    ticker: str,
+    cik: str,
+) -> bool:
+    """Download one company's XBRL facts JSON.  Returns True on success."""
+    dest = _XBRL_RAW_DIR / f"{ticker}.json"
+    if dest.exists() and dest.stat().st_size > 100:
+        return True  # already collected
+
+    url = config.XBRL_COMPANY_FACTS_URL.format(cik=cik)
+
+    for attempt in range(3):
+        try:
+            resp = await client.get(url)
+            if resp.status_code == 404:
+                _atomic_json_write(
+                    {"_no_xbrl": True, "cik": cik, "ticker": ticker}, dest,
+                )
+                return True
+
+            resp.raise_for_status()
+            _atomic_json_write(resp.json(), dest)
+            return True
+
+        except httpx.HTTPStatusError as exc:
+            if exc.response.status_code == 429:
+                await asyncio.sleep(2 ** (attempt + 1))
+            elif exc.response.status_code >= 500:
+                await asyncio.sleep(2 ** attempt)
+            else:
+                logger.warning("XBRL HTTP %d for %s", exc.response.status_code, ticker)
+                return False
+        except (httpx.ConnectError, httpx.ReadTimeout):
+            await asyncio.sleep(2 ** attempt)
+
+    logger.warning("XBRL download failed for %s after 3 attempts", ticker)
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Filing download helpers
+# ---------------------------------------------------------------------------
+
+_MAX_RETRIES = 3
+
+
+async def _retry_async(coro_factory, description: str, retries: int = _MAX_RETRIES):
+    """Call *coro_factory()* up to *retries* times with exponential backoff.
+
+    ValueError is never retried (it signals a deterministic failure like
+    missing CIK, not a transient network issue).
+    """
+    for attempt in range(retries):
+        try:
+            return await coro_factory()
+        except ValueError:
+            raise  # deterministic – retrying won't help
+        except Exception as exc:
+            if attempt < retries - 1:
+                wait = 2 ** attempt * 3  # 3s, 6s, 12s
+                logger.warning("%s failed (attempt %d/%d), retrying in %ds: %s",
+                               description, attempt + 1, retries, wait, exc)
+                await asyncio.sleep(wait)
+            else:
+                raise
+
+
+async def _download_with_fallback(
+    ticker: str,
+    company_name: str,
+    downloader: SecEdgarDownloader,
+    output_dir: Path,
+) -> list[Path]:
+    """Download filings, falling back to CIK-by-company-name if ticker lookup fails.
+
+    Every US-listed company has a CIK.  The direct ticker→CIK map sometimes
+    misses tickers (recent renames, class shares, etc.), so we fall back to
+    fuzzy-matching the company name against the SEC title database.
+    """
+    try:
+        return await downloader.download(
+            ticker=ticker,
+            filing_types=config.SEC_FILING_TYPES,  # type: ignore[arg-type]
+            from_year=config.START_YEAR,
+            to_year=config.END_YEAR,
+            output_dir=output_dir,
+        )
+    except ValueError:
+        pass  # ticker not in CIK map – try fallback
+
+    if not company_name:
+        raise ValueError(f"Ticker {ticker} not in SEC CIK map and no company name for fallback.")
+
+    logger.info("%s: ticker lookup failed, trying fuzzy match for '%s' ...", ticker, company_name)
+    matches = await downloader.score_title_fuzzy_match(company_name)
+    if not matches:
+        raise ValueError(f"Ticker {ticker}: no fuzzy matches for '{company_name}'.")
+
+    best = matches[0]
+    if best.score < 60:
+        raise ValueError(
+            f"Ticker {ticker}: best fuzzy match '{best.title}' (CIK={best.cik}) "
+            f"scored only {best.score:.0f} – too low to trust."
+        )
+
+    logger.info("%s: fuzzy matched → '%s' (CIK=%s, score=%.0f)", ticker, best.title, best.cik, best.score)
+    return await downloader.download(
+        cik=best.cik,
+        filing_types=config.SEC_FILING_TYPES,  # type: ignore[arg-type]
+        from_year=config.START_YEAR,
+        to_year=config.END_YEAR,
+        output_dir=output_dir,
+    )
+
+
+async def _download_ticker_filings(
+    ticker: str,
+    company_name: str,
+    downloader: SecEdgarDownloader,
+    semaphore: asyncio.Semaphore,
+    xbrl_client: httpx.AsyncClient | None = None,
+    cik: str | None = None,
+) -> int:
+    """Download filings + XBRL for a single ticker.  Returns number of filings processed."""
+    ticker_dir = config.FILINGS_DIR / ticker
+    done_flag = ticker_dir / ".done"
+    filings_done = done_flag.exists()
+
+    xbrl_path = _XBRL_RAW_DIR / f"{ticker}.json"
+    xbrl_done = xbrl_path.exists() and xbrl_path.stat().st_size > 100
+
+    if filings_done and xbrl_done:
+        return 0  # everything already done
+
+    async with semaphore:
+        filing_count = 0
+
+        # ── Filing documents (PDF + Markdown) ─────────────────────────
+        if not filings_done:
+            logger.info("Downloading filings for %s ...", ticker)
+            ticker_dir.mkdir(parents=True, exist_ok=True)
+            all_conversions_ok = True
+
+            try:
+                with tempfile.TemporaryDirectory(prefix="whatif_sec_") as tmpdir:
+                    tmpdir_path = Path(tmpdir)
+                    html_paths = await _retry_async(
+                        lambda: _download_with_fallback(
+                            ticker, company_name, downloader, tmpdir_path,
+                        ),
+                        description=f"SEC download {ticker}",
+                    )
+
+                    for htm_path in html_paths:
+                        base_name = htm_path.parent.name
+                        pdf_path = ticker_dir / (base_name + ".pdf")
+                        md_path = ticker_dir / (base_name + ".md")
+
+                        # HTML -> PDF (human-readable; skip if already exists)
+                        if not pdf_path.exists():
+                            try:
+                                await _retry_async(
+                                    lambda _h=htm_path, _p=pdf_path: html_to_pdf(_h, _p),
+                                    description=f"PDF {ticker}/{htm_path.name}",
+                                )
+                            except Exception as exc:
+                                logger.warning("PDF conversion failed for %s/%s after retries: %s",
+                                               ticker, htm_path.name, exc)
+                                all_conversions_ok = False
+
+                        # HTML -> Markdown (LLM-friendly; skip if already exists)
+                        if not md_path.exists():
+                            try:
+                                _html_to_markdown(htm_path, md_path)
+                            except Exception as exc:
+                                logger.warning("Markdown conversion failed for %s/%s: %s",
+                                               ticker, htm_path.name, exc)
+                                all_conversions_ok = False
+
+                        filing_count += 1
+
+                # Only mark as done if ALL conversions succeeded
+                if all_conversions_ok:
+                    _ = done_flag.write_text(f"filings={filing_count}")
+                logger.info("%s: %d filings processed (PDF + MD).%s",
+                            ticker, filing_count,
+                            "" if all_conversions_ok else " (some conversions failed, will retry)")
+            except ValueError as exc:
+                logger.warning("Ticker %s: CIK resolution failed after all strategies: %s", ticker, exc)
+            except Exception as exc:
+                logger.warning("Filing download failed for %s: %s", ticker, exc)
+
+        # ── XBRL company facts ────────────────────────────────────────
+        if not xbrl_done and xbrl_client is not None and cik:
+            try:
+                await _download_xbrl_facts(xbrl_client, ticker, cik)
+            except Exception as exc:
+                logger.warning("XBRL download failed for %s: %s", ticker, exc)
+
+    return filing_count
+
+
+def _load_company_names() -> dict[str, str]:
+    """Load ticker → company name mapping from the universe CSV."""
+    univ_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+    if not univ_path.exists():
+        return {}
+    df = pd.read_csv(univ_path)
+    if "ticker" in df.columns and "name" in df.columns:
+        return dict(zip(df["ticker"], df["name"].fillna("")))
+    return {}
+
+
+async def run_async(tickers: list[str] | None = None) -> dict[str, int]:
+    """Execute Step 4 (async): download filings + XBRL facts.
+
+    Returns ``{ticker: filing_count}``.
+    """
+    config.FILINGS_DIR.mkdir(parents=True, exist_ok=True)
+    _XBRL_RAW_DIR.mkdir(parents=True, exist_ok=True)
+
+    user_agent = os.getenv("SEC_EDGAR_USER_AGENT")
+    if not user_agent:
+        raise ValueError("Set SEC_EDGAR_USER_AGENT environment variable.")
+
+    if tickers is None:
+        universe_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+        if not universe_path.exists():
+            raise FileNotFoundError(f"Run Step 1 first: {universe_path}")
+        tickers = pd.read_csv(universe_path)["ticker"].tolist()
+
+    # Load company names for CIK fuzzy-match fallback
+    company_names = _load_company_names()
+
+    # Resolve CIK map for XBRL (single API call, reused across all tickers)
+    headers = {"User-Agent": user_agent, "Accept-Encoding": "gzip, deflate"}
+    async with httpx.AsyncClient(
+        headers=headers, timeout=30.0, follow_redirects=True,
+    ) as xbrl_client:
+        cik_map = await _resolve_cik_map(xbrl_client, tickers)
+
+        # Persist CIK map for reference
+        cik_map_path = config.XBRL_DIR / "cik_map.json"
+        config.XBRL_DIR.mkdir(parents=True, exist_ok=True)
+        _atomic_json_write(cik_map, cik_map_path)
+
+        logger.info(
+            "Downloading SEC filings + XBRL for %d tickers "
+            "(%d with company names, %d with CIK) ...",
+            len(tickers), len(company_names), len(cik_map),
+        )
+
+        downloader = SecEdgarDownloader(user_agent=user_agent)
+        semaphore = asyncio.Semaphore(config.SEC_FILING_WORKERS)
+
+        tasks = [
+            _download_ticker_filings(
+                t,
+                company_names.get(t, ""),
+                downloader,
+                semaphore,
+                xbrl_client=xbrl_client,
+                cik=cik_map.get(t),
+            )
+            for t in tickers
+        ]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    summary: dict[str, int] = {}
+    for ticker, result in zip(tickers, results):
+        if isinstance(result, BaseException):
+            logger.warning("Ticker %s raised: %s", ticker, result)
+            summary[ticker] = 0
+        else:
+            summary[ticker] = result
+
+    total = sum(summary.values())
+    xbrl_count = sum(1 for f in _XBRL_RAW_DIR.glob("*.json") if f.stat().st_size > 100)
+    logger.info(
+        "SEC Step 4 complete: %d filings across %d tickers, %d XBRL facts downloaded.",
+        total, len(tickers), xbrl_count,
+    )
+    return summary
+
+
+def run(tickers: list[str] | None = None) -> dict[str, int]:
+    """Sync wrapper around the async implementation."""
+    return asyncio.run(run_async(tickers))

code/collect_fundamentals.py

@@ -0,0 +1,164 @@
+"""Step 2: Collect company fundamentals.
+
+For each ticker in the universe: yfinance .info (PE, EPS, margins, ROE,
+ROA, market cap, revenue, EBITDA) and quarterly financial statements
+(quarterly_income_stmt, quarterly_balance_sheet, quarterly_cashflow).
+
+Processes tickers sequentially with a mandatory delay between requests
+to stay under yfinance rate limits.  Includes retry with exponential
+backoff on rate-limit errors.
+
+Output:
+  data/fundamentals/company_info.csv         -- summary info per ticker
+  data/fundamentals/{TICKER}_income.csv      -- quarterly income statement
+  data/fundamentals/{TICKER}_balance.csv     -- quarterly balance sheet
+  data/fundamentals/{TICKER}_cashflow.csv    -- quarterly cash flow statement
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import yfinance as yf
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+# Fields to pull from yfinance Ticker.info
+INFO_FIELDS = [
+    "marketCap",
+    "trailingPE",
+    "forwardPE",
+    "trailingEps",
+    "forwardEps",
+    "priceToSalesTrailing12Months",
+    "priceToBook",
+    "enterpriseValue",
+    "enterpriseToRevenue",
+    "enterpriseToEbitda",
+    "profitMargins",
+    "operatingMargins",
+    "grossMargins",
+    "returnOnEquity",
+    "returnOnAssets",
+    "debtToEquity",
+    "totalRevenue",
+    "revenueGrowth",
+    "ebitda",
+    "totalDebt",
+    "totalCash",
+    "freeCashflow",
+    "operatingCashflow",
+    "sector",
+    "industry",
+    "fullTimeEmployees",
+]
+
+
+def _collect_single_ticker(ticker: str, out_dir: Path, max_retries: int = 3) -> dict[str, Any] | None:
+    """Collect info + statements for one ticker.  Returns info dict or None."""
+    info_path = out_dir / f"{ticker}_info_done.flag"
+    if info_path.exists():
+        return None  # already collected
+
+    info = None
+    for attempt in range(max_retries):
+        try:
+            t = yf.Ticker(ticker)
+            info = t.info
+            break
+        except Exception as exc:
+            err_str = str(exc)
+            if "Too Many Requests" in err_str or "Rate" in err_str:
+                wait = 2 ** attempt * 5  # 5s, 10s, 20s
+                time.sleep(wait)
+                continue
+            logger.warning("Skipping %s (.info failed): %s", ticker, exc)
+            return None
+
+    if info is None:
+        logger.warning("Rate-limited for %s after %d retries", ticker, max_retries)
+        return None
+
+    row: dict[str, Any] = {"ticker": ticker}
+    for field in INFO_FIELDS:
+        row[field] = info.get(field)  # type: ignore[union-attr]
+
+    # Quarterly financial statements (native quarterly granularity)
+    for attr, suffix in [
+        ("quarterly_income_stmt", "income"),
+        ("quarterly_balance_sheet", "balance"),
+        ("quarterly_cashflow", "cashflow"),
+    ]:
+        try:
+            stmt: pd.DataFrame = getattr(t, attr)
+            if stmt is not None and not stmt.empty:
+                stmt.to_csv(out_dir / f"{ticker}_{suffix}.csv")
+        except Exception as exc:
+            logger.debug("Could not get %s for %s: %s", attr, ticker, exc)
+
+    # Mark as done
+    _ = info_path.write_text("done")
+    return row
+
+
+def run(tickers: list[str] | None = None) -> pd.DataFrame:
+    """Execute Step 2 and return the company_info DataFrame."""
+    config.FUNDAMENTALS_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = config.FUNDAMENTALS_DIR / "company_info.csv"
+
+    if tickers is None:
+        universe_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+        if not universe_path.exists():
+            raise FileNotFoundError(f"Run Step 1 first: {universe_path}")
+        tickers = pd.read_csv(universe_path)["ticker"].tolist()
+
+    # Filter to tickers not yet collected (resume-safe via flag files)
+    already_done = {f.stem.replace("_info_done", "")
+                    for f in config.FUNDAMENTALS_DIR.glob("*_info_done.flag")}
+    remaining = [t for t in tickers if t not in already_done]
+    logger.info("Collecting fundamentals for %d tickers (%d already done) ...",
+                len(remaining), len(already_done))
+
+    rows: list[dict] = []
+    # Sequential with delay to avoid yfinance rate limits
+    for i, ticker in enumerate(remaining):
+        result = _collect_single_ticker(ticker, config.FUNDAMENTALS_DIR)
+        if result is not None:
+            rows.append(result)
+        # Checkpoint every 10 tickers (more frequent = less data loss on crash,
+        # and the flag file is only written AFTER statements are saved so the
+        # checkpoint is the only window where data could be lost)
+        if (i + 1) % 10 == 0:
+            if rows:
+                _df = pd.DataFrame(rows)
+                if out_path.exists():
+                    _existing = pd.read_csv(out_path)
+                    _df = pd.concat([_existing, _df]).drop_duplicates(subset="ticker", keep="last")
+                _df.sort_values("ticker").to_csv(out_path, index=False)
+                rows.clear()  # flush — already persisted
+            if (i + 1) % 50 == 0:
+                logger.info("Fundamentals progress: %d / %d", i + 1, len(remaining))
+        # Mandatory delay between requests to stay under yfinance limits
+        time.sleep(1.5)
+
+    if rows:
+        new_df = pd.DataFrame(rows)
+        # Merge with any existing data (resume-safe)
+        if out_path.exists():
+            existing = pd.read_csv(out_path)
+            combined = pd.concat([existing, new_df]).drop_duplicates(subset="ticker", keep="last")
+        else:
+            combined = new_df
+        combined.sort_values("ticker").to_csv(out_path, index=False)
+        logger.info("Saved company_info (%d rows) to %s", len(combined), out_path)
+        return combined
+
+    if out_path.exists():
+        return pd.read_csv(out_path)
+    return pd.DataFrame()

code/collect_macro.py

@@ -0,0 +1,233 @@
+"""Step 5: Collect macro-economic context data.
+
+Uses:
+  - FredClient  from projects.tools.finance.fred       (interest rates, indices, dollar index)
+  - EIAClient   from projects.tools.commodity.eia       (crude oil, natural gas)
+
+Resume logic:
+  - FRED: per-series file check + freshness validation.
+  - EIA:  per-file freshness check (not per-category!).
+    If any processed CSV is stale (max date > STALE_DAYS behind END_DATE),
+    it is deleted and re-fetched.
+
+Output:
+  data/macro/fred_{SERIES_ID}.csv
+  data/macro/crude_oil/{name}_raw.csv  +  {name}.csv
+  data/macro/natural_gas/{name}_raw.csv  +  {name}.csv
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+from pathlib import Path
+
+import pandas as pd
+
+from projects.tools.commodity.eia import EIAClient
+from projects.tools.finance.fred import FredClient
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+_MAX_RETRIES = 3
+
+# A processed CSV is considered stale if its latest date is more than
+# STALE_DAYS before config.END_DATE.
+_STALE_DAYS = 90
+
+
+async def _retry_async(coro_factory, description: str, retries: int = _MAX_RETRIES):
+    """Call *coro_factory()* up to *retries* times with exponential backoff."""
+    for attempt in range(retries):
+        try:
+            return await coro_factory()
+        except Exception as exc:
+            if attempt < retries - 1:
+                wait = 2 ** attempt * 3  # 3s, 6s, 12s
+                logger.warning("%s failed (attempt %d/%d), retrying in %ds: %s",
+                               description, attempt + 1, retries, wait, exc)
+                await asyncio.sleep(wait)
+            else:
+                raise
+
+
+def _atomic_csv_write(df: pd.DataFrame, dest: Path) -> None:
+    """Write a CSV atomically: write to temp file first, then rename."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(suffix=".csv", dir=dest.parent)
+    try:
+        os.close(fd)
+        df.to_csv(tmp_path, index=False)
+        os.replace(tmp_path, dest)
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def _is_stale(csv_path: Path) -> bool:
+    """Check if a CSV's latest date is too far behind config.END_DATE."""
+    if not csv_path.exists():
+        return True  # missing = stale
+    try:
+        df = pd.read_csv(csv_path, nrows=0)
+        date_col = next(
+            (c for c in df.columns if "date" in c.lower()
+             or "period" in c.lower() or "time" in c.lower()),
+            None,
+        )
+        if date_col is None:
+            return False  # can't determine, assume OK
+        df = pd.read_csv(csv_path, usecols=[date_col])
+        df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+        max_date = df[date_col].max()
+        if pd.isna(max_date):
+            return True
+        cutoff = pd.Timestamp(config.END_DATE) - pd.Timedelta(days=_STALE_DAYS)
+        if max_date < cutoff:
+            logger.warning(
+                "STALE: %s latest date is %s (cutoff %s, %d days behind)",
+                csv_path.name, max_date.date(), cutoff.date(),
+                (pd.Timestamp(config.END_DATE) - max_date).days,
+            )
+            return True
+        return False
+    except Exception as exc:
+        logger.warning("Could not check freshness of %s (treating as stale): %s", csv_path.name, exc)
+        return True  # corrupt / unreadable → treat as stale so it gets re-fetched
+
+
+# ---------------------------------------------------------------------------
+# FRED collection (per-series resume + freshness)
+# ---------------------------------------------------------------------------
+
+async def _collect_fred(client: FredClient) -> None:
+    """Fetch every FRED series defined in config."""
+    fred_dir = config.MACRO_DIR
+    fred_dir.mkdir(parents=True, exist_ok=True)
+
+    for series_id, description in config.FRED_SERIES.items():
+        out_path = fred_dir / f"fred_{series_id}.csv"
+        if out_path.exists() and not _is_stale(out_path):
+            logger.info("FRED %s already exists and is fresh, skipping.", series_id)
+            continue
+
+        reason = "stale" if out_path.exists() else "missing"
+        logger.info("Fetching FRED %s (%s) [%s] ...", series_id, description, reason)
+        try:
+            df = await _retry_async(
+                lambda sid=series_id: client.fetch_series_data(
+                    series_id=sid,
+                    start_date=config.START_DATE,
+                    end_date=config.END_DATE,
+                ),
+                description=f"FRED {series_id}",
+            )
+            _atomic_csv_write(df, out_path)
+            logger.info("Saved FRED %s (%d rows).", series_id, len(df))
+        except Exception as exc:
+            logger.warning("FRED %s failed after retries: %s", series_id, exc)
+
+
+# ---------------------------------------------------------------------------
+# EIA collection (per-file freshness, NOT per-category!)
+# ---------------------------------------------------------------------------
+
+async def _collect_eia_category(
+    client: EIAClient,
+    category: str,
+    out_dir: Path,
+    fetch_fn,
+) -> None:
+    """Fetch an EIA category, re-downloading only missing or stale files."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Inventory existing processed files
+    existing = {f.stem: f for f in out_dir.glob("*.csv") if "_raw" not in f.stem}
+    stale_files = [name for name, path in existing.items() if _is_stale(path)]
+    fresh_count = len(existing) - len(stale_files)
+
+    if stale_files:
+        logger.info(
+            "EIA %s: %d fresh files, %d stale to re-fetch: %s",
+            category, fresh_count, len(stale_files), stale_files,
+        )
+        # Delete stale files so they get re-written
+        for name in stale_files:
+            for suffix in ["", "_raw"]:
+                p = out_dir / f"{name}{suffix}.csv"
+                if p.exists():
+                    p.unlink()
+                    logger.info("  Deleted stale %s", p.name)
+    elif existing:
+        logger.info("EIA %s: all %d files are fresh, skipping.", category, len(existing))
+        return
+
+    # Fetch all data from the API (EIA client returns all endpoints at once)
+    logger.info("Fetching EIA %s data ...", category)
+    try:
+        results = await _retry_async(fetch_fn, description=f"EIA {category}")
+        if not results:
+            logger.warning("EIA %s: all endpoints returned empty (check API key / network).",
+                           category)
+            return
+        for name, raw_df, processed_df in results:
+            processed_path = out_dir / f"{name}.csv"
+            raw_path = out_dir / f"{name}_raw.csv"
+            # Only write if the file is missing or was stale
+            if not processed_path.exists() or name in stale_files:
+                _atomic_csv_write(raw_df, raw_path)
+                _atomic_csv_write(processed_df, processed_path)
+                logger.info("  Saved %s %s (%d raw, %d processed rows).",
+                             category, name, len(raw_df), len(processed_df))
+            else:
+                logger.info("  %s %s already fresh, not overwriting.", category, name)
+    except Exception as exc:
+        logger.error("EIA %s collection failed after retries: %s: %s",
+                     category, type(exc).__name__, exc, exc_info=True)
+
+
+async def _collect_eia(client: EIAClient) -> None:
+    """Fetch crude oil and natural gas data from EIA (per-file freshness)."""
+    await _collect_eia_category(
+        client,
+        category="crude_oil",
+        out_dir=config.MACRO_DIR / "crude_oil",
+        fetch_fn=lambda: client.get_all_crude_oil_data(),
+    )
+    await _collect_eia_category(
+        client,
+        category="natural_gas",
+        out_dir=config.MACRO_DIR / "natural_gas",
+        fetch_fn=lambda: client.get_all_natural_gas_data(),
+    )
+
+
+async def run_async() -> None:
+    """Execute Step 5 (async)."""
+    fred_key = os.getenv("FRED_API_KEY")
+    if not fred_key:
+        raise ValueError("Set FRED_API_KEY environment variable.")
+
+    eia_key = os.getenv("EIA_API_KEY")
+    if not eia_key:
+        raise ValueError("Set EIA_API_KEY environment variable.")
+
+    fred_client = FredClient(api_key=fred_key)
+    eia_client = EIAClient(api_key=eia_key)
+
+    await _collect_fred(fred_client)
+    await _collect_eia(eia_client)
+
+    logger.info("Macro data collection complete.")
+
+
+def run() -> None:
+    """Sync wrapper around the async implementation."""
+    asyncio.run(run_async())

code/collect_news.py

@@ -0,0 +1,308 @@
+"""Step 10 – News collection.
+
+Collects two categories of news data:
+
+  Part A: Per-ticker news & press releases via YFinance (FREE, recent only).
+  Part B: Per-scenario event-specific news via Firecrawl (date-targeted)
+          with Tavily fallback.
+
+Output
+------
+  data/news/tickers/{TICKER}.json   -- per-ticker yfinance news + press
+  data/news/scenarios/{scenario_id}.json -- per-scenario Firecrawl/Tavily
+
+Resume: skips if output file already exists.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pandas as pd
+from dotenv import load_dotenv
+
+from projects.agent_builder.scripts.whatif_bench import config
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _ensure_dirs() -> tuple[Path, Path]:
+    """Create news output directories and return (tickers_dir, scenarios_dir)."""
+    tickers_dir = config.NEWS_DIR / "tickers"
+    scenarios_dir = config.NEWS_DIR / "scenarios"
+    tickers_dir.mkdir(parents=True, exist_ok=True)
+    scenarios_dir.mkdir(parents=True, exist_ok=True)
+    return tickers_dir, scenarios_dir
+
+
+# ---------------------------------------------------------------------------
+# Part A – Per-ticker news + press releases (yfinance, FREE)
+# ---------------------------------------------------------------------------
+
+def _collect_single_ticker_news(ticker: str, tickers_dir: Path, client) -> int:
+    """Fetch news + press releases for a single ticker. Returns article count."""
+    out_path = tickers_dir / f"{ticker}.json"
+    if out_path.exists():
+        return 0  # resume: already collected
+
+    articles: list[dict] = []
+    any_success = False
+
+    for tab in ("news", "press releases"):
+        for attempt in range(3):
+            try:
+                result = client.fetch_news_from_single_ticker(
+                    ticker, tab=tab, count=config.NEWS_PER_TICKER_COUNT,
+                )
+                articles.extend([item.model_dump(mode="json") for item in result.root])
+                any_success = True
+                break
+            except Exception:
+                if attempt == 2:
+                    logger.warning("Failed to fetch %s tab=%s after 3 attempts", ticker, tab)
+                else:
+                    time.sleep(2 ** attempt)
+
+    # Fallback: if yfinance returned nothing, try Tavily for per-ticker news.
+    # Tavily is a paid API but handles obscure small-caps better than yfinance.
+    if not articles:
+        tavily_key = os.environ.get("TAVILY_API_KEY", "")
+        if tavily_key:
+            try:
+                from tavily import TavilyClient
+                tv = TavilyClient(api_key=tavily_key)
+                tv_results = tv.search(
+                    query=f"{ticker} stock news financial",
+                    search_depth="basic",
+                    max_results=config.NEWS_PER_TICKER_COUNT,
+                    topic="news",
+                )
+                for item in tv_results.get("results", []):
+                    articles.append({
+                        "source": "tavily",
+                        "title": item.get("title", ""),
+                        "url": item.get("url", ""),
+                        "snippet": item.get("content", ""),
+                        "date": item.get("published_date", ""),
+                    })
+                if articles:
+                    any_success = True
+                    logger.info("Tavily fallback for %s: %d articles", ticker, len(articles))
+            except Exception as exc:
+                logger.debug("Tavily fallback failed for %s: %s", ticker, exc)
+
+    # Only write the file if at least one tab succeeded.
+    # If ALL tabs failed, do NOT write — leave the file missing so it's retried next run.
+    if any_success:
+        tmp_path = out_path.with_suffix(".json.tmp")
+        tmp_path.write_text(json.dumps(articles, default=str), encoding="utf-8")
+        tmp_path.replace(out_path)  # atomic rename
+    else:
+        logger.warning("All tabs failed for %s — NOT writing file (will retry next run)", ticker)
+
+    return len(articles)
+
+
+# Shared lock to enforce actual rate limiting across threads
+import threading
+_rate_lock = threading.Lock()
+_last_request_time = 0.0
+
+
+def _rate_limited_worker(ticker: str, tickers_dir: Path, client) -> int:
+    """Worker that enforces sequential rate limiting via a shared lock."""
+    global _last_request_time
+    with _rate_lock:
+        elapsed = time.time() - _last_request_time
+        if elapsed < config.NEWS_RATE_LIMIT_SEC:
+            time.sleep(config.NEWS_RATE_LIMIT_SEC - elapsed)
+        _last_request_time = time.time()
+    return _collect_single_ticker_news(ticker, tickers_dir, client)
+
+
+def _run_part_a(tickers: list[str], tickers_dir: Path) -> None:
+    """Parallel per-ticker news collection with proper rate limiting."""
+    logger.info("Part A: collecting per-ticker news for %d tickers …", len(tickers))
+
+    from concurrent.futures import as_completed
+    from projects.tools.finance.yahoo import YFinanceClient
+
+    # Single shared client for connection reuse
+    client = YFinanceClient()
+    total_articles = 0
+    done = 0
+
+    with ThreadPoolExecutor(max_workers=config.NEWS_WORKERS) as pool:
+        futures = {pool.submit(_rate_limited_worker, t, tickers_dir, client): t for t in tickers}
+        for future in as_completed(futures):
+            ticker = futures[future]
+            try:
+                n = future.result()
+                total_articles += n
+            except Exception:
+                logger.exception("Error collecting news for %s", ticker)
+            done += 1
+            if done % 200 == 0:
+                logger.info("  Part A progress: %d / %d tickers", done, len(tickers))
+
+    logger.info("Part A complete: %d articles across %d tickers", total_articles, len(tickers))
+
+
+# ---------------------------------------------------------------------------
+# Part B – Scenario-event news (Firecrawl + Tavily fallback)
+# ---------------------------------------------------------------------------
+
+async def _collect_single_scenario_news(
+    scenario: dict,
+    scenarios_dir: Path,
+    firecrawl_client,
+    tavily_client,
+) -> int:
+    """Fetch news for a single scenario event. Returns article count."""
+    sc_id = scenario["scenario_id"]
+    out_path = scenarios_dir / f"{sc_id}.json"
+    if out_path.exists():
+        return 0
+
+    event_date = pd.Timestamp(scenario["event_date"])
+    # Wider window (±30 days) — narrow windows return empty from news APIs
+    start = (event_date - pd.Timedelta(days=30)).strftime("%-m/%-d/%Y")
+    end = (event_date + pd.Timedelta(days=30)).strftime("%-m/%-d/%Y")
+    tbs = f"cdr:1,cd_min:{start},cd_max:{end}"
+    # Simplify query: use event_type keywords + date, not full description
+    event_type = scenario.get("event_type", "").replace("_", " ")
+    year_month = event_date.strftime("%B %Y")
+    query = f"{event_type} {year_month} financial markets impact"
+
+    articles: list[dict] = []
+
+    # Try Firecrawl first
+    try:
+        fc_results = await firecrawl_client._search(
+            query=query,
+            limit=config.NEWS_SCENARIO_LIMIT,
+            sources=["news"],
+            categories=[],
+            tbs=tbs,
+        )
+        if fc_results and hasattr(fc_results, "news") and fc_results.news:
+            for item in fc_results.news:
+                articles.append({
+                    "source": "firecrawl",
+                    "title": getattr(item, "title", ""),
+                    "url": getattr(item, "url", ""),
+                    "snippet": getattr(item, "snippet", getattr(item, "description", "")),
+                    "date": getattr(item, "date", ""),
+                })
+    except Exception:
+        logger.warning("Firecrawl failed for scenario %s, trying Tavily", sc_id)
+
+    # Tavily fallback if Firecrawl returned nothing
+    if not articles and tavily_client is not None:
+        try:
+            tv_results = await tavily_client._search(
+                query=query,
+                search_depth="advanced",
+                include_raw_content=True,
+                max_results=config.NEWS_SCENARIO_LIMIT,
+            )
+            for item in tv_results.get("results", []):
+                articles.append({
+                    "source": "tavily",
+                    "title": item.get("title", ""),
+                    "url": item.get("url", ""),
+                    "snippet": item.get("content", ""),
+                    "date": item.get("published_date", ""),
+                    "raw_content": item.get("raw_content", ""),
+                })
+        except Exception:
+            logger.warning("Tavily also failed for scenario %s", sc_id)
+
+    out_path.write_text(json.dumps(articles, default=str), encoding="utf-8")
+    return len(articles)
+
+
+async def _run_part_b(scenarios_dir: Path) -> None:
+    """Async per-scenario news collection."""
+    # Load scenarios
+    benchmark_dir = config.get_benchmark_dir()
+    scenarios_path = benchmark_dir / "scenarios.parquet"
+    if not scenarios_path.exists():
+        logger.warning("scenarios.parquet not found at %s — skipping Part B", scenarios_path)
+        return
+
+    scenarios_df = pd.read_parquet(scenarios_path)
+    scenarios = scenarios_df.to_dict("records")
+    logger.info("Part B: collecting scenario news for %d events …", len(scenarios))
+
+    # Init clients
+    firecrawl_api_key = os.environ.get("FIRECRAWL_API_KEY", "")
+    tavily_api_key = os.environ.get("TAVILY_API_KEY", "")
+
+    from projects.tools.web.firecrawl_search import FirecrawlClient
+    from projects.tools.web.tavily_search import TavilyClient
+
+    fc_client = FirecrawlClient(api_key=firecrawl_api_key) if firecrawl_api_key else None
+    tv_client = TavilyClient(api_key=tavily_api_key) if tavily_api_key else None
+
+    if fc_client is None and tv_client is None:
+        logger.error("Neither FIRECRAWL_API_KEY nor TAVILY_API_KEY set — skipping Part B")
+        return
+
+    total = 0
+    for i, sc in enumerate(scenarios):
+        if fc_client is not None:
+            n = await _collect_single_scenario_news(sc, scenarios_dir, fc_client, tv_client)
+        elif tv_client is not None:
+            n = await _collect_single_scenario_news(sc, scenarios_dir, None, tv_client)
+        else:
+            n = 0
+        total += n
+        await asyncio.sleep(config.NEWS_RATE_LIMIT_SEC)
+        if (i + 1) % 10 == 0:
+            logger.info("  Part B progress: %d / %d scenarios", i + 1, len(scenarios))
+
+    logger.info("Part B complete: %d articles across %d scenarios", total, len(scenarios))
+
+
+# ---------------------------------------------------------------------------
+# Public entry points
+# ---------------------------------------------------------------------------
+
+async def run_async(tickers: list[str] | None = None) -> None:
+    """Run both Part A and Part B news collection.
+
+    Parameters
+    ----------
+    tickers : list[str] | None
+        Ticker symbols for Part A. If None, reads from universe CSV.
+    """
+    tickers_dir, scenarios_dir = _ensure_dirs()
+
+    # Resolve tickers
+    if tickers is None:
+        universe_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+        if universe_path.exists():
+            tickers = pd.read_csv(universe_path)["ticker"].tolist()
+        else:
+            logger.error("No tickers provided and universe CSV not found")
+            return
+
+    # Part A: synchronous (uses ThreadPoolExecutor internally)
+    _run_part_a(tickers, tickers_dir)
+
+    # Part B: async
+    await _run_part_b(scenarios_dir)
+
+    logger.info("News collection complete.")

code/collect_prices.py

@@ -0,0 +1,191 @@
+"""Step 3: Collect daily stock prices (OHLCV + Adj Close).
+
+Downloads daily OHLCV data for the full ticker universe using
+yf.download() in batches of PRICE_BATCH_SIZE.
+
+Uses ``auto_adjust=False`` to preserve the ``Adj Close`` column,
+which is required for the shares_outstanding derivation in Layer 2.
+
+Includes retry with backoff for rate-limited batches, per-batch
+checkpointing (so crashes don't lose all progress), and filters out
+tickers/rows where ``Close`` is entirely NaN (junk/delisted symbols).
+
+Output: data/prices/daily_prices.csv
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+import time
+
+import pandas as pd
+import yfinance as yf
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+MAX_BATCH_RETRIES = 3
+
+
+def _download_batch_with_retry(
+    batch: list[str],
+    start: str,
+    end: str,
+    retries: int = MAX_BATCH_RETRIES,
+) -> pd.DataFrame | None:
+    """Download a batch of tickers with retry on rate-limit errors."""
+    for attempt in range(retries):
+        try:
+            df = yf.download(
+                batch,
+                start=start,
+                end=end,
+                group_by="ticker",
+                auto_adjust=False,
+                threads=True,
+            )
+            if df is not None and not df.empty:
+                return df
+            return None
+        except Exception as exc:
+            err_str = str(exc)
+            if "Too Many Requests" in err_str or "Rate" in err_str:
+                wait = 2 ** attempt * 5  # 5s, 10s, 20s
+                logger.warning("Batch rate-limited (attempt %d/%d), waiting %ds ...",
+                               attempt + 1, retries, wait)
+                time.sleep(wait)
+                continue
+            logger.warning("Batch download failed: %s", exc)
+            return None
+    logger.warning("Batch exhausted %d retries.", retries)
+    return None
+
+
+def _reshape_batch(raw: pd.DataFrame, batch: list[str]) -> pd.DataFrame:
+    """Reshape a yfinance MultiIndex batch to long format."""
+    records = []
+    if isinstance(raw.columns, pd.MultiIndex):
+        for ticker in raw.columns.get_level_values(0).unique():
+            try:
+                sub = raw[ticker].copy()
+                sub = sub.reset_index()
+                sub["Ticker"] = ticker
+                records.append(sub)
+            except Exception as exc:
+                logger.warning("Could not reshape ticker %s: %s", ticker, exc)
+                continue
+    else:
+        # Single ticker case
+        raw = raw.reset_index()
+        raw["Ticker"] = batch[0] if len(batch) == 1 else "UNKNOWN"
+        records.append(raw)
+
+    if not records:
+        return pd.DataFrame()
+    return pd.concat(records, ignore_index=True)
+
+
+def _atomic_csv_write(df: pd.DataFrame, dest) -> None:
+    """Write CSV atomically via temp file + rename."""
+    dest_parent = dest.parent if hasattr(dest, "parent") else os.path.dirname(dest)
+    fd, tmp_path = tempfile.mkstemp(suffix=".csv", dir=dest_parent)
+    try:
+        os.close(fd)
+        df.to_csv(tmp_path, index=False)
+        os.replace(tmp_path, str(dest))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def run(tickers: list[str] | None = None) -> pd.DataFrame:
+    """Execute Step 3 and return the daily prices DataFrame."""
+    config.PRICES_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = config.PRICES_DIR / "daily_prices.csv"
+    checkpoint_path = config.PRICES_DIR / "_prices_checkpoint.csv"
+
+    if out_path.exists():
+        logger.info("Daily prices file already exists at %s, loading.", out_path)
+        return pd.read_csv(out_path, parse_dates=["Date"])
+
+    if tickers is None:
+        universe_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+        if not universe_path.exists():
+            raise FileNotFoundError(f"Run Step 1 first: {universe_path}")
+        tickers = pd.read_csv(universe_path)["ticker"].tolist()
+
+    # Resume from checkpoint if it exists
+    existing = pd.DataFrame()
+    already_done: set[str] = set()
+    if checkpoint_path.exists():
+        try:
+            existing = pd.read_csv(checkpoint_path)
+            already_done = set(existing["Ticker"].unique())
+            logger.info("Resuming from checkpoint: %d tickers already downloaded.", len(already_done))
+        except Exception:
+            logger.warning("Checkpoint file corrupt, starting fresh.")
+            existing = pd.DataFrame()
+
+    remaining = [t for t in tickers if t not in already_done]
+    logger.info("Downloading daily prices for %d tickers (%d already done) ...",
+                len(remaining), len(already_done))
+
+    batch_size = config.PRICE_BATCH_SIZE
+    batches_since_checkpoint = 0
+
+    for i in range(0, len(remaining), batch_size):
+        batch = remaining[i : i + batch_size]
+        logger.info("Downloading batch %d-%d / %d remaining", i, i + len(batch), len(remaining))
+        raw = _download_batch_with_retry(batch, config.START_DATE, config.END_DATE)
+        if raw is not None:
+            reshaped = _reshape_batch(raw, batch)
+            if not reshaped.empty:
+                existing = pd.concat([existing, reshaped], ignore_index=True)
+                batches_since_checkpoint += 1
+
+        # Checkpoint every 5 batches (~250 tickers)
+        if batches_since_checkpoint >= 5 and not existing.empty:
+            _atomic_csv_write(existing, checkpoint_path)
+            batches_since_checkpoint = 0
+            logger.info("  Checkpoint saved (%d rows, %d tickers).",
+                        len(existing), existing["Ticker"].nunique())
+
+    if existing.empty:
+        logger.warning("No price data downloaded.")
+        return pd.DataFrame()
+
+    # Standardize column names
+    col_map = {c: c.strip() for c in existing.columns}
+    result = existing.rename(columns=col_map)
+
+    # Filter out rows where Close is NaN (junk/delisted tickers, pre-listing dates)
+    before_len = len(result)
+    result = result.dropna(subset=["Close"])
+    dropped = before_len - len(result)
+    if dropped > 0:
+        logger.info("Filtered %d rows with NaN Close (kept %d).", dropped, len(result))
+
+    # Report tickers with zero valid rows
+    valid_tickers = result["Ticker"].nunique()
+    all_tickers_set = set(tickers)
+    tickers_in_result = set(result["Ticker"].unique())
+    missing = all_tickers_set - tickers_in_result
+    if missing:
+        logger.info("%d tickers had no valid price data: %s",
+                     len(missing), sorted(missing))
+
+    _atomic_csv_write(result, out_path)
+    logger.info("Saved daily prices (%d rows, %d tickers) to %s",
+                len(result), valid_tickers, out_path)
+
+    # Clean up checkpoint
+    if checkpoint_path.exists():
+        checkpoint_path.unlink()
+
+    return result

code/collect_real_estate.py

@@ -0,0 +1,193 @@
+"""Step 6: Collect multifamily real estate with logical locations.
+
+Uses:
+  - RentCastPropertiesClient  from projects.tools.property_market.rentcast
+    .get_properties_by_address()        -- property records
+    .get_rental_listings_by_address()   -- rental listings
+    .get_sale_listings_by_address()     -- sale listings
+    .export_records()                   -- CSV export
+  - EsriAPIClient  from projects.tools.property_market.esri_package.esri_package.esri
+    .get_processed_demographic_info()   -- demographics per metro
+
+Includes resume checks (skip if output CSVs exist) and retry with
+exponential backoff for transient RentCast API failures.
+
+Output:
+  data/real_estate/properties.csv
+  data/real_estate/rentals.csv
+  data/real_estate/sales.csv
+  data/real_estate/demographics.csv
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+import pandas as pd
+
+from projects.tools.property_market.rentcast import RentCastPropertiesClient
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+_MAX_RETRIES = 3
+
+
+async def _retry_async(coro_factory, description: str, retries: int = _MAX_RETRIES):
+    """Call *coro_factory()* up to *retries* times with exponential backoff."""
+    for attempt in range(retries):
+        try:
+            return await coro_factory()
+        except Exception as exc:
+            if attempt < retries - 1:
+                wait = 2 ** attempt * 3  # 3s, 6s, 12s
+                logger.warning("%s failed (attempt %d/%d), retrying in %ds: %s",
+                               description, attempt + 1, retries, wait, exc)
+                await asyncio.sleep(wait)
+            else:
+                raise
+
+
+async def _collect_rentcast(client: RentCastPropertiesClient) -> None:
+    """Fetch properties, rental listings, and sale listings for every metro."""
+    re_dir = config.REAL_ESTATE_DIR
+    re_dir.mkdir(parents=True, exist_ok=True)
+
+    # Resume check: skip if all three output CSVs already exist
+    props_path = re_dir / "properties.csv"
+    rentals_path = re_dir / "rentals.csv"
+    sales_path = re_dir / "sales.csv"
+    if props_path.exists() and rentals_path.exists() and sales_path.exists():
+        logger.info("RentCast data already exists (properties, rentals, sales), skipping.")
+        return
+
+    all_properties = []
+    all_rentals = []
+    all_sales = []
+
+    for metro_addr in config.METROS:
+        logger.info("RentCast: querying %s ...", metro_addr)
+        try:
+            props = await _retry_async(
+                lambda addr=metro_addr: client.get_properties_by_address(
+                    address=addr,
+                    property_types=config.RENTCAST_PROPERTY_TYPES,  # type: ignore[arg-type]
+                    radius=config.RENTCAST_RADIUS_MILES,
+                    auto_paginate=False,
+                    limit=config.RENTCAST_MAX_RESULTS,
+                ),
+                description=f"RentCast properties {metro_addr}",
+            )
+            all_properties.extend(props)
+            logger.info("  properties: %d", len(props))
+        except Exception as exc:
+            logger.warning("  properties failed for %s after retries: %s", metro_addr, exc)
+
+        try:
+            rentals = await _retry_async(
+                lambda addr=metro_addr: client.get_rental_listings_by_address(
+                    address=addr,
+                    property_types=config.RENTCAST_PROPERTY_TYPES,  # type: ignore[arg-type]
+                    radius=config.RENTCAST_RADIUS_MILES,
+                    auto_paginate=False,
+                    limit=config.RENTCAST_MAX_RESULTS,
+                ),
+                description=f"RentCast rentals {metro_addr}",
+            )
+            all_rentals.extend(rentals)
+            logger.info("  rental listings: %d", len(rentals))
+        except Exception as exc:
+            logger.warning("  rentals failed for %s after retries: %s", metro_addr, exc)
+
+        try:
+            sales = await _retry_async(
+                lambda addr=metro_addr: client.get_sale_listings_by_address(
+                    address=addr,
+                    property_types=config.RENTCAST_PROPERTY_TYPES,  # type: ignore[arg-type]
+                    radius=config.RENTCAST_RADIUS_MILES,
+                    auto_paginate=False,
+                    limit=config.RENTCAST_MAX_RESULTS,
+                ),
+                description=f"RentCast sales {metro_addr}",
+            )
+            all_sales.extend(sales)
+            logger.info("  sale listings: %d", len(sales))
+        except Exception as exc:
+            logger.warning("  sales failed for %s after retries: %s", metro_addr, exc)
+
+        # Brief pause between metros to be polite to the API
+        await asyncio.sleep(0.5)
+
+    # Write each file individually so partial success is preserved
+    if all_properties:
+        client.export_records(all_properties, props_path)
+        logger.info("Saved %d property records.", len(all_properties))
+    if all_rentals:
+        client.export_records(all_rentals, rentals_path)
+        logger.info("Saved %d rental listings.", len(all_rentals))
+    if all_sales:
+        client.export_records(all_sales, sales_path)
+        logger.info("Saved %d sale listings.", len(all_sales))
+
+    # Write a done marker so we know all 3 were attempted
+    done_marker = re_dir / ".rentcast_done"
+    done_marker.write_text("done")
+
+
+async def _collect_demographics(client) -> None:
+    """Fetch ESRI demographic data for each metro to make locations 'logical'."""
+    re_dir = config.REAL_ESTATE_DIR
+    demo_path = re_dir / "demographics.csv"
+    if demo_path.exists():
+        logger.info("Demographics file already exists, skipping.")
+        return
+
+    rows = []
+    for metro_addr in config.METROS:
+        logger.info("ESRI demographics: %s ...", metro_addr)
+        try:
+            info = await _retry_async(
+                lambda addr=metro_addr: client.get_processed_demographic_info(addr),
+                description=f"ESRI demographics {metro_addr}",
+            )
+            rows.append(info.model_dump())
+        except Exception as exc:
+            logger.warning("  demographics failed for %s after retries: %s", metro_addr, exc)
+
+    if rows:
+        df = pd.DataFrame(rows)
+        df.to_csv(demo_path, index=False)
+        logger.info("Saved demographics (%d metros).", len(df))
+
+
+async def run_async() -> None:
+    """Execute Step 6 (async)."""
+    rentcast_key = os.getenv("RENTCAST_API_KEY")
+    if not rentcast_key:
+        raise ValueError("Set RENTCAST_API_KEY environment variable.")
+
+    rentcast_client = RentCastPropertiesClient(api_key=rentcast_key)
+    await _collect_rentcast(rentcast_client)
+
+    # Demographics via ESRI (requires arcgis package -- skip if unavailable)
+    esri_user = os.getenv("ARCGIS_USERNAME")
+    esri_pass = os.getenv("ARCGIS_PASSWORD")
+    if not esri_user or not esri_pass:
+        logger.warning("ARCGIS_USERNAME / ARCGIS_PASSWORD not set, skipping demographics.")
+    else:
+        try:
+            from projects.tools.property_market.esri_package.esri_package.esri import EsriAPIClient
+            esri_client = EsriAPIClient(username=esri_user, password=esri_pass)
+            await _collect_demographics(esri_client)
+        except ImportError:
+            logger.warning("arcgis package not installed, skipping demographics collection.")
+
+    logger.info("Real estate data collection complete.")
+
+
+def run() -> None:
+    """Sync wrapper around the async implementation."""
+    asyncio.run(run_async())

code/collect_universe.py

@@ -0,0 +1,568 @@
+"""Step 1: Collect the small-cap ticker universe.
+
+Universe definition: union of small-cap-and-below tickers from major
+S&P/Russell/iShares ETFs:
+
+  - IWM: iShares Russell 2000 ETF (Russell 2000 small-caps)
+  - IJR: iShares Core S&P SmallCap ETF (S&P 600 small-caps)
+  - IWC: iShares Micro-Cap ETF (micro-caps below small-cap threshold)
+
+Tickers exceeding the S&P 600 upper bound ($7.4B median market cap) are
+filtered out downstream in preprocess.py via SMALL_CAP_MAX_MEDIAN_MCAP.
+We do NOT filter on ETF holding value here because it does not correlate
+with actual company market cap (mega-caps may have small ETF positions).
+
+This satisfies Prof. Hwang's Requirement 1.1: "Collect R2K + small caps".
+
+- Uses iShares CSV data directly for market value, sector, exchange.
+- Normalises multi-class share tickers (e.g. BFA -> BF-A) so yfinance can find them.
+- Removes duplicates, zero-price entries, and non-equity rows.
+
+Output: data/universe/benchmark_universe.csv
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import math
+import os
+import tempfile
+import time
+
+import httpx
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+_MAX_HTTP_RETRIES = 3
+
+# Sanity bounds for company market cap (USD).
+# Anything outside this range is treated as an invalid lookup.
+_MCAP_MIN_VALID = 1.0e5      # $100k — below this is almost certainly bad data
+_MCAP_MAX_VALID = 1.0e13     # $10T — above this is impossible
+
+# yfinance lookup pacing — pure serial.
+#
+# Empirically, ANY parallelism (even 4 workers × 0.3s delay = ~5 req/s)
+# triggers Yahoo's per-IP rate limit on runs of >2000 tickers, dropping
+# coverage to ~60%. Pure serial at ~3 req/s stays under the threshold and
+# achieves ~99% coverage. For ~5,345 tickers this takes ~27 minutes — that
+# is the minimum reliable wall time for this dataset size.
+_MCAP_LOOKUP_DELAY_SEC = 0.3
+
+# iShares strips the dash from multi-class share tickers.
+# This map restores the yfinance-compatible format.
+_CLASS_SHARE_FIXES: dict[str, str] = {
+    "BFA": "BF-A",
+    "BFB": "BF-B",
+    "BRKB": "BRK-B",
+    "LENB": "LEN-B",
+    "MOGA": "MOG-A",
+    "MOGB": "MOG-B",
+    "GEFB": "GEF-B",
+    "CWENA": "CWEN-A",
+    "UHALB": "UHAL-B",
+    "CRDA": "CRD-A",   # Crawford & Co Class A — non-voting
+    "CRDB": "CRD-B",   # Crawford & Co Class B — voting
+}
+
+# NASDAQ Trader public symbol directory — authoritative source for ALL
+# US-listed common equities (NASDAQ + NYSE + NYSE Mkt + AMEX). Used to
+# populate Prof. Hwang's third universe component: small caps that are
+# NOT in any major index (recent IPOs, between-rebalance additions,
+# dropped-from-index small caps still trading).
+_NASDAQ_LISTED_URL = "https://www.nasdaqtrader.com/dynamic/symdir/nasdaqlisted.txt"
+_OTHER_LISTED_URL = "https://www.nasdaqtrader.com/dynamic/symdir/otherlisted.txt"
+
+
+def _download_ishares_holdings(url: str) -> pd.DataFrame:
+    """Download iShares ETF holdings CSV and return a cleaned DataFrame."""
+    for attempt in range(_MAX_HTTP_RETRIES):
+        try:
+            resp = httpx.get(url, follow_redirects=True, timeout=60)
+            resp.raise_for_status()
+            break
+        except Exception as exc:
+            if attempt < _MAX_HTTP_RETRIES - 1:
+                wait = 2 ** attempt * 5
+                logger.warning("iShares download failed (attempt %d/%d), retrying in %ds: %s",
+                               attempt + 1, _MAX_HTTP_RETRIES, wait, exc)
+                time.sleep(wait)
+            else:
+                raise
+    text = resp.text
+
+    # iShares CSVs have metadata rows before the actual header.
+    lines = text.splitlines()
+    header_idx = 0
+    for i, line in enumerate(lines):
+        if line.strip().lower().startswith("ticker"):
+            header_idx = i
+            break
+
+    csv_text = "\n".join(lines[header_idx:])
+    df = pd.read_csv(io.StringIO(csv_text))
+    df.columns = [c.strip() for c in df.columns]
+    if "Ticker" in df.columns:
+        df = df[df["Ticker"].notna() & (df["Ticker"].str.strip() != "-") & (df["Ticker"].str.strip() != "")]
+        df["Ticker"] = df["Ticker"].str.strip().str.upper()
+        # Filter out junk rows (e.g. iShares copyright disclaimers parsed as tickers)
+        df = df[df["Ticker"].str.len() <= 10]
+        # Keep only equity instruments (remove futures, cash, CVRs, etc.)
+        if "Asset Class" in df.columns:
+            before = len(df)
+            df = df[df["Asset Class"].str.strip().str.lower() == "equity"]
+            dropped = before - len(df)
+            if dropped > 0:
+                logger.info("Filtered %d non-equity entries (kept %d equities).", dropped, len(df))
+        # Remove zero-price entries (CVRs, escrows, delisted, private vestings
+        # that iShares mislabels as Equity)
+        if "Price" in df.columns:
+            price_num = pd.to_numeric(df["Price"].astype(str).str.replace(",", ""), errors="coerce")
+            before = len(df)
+            df = df[price_num > 0]
+            dropped = before - len(df)
+            if dropped > 0:
+                logger.info("Filtered %d zero-price entries (CVRs/escrows/delisted).", dropped)
+    return df
+
+
+def _download_nasdaq_trader(url: str) -> pd.DataFrame:
+    """Download a pipe-delimited NASDAQ Trader symbol directory file.
+
+    Both nasdaqlisted.txt and otherlisted.txt share the same format:
+    pipe-delimited, one header row, last line is a 'File Creation Time'
+    footer that must be skipped.
+    """
+    for attempt in range(_MAX_HTTP_RETRIES):
+        try:
+            resp = httpx.get(url, follow_redirects=True, timeout=60)
+            resp.raise_for_status()
+            break
+        except Exception as exc:
+            if attempt < _MAX_HTTP_RETRIES - 1:
+                wait = 2 ** attempt * 5
+                logger.warning("NASDAQ Trader download failed (attempt %d/%d), retrying in %ds: %s",
+                               attempt + 1, _MAX_HTTP_RETRIES, wait, exc)
+                time.sleep(wait)
+            else:
+                raise
+    text = resp.text
+
+    # Drop the trailing "File Creation Time" footer line
+    lines = [ln for ln in text.splitlines() if ln and not ln.startswith("File Creation Time")]
+    df = pd.read_csv(io.StringIO("\n".join(lines)), sep="|")
+    df.columns = [c.strip() for c in df.columns]
+    return df
+
+
+def _collect_uncovered_smallcaps(already_seen: set[str]) -> list[dict]:
+    """Return candidate records for Prof. Hwang's third universe component:
+    small caps listed on NYSE/NASDAQ that are NOT in any major index
+    (specifically not in the IWM/IJR/IWC ETF holdings already collected).
+
+    Each record is a dict with keys: ticker, exchange, name. The exchange
+    and security name come directly from the NASDAQ Trader symbol directory
+    files (no extra API calls). Sector is filled later by collect_fundamentals.
+
+    The mcap filter (≤ $7.4B) is applied later in run() via the same serial
+    yfinance lookup pass; this function only produces the candidate set.
+
+    Filtering rules:
+      - Drop ETFs (ETF=Y in nasdaqlisted.txt)
+      - Drop test issues (Test Issue=Y)
+      - Drop tickers already in IWM/IJR/IWC (passed via `already_seen`)
+      - Drop preferreds (containing '$' or '.' which mark preferred classes)
+      - Drop warrants and units (suffix W/U/R on a 5-char base)
+      - Keep only common stock (Common Stock / Common Shares in security name)
+    """
+    logger.info("Downloading NASDAQ Trader symbol directories ...")
+    nas = _download_nasdaq_trader(_NASDAQ_LISTED_URL)
+    oth = _download_nasdaq_trader(_OTHER_LISTED_URL)
+    logger.info("nasdaqlisted: %d rows, otherlisted: %d rows", len(nas), len(oth))
+
+    candidates: list[tuple[str, str, str]] = []  # (ticker, exchange_code, security_name)
+
+    # ── nasdaqlisted.txt fields: Symbol|Security Name|Market Category|Test Issue|Financial Status|Round Lot Size|ETF|NextShares
+    if not nas.empty:
+        nas = nas[nas["Test Issue"].astype(str).str.upper() != "Y"]
+        nas = nas[nas["ETF"].astype(str).str.upper() != "Y"]
+        for _, row in nas.iterrows():
+            sym = str(row.get("Symbol", "")).strip().upper()
+            sec_name = str(row.get("Security Name", ""))
+            if not sym or sym == "NAN":
+                continue
+            candidates.append((sym, "NASDAQ", sec_name))
+
+    # ── otherlisted.txt fields: ACT Symbol|Security Name|Exchange|CQS Symbol|ETF|Round Lot Size|Test Issue|NASDAQ Symbol
+    # Exchange codes: A=NYSE Mkt (AMEX), N=NYSE, P=NYSE Arca, Z=BATS, V=IEX
+    if not oth.empty:
+        oth = oth[oth["Test Issue"].astype(str).str.upper() != "Y"]
+        oth = oth[oth["ETF"].astype(str).str.upper() != "Y"]
+        # Keep only NYSE-family exchanges
+        oth = oth[oth["Exchange"].astype(str).str.upper().isin(["N", "A"])]
+        for _, row in oth.iterrows():
+            sym = str(row.get("ACT Symbol", "")).strip().upper()
+            sec_name = str(row.get("Security Name", ""))
+            exch = "NYSE" if row.get("Exchange") == "N" else "NYSE_MKT"
+            if not sym or sym == "NAN":
+                continue
+            candidates.append((sym, exch, sec_name))
+
+    # Filter to common stock only (drop preferreds, warrants, units, notes,
+    # rights, depositary shares, etc.). Use security name keyword whitelist
+    # — most US-listed equities have "Common Stock" or "Common Shares".
+    common_kws = ("common stock", "common share", "ordinary share", "class a common",
+                  "class b common", "class c common")
+    drop_kws = ("preferred", "warrant", "unit ", " unit", "% notes", "depositary",
+                "right ", " rights", "subordinate", "convertible", "trust preferred",
+                "% senior", "debenture", " etn ", "exchange-traded note")
+
+    # Build per-ticker dict (dedupe by ticker, prefer first occurrence)
+    by_ticker: dict[str, dict] = {}
+    for sym, exch, sec_name in candidates:
+        sn_low = sec_name.lower()
+        if any(k in sn_low for k in drop_kws):
+            continue
+        if not any(k in sn_low for k in common_kws):
+            continue
+        # Drop ticker symbols that look like preferred/warrant variants:
+        # tickers containing $ or . (preferred class markers like BAC.PA),
+        # 5-char tickers ending in W (warrant), U (unit), R (rights).
+        if "$" in sym or "." in sym:
+            continue
+        if len(sym) >= 5 and sym.endswith(("W", "U", "R")):
+            continue
+        if sym in by_ticker:
+            continue  # first occurrence wins
+        # Strip the " - Common Stock" suffix from the security name for cleaner display
+        clean_name = sec_name
+        for suffix in (" - Common Stock", " - Common Shares", " - Class A Common Stock",
+                       " - Class B Common Stock", " - Class C Common Stock"):
+            if clean_name.endswith(suffix):
+                clean_name = clean_name[: -len(suffix)]
+                break
+        by_ticker[sym] = {
+            "ticker": sym,
+            "exchange": exch,
+            "name": clean_name.strip(),
+        }
+
+    # Subtract already-known tickers (those in IWM/IJR/IWC)
+    new_records = [r for sym, r in sorted(by_ticker.items()) if sym not in already_seen]
+    overlap = sum(1 for sym in by_ticker if sym in already_seen)
+    logger.info("NASDAQ Trader common-stock candidates: %d (after subtracting "
+                "%d already-known tickers: %d)", len(by_ticker), overlap, len(new_records))
+    return new_records
+
+
+def _fetch_one_market_cap(ticker: str) -> float | None:
+    """Fetch a single ticker's company market cap from yfinance.
+
+    Uses ONLY `fast_info.market_cap` — a single fast network call. The
+    deliberately simple approach avoids the multi-fallback hangs that
+    occur when `tk.info` blocks for 30+ seconds on rate limits or bad
+    tickers. Tickers where fast_info fails are returned as None and
+    dropped from the universe per Option A (a small-cap benchmark
+    cannot include a ticker without a verified market cap).
+
+    Returns a float USD value in [_MCAP_MIN_VALID, _MCAP_MAX_VALID]
+    or None on any failure.
+    """
+    import yfinance as yf  # local import — yfinance is heavy
+
+    try:
+        mc = yf.Ticker(ticker).fast_info.market_cap
+    except Exception:
+        return None
+    try:
+        mcf = float(mc)
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(mcf):
+        return None
+    if not (_MCAP_MIN_VALID <= mcf <= _MCAP_MAX_VALID):
+        return None
+    return mcf
+
+
+def _serial_fetch_pass(tickers: list[str], pass_label: str) -> dict[str, float | None]:
+    """One serial pass over `tickers`. fast_info call + delay per ticker."""
+    results: dict[str, float | None] = {}
+    total = len(tickers)
+    if total == 0:
+        return results
+    logger.info("%s: %d tickers, serial, %.2fs delay ...",
+                pass_label, total, _MCAP_LOOKUP_DELAY_SEC)
+    t0 = time.time()
+    for i, t in enumerate(tickers, start=1):
+        results[t] = _fetch_one_market_cap(t)
+        time.sleep(_MCAP_LOOKUP_DELAY_SEC)
+        if i % 200 == 0 or i == total:
+            elapsed = time.time() - t0
+            ok = sum(1 for v in results.values() if v is not None)
+            rate = i / elapsed if elapsed > 0 else 0
+            eta = (total - i) / rate if rate > 0 else 0
+            logger.info("  %s progress: %d/%d (ok=%d) — %.0fs elapsed, ETA %.0fs",
+                        pass_label, i, total, ok, elapsed, eta)
+    return results
+
+
+def _fetch_market_caps(tickers: list[str]) -> dict[str, float | None]:
+    """Fetch market caps via two serial passes for maximum coverage.
+
+    Pass 1: serial fast_info call for every ticker (~3 req/s, no rate limit).
+    Pass 2: serial retry of any tickers that returned None in pass 1 (catches
+            transient errors; permanent no-data tickers will fail again and
+            be dropped per Option A).
+
+    Pure serial avoids the per-IP rate limit that even 4 workers triggered.
+    Expected wall time for ~5,345 tickers: ~27 min pass 1 + ~3 min pass 2.
+    """
+    t0 = time.time()
+
+    # ── Pass 1: serial over all tickers ──
+    results = _serial_fetch_pass(tickers, pass_label="Pass 1")
+    pass1_ok = sum(1 for v in results.values() if v is not None)
+    logger.info("Pass 1 complete: %d/%d resolved in %.0fs",
+                pass1_ok, len(tickers), time.time() - t0)
+
+    # ── Pass 2: serial retry of pass-1 failures ──
+    failed = [t for t in tickers if results.get(t) is None]
+    if failed:
+        retry_results = _serial_fetch_pass(failed, pass_label="Pass 2 (retry)")
+        recovered = 0
+        for t, mc in retry_results.items():
+            if mc is not None:
+                results[t] = mc
+                recovered += 1
+        logger.info("Pass 2 complete: recovered %d/%d failures",
+                    recovered, len(failed))
+
+    final_ok = sum(1 for v in results.values() if v is not None)
+    logger.info("Total market_cap coverage: %d/%d (%.1f%%) in %.0fs",
+                final_ok, len(tickers), 100 * final_ok / len(tickers),
+                time.time() - t0)
+    return results
+
+
+def run() -> pd.DataFrame:
+    """Execute Step 1 and return the universe DataFrame."""
+    config.UNIVERSE_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
+
+    if out_path.exists():
+        logger.info("Universe file already exists at %s, loading.", out_path)
+        return pd.read_csv(out_path)
+
+    def _records_from_ishares(holdings_df: pd.DataFrame, source: str) -> list[dict]:
+        records = []
+        for _, row in holdings_df.iterrows():
+            ticker = row["Ticker"]
+            mv_str = str(row.get("Market Value", "")).replace(",", "")
+            try:
+                market_value = float(mv_str)
+            except (ValueError, TypeError):
+                market_value = None
+            records.append({
+                "ticker": ticker,
+                "market_value": market_value,
+                "sector": row.get("Sector"),
+                "exchange": row.get("Exchange"),
+                "name": row.get("Name"),
+                "source": source,
+            })
+        return records
+
+    # ----- Russell 2000 from IWM -----
+    logger.info("Downloading IWM (Russell 2000) holdings ...")
+    iwm_df = _download_ishares_holdings(config.IWM_HOLDINGS_URL)
+    logger.info("IWM tickers: %d", len(iwm_df))
+    iwm_records = _records_from_ishares(iwm_df, source="IWM")
+    iwm_set = {r["ticker"] for r in iwm_records}
+
+    # ----- S&P SmallCap 600 from IJR -----
+    logger.info("Downloading IJR (S&P SmallCap 600) holdings ...")
+    ijr_df = _download_ishares_holdings(config.IJR_HOLDINGS_URL)
+    logger.info("IJR tickers: %d", len(ijr_df))
+    ijr_records = _records_from_ishares(ijr_df, source="IJR")
+    # Keep only IJR tickers not already in IWM
+    ijr_only = [r for r in ijr_records if r["ticker"] not in iwm_set]
+    logger.info("IJR-only tickers (not in IWM): %d", len(ijr_only))
+
+    # ----- Micro-cap from IWC -----
+    logger.info("Downloading IWC (Micro-Cap) holdings ...")
+    iwc_df = _download_ishares_holdings(config.IWC_HOLDINGS_URL)
+    iwc_records = _records_from_ishares(iwc_df, source="IWC")
+    seen = iwm_set | {r["ticker"] for r in ijr_only}
+    iwc_only = [r for r in iwc_records if r["ticker"] not in seen]
+    logger.info("IWC-only tickers (not in IWM or IJR): %d", len(iwc_only))
+
+    # ----- Uncovered NYSE/NASDAQ small caps (Prof. Hwang component 3) -----
+    # "those who are not even included in the index (small caps in NYSE or NASDAQ)"
+    # We pull the full NASDAQ Trader symbol directories, filter to common stock
+    # only, subtract everything already in IWM/IJR/IWC, and let the downstream
+    # mcap pass apply the $7.4B small-cap upper bound. The remainder is the
+    # set of small caps that are NOT in any major index (recent IPOs,
+    # between-rebalance additions, dropped-from-index small caps).
+    seen_for_uncovered = iwm_set | {r["ticker"] for r in ijr_only} | {r["ticker"] for r in iwc_only}
+    uncovered_seed = _collect_uncovered_smallcaps(seen_for_uncovered)
+    uncovered_records = [
+        {
+            "ticker": rec["ticker"],
+            "market_value": None,            # iShares-only field; not applicable
+            "sector": None,                  # filled later by collect_fundamentals
+            "exchange": rec["exchange"],     # populated from NASDAQ Trader directory
+            "name": rec["name"],             # populated from NASDAQ Trader directory
+            "source": "UNCOVERED",
+        }
+        for rec in uncovered_seed
+    ]
+    logger.info("UNCOVERED small-cap candidates (pre-mcap-filter): %d", len(uncovered_records))
+
+    # Build the set of ALL S&P 600 tickers (BEFORE the IJR-only subtraction
+    # against IWM). This is what `in_sp_smallcap_600` should reflect: an
+    # IJR ticker is an S&P 600 small-cap regardless of whether it ALSO
+    # happens to appear in IWM (they overlap by hundreds of names). The
+    # earlier `source` column does NOT capture this -- a ticker in both
+    # IWM and IJR carries source='IWM', losing the SP600 attestation.
+    all_ijr_tickers = {r["ticker"] for r in ijr_records}
+
+    # Combine: IWM + IJR-only + IWC-only + UNCOVERED
+    all_records = []
+    for r in iwm_records:
+        all_records.append({
+            **r,
+            "in_russell_2000": True,
+            "in_sp_smallcap_600": r["ticker"] in all_ijr_tickers,
+            "small_cap_outside": False,
+        })
+    for r in ijr_only:
+        all_records.append({
+            **r,
+            "in_russell_2000": False,
+            "in_sp_smallcap_600": True,
+            "small_cap_outside": True,
+        })
+    for r in iwc_only:
+        all_records.append({
+            **r,
+            "in_russell_2000": False,
+            "in_sp_smallcap_600": False,
+            "small_cap_outside": True,
+        })
+    for r in uncovered_records:
+        all_records.append({
+            **r,
+            "in_russell_2000": False,
+            "in_sp_smallcap_600": False,
+            "small_cap_outside": True,
+        })
+
+    df = pd.DataFrame(all_records)
+    logger.info("Combined raw universe: %d tickers (IWM=%d, IJR-only=%d, IWC-only=%d, UNCOVERED=%d)",
+                len(df), len(iwm_records), len(ijr_only), len(iwc_only), len(uncovered_records))
+
+    # Normalise multi-class share tickers (iShares strips the dash)
+    fixed = 0
+    for old, new in _CLASS_SHARE_FIXES.items():
+        mask = df["ticker"] == old
+        if mask.any():
+            df.loc[mask, "ticker"] = new
+            fixed += mask.sum()
+    if fixed:
+        logger.info("Normalised %d multi-class share tickers (e.g. BFA -> BF-A).", fixed)
+
+    # Remove exact duplicates (same ticker appearing as CVR + regular stock)
+    before = len(df)
+    df = df.drop_duplicates(subset="ticker", keep="first")
+    dupes = before - len(df)
+    if dupes:
+        logger.info("Removed %d duplicate tickers.", dupes)
+
+    # ── Fetch authoritative company market cap from yfinance ──────────────
+    # NOTE: iShares "market_value" is the ETF's holding value, NOT the
+    # company's market cap. We fetch the real market cap here so the saved
+    # universe file is the authoritative small-cap set from the start.
+    #
+    # Every ticker in the saved file MUST have a verified market_cap, or it
+    # is dropped (cannot honestly be classified as small-cap without knowing).
+    tickers = df["ticker"].tolist()
+    mcap_map = _fetch_market_caps(tickers)
+    df["market_cap"] = df["ticker"].map(mcap_map)
+
+    # Drop tickers with no reliable market cap (delisted, SPAC residue, ADR glitches)
+    invalid_mask = df["market_cap"].isna()
+    invalid_tickers = sorted(df.loc[invalid_mask, "ticker"].tolist())
+    if invalid_tickers:
+        logger.warning("Dropped %d tickers with no valid market_cap (showing first 30): %s",
+                       len(invalid_tickers), invalid_tickers[:30])
+        df = df.loc[~invalid_mask].copy()
+
+    # Drop mega-caps from IWC and UNCOVERED sources.
+    #
+    # IWM (Russell 2000) and IJR (S&P SmallCap 600) constituents are
+    # index-designated small-caps by FTSE Russell / S&P Dow Jones methodology
+    # — we respect those classifications and do NOT filter them by current
+    # market cap (a few names may have drifted above $7.4B since the last
+    # index reconstitution, but they remain index-designated small-caps).
+    #
+    # IWC has known mega-cap leakage (iShares holds tiny tracking positions
+    # in NVDA/AAPL/etc. for index-fit reasons) and must be filtered.
+    #
+    # UNCOVERED tickers have no index attestation at all and so require
+    # an explicit small-cap upper bound. The S&P 600 SmallCap upper bound
+    # ($7.4B) is the official threshold per S&P Dow Jones methodology.
+    needs_filter = df["source"].isin(["IWC", "UNCOVERED"])
+    mega_mask = needs_filter & (df["market_cap"] > config.SMALL_CAP_MAX_MEDIAN_MCAP)
+    mega_rows = df.loc[mega_mask, ["ticker", "source", "market_cap"]].sort_values(
+        "market_cap", ascending=False
+    )
+    if not mega_rows.empty:
+        logger.warning(
+            "Dropped %d mega-caps from IWC/UNCOVERED (market_cap > $%.1fB). First 30:\n%s",
+            len(mega_rows),
+            config.SMALL_CAP_MAX_MEDIAN_MCAP / 1e9,
+            mega_rows.head(30).to_string(index=False),
+        )
+        df = df.loc[~mega_mask].copy()
+
+    logger.info(
+        "Universe after market-cap filtering: %d tickers (max mcap=$%.2fB, median=$%.2fB)",
+        len(df),
+        df["market_cap"].max() / 1e9,
+        df["market_cap"].median() / 1e9,
+    )
+
+    # Apply MAX_TICKERS cap if set
+    if config.MAX_TICKERS is not None:
+        df = df.head(config.MAX_TICKERS)
+
+    # Label lower-end by market value percentile (within Russell 2000 subset)
+    r2k = df[df["in_russell_2000"] & df["market_value"].notna()]
+    if not r2k.empty:
+        threshold = r2k["market_value"].quantile(config.LOWER_END_PERCENTILE / 100.0)
+        df["lower_end_russell2000"] = df["in_russell_2000"] & (df["market_value"] <= threshold)
+        logger.info("Lower-end R2K threshold: market_value <= %.0f (%d tickers)",
+                     threshold, df["lower_end_russell2000"].sum())
+    else:
+        df["lower_end_russell2000"] = False
+
+    df = df.sort_values("ticker").reset_index(drop=True)
+    # Atomic write: write to temp file first, then rename
+    fd, tmp_path = tempfile.mkstemp(suffix=".csv", dir=out_path.parent)
+    try:
+        os.close(fd)
+        df.to_csv(tmp_path, index=False)
+        os.replace(tmp_path, out_path)
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+    logger.info("Saved universe (%d tickers) to %s", len(df), out_path)
+    return df

code/config.py

@@ -0,0 +1,833 @@
+"""Centralised configuration for the What-If Scenario Benchmark pipeline.
+
+Every tunable parameter lives here so that notebooks and scripts have a
+single source of truth.
+
+Architecture:
+  Layer 1 (Raw Collection)  -> data/{source}/
+  Layer 2 (Preprocessing)   -> data/processed/{GRANULARITY}/
+  Layer 3 (Benchmark)       -> data/benchmark/{GRANULARITY}/
+"""
+
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Paths -- Layer 1 (raw data)
+# ---------------------------------------------------------------------------
+import os as _os
+
+BASE_DIR = Path(__file__).resolve().parent
+# Small-cap rebuild: all data lives under data_small_caps/ for the
+# clean-slate small-cap-and-below universe rebuild (Apr 2026).
+DATA_DIR = BASE_DIR / _os.environ.get("WHATIF_DATA_DIR", "data_small_caps")
+
+UNIVERSE_DIR = DATA_DIR / "universe"
+FUNDAMENTALS_DIR = DATA_DIR / "fundamentals"
+PRICES_DIR = DATA_DIR / "prices"
+FILINGS_DIR = DATA_DIR / "filings"
+MACRO_DIR = DATA_DIR / "macro"
+REAL_ESTATE_DIR = DATA_DIR / "real_estate"
+NEWS_DIR = DATA_DIR / "news"
+XBRL_DIR = DATA_DIR / "xbrl"
+
+# ---------------------------------------------------------------------------
+# Paths -- Layer 2 & 3 (derived from GRANULARITY)
+# ---------------------------------------------------------------------------
+GRANULARITY: str = "daily"  # "daily", "weekly", or "monthly"
+
+
+def get_processed_dir(granularity: str | None = None) -> Path:
+    """Return the processed-data directory for *granularity* (default: GRANULARITY)."""
+    return DATA_DIR / "processed" / (granularity or GRANULARITY)
+
+
+def get_benchmark_dir(granularity: str | None = None) -> Path:
+    """Return the benchmark-output directory for *granularity* (default: GRANULARITY)."""
+    return DATA_DIR / "benchmark" / (granularity or GRANULARITY)
+
+
+# Legacy module-level aliases (point to the default granularity).
+# Use the functions above when the caller might override granularity.
+PROCESSED_DIR = get_processed_dir()
+BENCHMARK_DIR = get_benchmark_dir()
+
+# ---------------------------------------------------------------------------
+# Date range (fixed for reproducibility)
+# ---------------------------------------------------------------------------
+START_DATE = "2021-01-01"
+END_DATE = "2026-04-01"
+START_YEAR = int(START_DATE[:4])  # 2021 — used by collect_filings.py
+END_YEAR = int(END_DATE[:4])      # 2026 — used by collect_filings.py
+
+# ---------------------------------------------------------------------------
+# Global reproducibility seed
+# ---------------------------------------------------------------------------
+BENCHMARK_SEED = 42
+
+# ---------------------------------------------------------------------------
+# Ticker universe
+# ---------------------------------------------------------------------------
+# iShares Russell 2000 ETF holdings CSV URL
+IWM_HOLDINGS_URL = (
+    "https://www.ishares.com/us/products/239710/"
+    "ishares-russell-2000-etf/1467271812596.ajax?"
+    "fileType=csv&fileName=IWM_holdings&dataType=fund"
+)
+# iShares Core S&P SmallCap ETF (IJR) — tracks S&P SmallCap 600 index
+# Defines official "small-cap" range: $1B – $7.4B (S&P methodology, 2025).
+IJR_HOLDINGS_URL = (
+    "https://www.ishares.com/us/products/239774/"
+    "ishares-core-sp-smallcap-etf/1467271812596.ajax?"
+    "fileType=csv&fileName=IJR_holdings&dataType=fund"
+)
+# iShares Micro-Cap ETF holdings CSV URL (micro-caps below small-cap threshold)
+IWC_HOLDINGS_URL = (
+    "https://www.ishares.com/us/products/239724/"
+    "ishares-microcap-etf/1467271812596.ajax?"
+    "fileType=csv&fileName=IWC_holdings&dataType=fund"
+)
+
+# Market-cap upper bound for the "small-cap and below" universe.
+# $7.4B = official S&P 600 SmallCap upper bound (S&P Dow Jones Indices, 2025).
+# Tickers with median derived_market_cap above this are filtered out as
+# mid-cap or larger and excluded from the benchmark.
+SMALL_CAP_MAX_MEDIAN_MCAP: float = 7.4e9
+
+# Market-cap percentile threshold to label "lower end" of Russell 2000
+LOWER_END_PERCENTILE = 50  # bottom 50 %
+
+# Cap the total number of tickers (set to None for full universe)
+MAX_TICKERS: int | None = None
+
+# Tickers excluded from the universe (none — filter is applied via market cap).
+EXCLUDED_TICKERS: list[str] = []
+
+# ---------------------------------------------------------------------------
+# Fundamentals collection
+# ---------------------------------------------------------------------------
+FUNDAMENTALS_WORKERS = 2  # ThreadPoolExecutor parallelism (low to avoid yfinance rate limits)
+
+# ---------------------------------------------------------------------------
+# Price collection
+# ---------------------------------------------------------------------------
+PRICE_BATCH_SIZE = 50  # tickers per yf.download() call
+
+# ---------------------------------------------------------------------------
+# SEC filings
+# ---------------------------------------------------------------------------
+SEC_FILING_TYPES: list[str] = ["10-K", "10-Q", "8-K", "20-F", "6-K", "N-CSR", "N-CSRS"]
+SEC_FILING_WORKERS = 4  # asyncio.Semaphore concurrency
+
+# ---------------------------------------------------------------------------
+# FRED macro series
+# ---------------------------------------------------------------------------
+FRED_SERIES: dict[str, str] = {
+    # ── Rates & monetary policy ──
+    "FEDFUNDS": "Federal Funds Effective Rate",
+    "SOFR": "Secured Overnight Financing Rate",
+    "DGS2": "2-Year Treasury Constant Maturity Rate",
+    "DGS10": "10-Year Treasury Constant Maturity Rate",
+    "DGS30": "30-Year Treasury Constant Maturity Rate",
+    "T10Y3M": "10-Year Treasury Minus 3-Month Treasury",
+    "T10Y2Y": "10-Year Treasury Minus 2-Year Treasury",
+    "MORTGAGE30US": "30-Year Fixed Rate Mortgage Average",
+    # ── Equity & volatility ──
+    "SP500": "S&P 500 Index",
+    "NASDAQCOM": "NASDAQ Composite Index",
+    "DJIA": "Dow Jones Industrial Average",
+    "VIXCLS": "CBOE Volatility Index (VIX)",
+    # ── Commodities (FRED daily) ──
+    "DCOILWTICO": "Crude Oil Prices: West Texas Intermediate (WTI)",
+    "DHHNGSP": "Henry Hub Natural Gas Spot Price",
+    # ── Currency & exchange rates ──
+    "DTWEXBGS": "Trade Weighted U.S. Dollar Index",
+    "DEXUSEU": "U.S. / Euro Foreign Exchange Rate",
+    "DEXJPUS": "Japan / U.S. Foreign Exchange Rate",
+    "DEXUSUK": "U.S. / U.K. Foreign Exchange Rate",
+    "DEXCHUS": "China / U.S. Foreign Exchange Rate",
+    # ── Inflation & prices ──
+    "CPIAUCSL": "Consumer Price Index For All Urban Consumers (All Items)",
+    "CPILFESL": "Consumer Price Index Less Food and Energy (Core CPI)",
+    "PPIACO": "Producer Price Index (All Commodities)",
+    "T10YIE": "10-Year Breakeven Inflation Rate",
+    "T5YIE": "5-Year Breakeven Inflation Rate",
+    "PCEPI": "Personal Consumption Expenditures: Chain-type Price Index",
+    # ── Labor market ──
+    "UNRATE": "Unemployment Rate",
+    "ICSA": "Initial Claims (Weekly Jobless Claims)",
+    "PAYEMS": "All Employees Total Nonfarm (Payrolls)",
+    "JTSJOL": "Job Openings: Total Nonfarm (JOLTS)",
+    "CES0500000003": "Average Hourly Earnings of All Employees (Total Private)",
+    # ── Credit & financial stress ──
+    "BAMLH0A0HYM2": "ICE BofA US High Yield Option-Adjusted Spread",
+    "BAMLC0A0CM": "ICE BofA US Corporate Master Option-Adjusted Spread",
+    "TEDRATE": "TED Spread (3-Month LIBOR minus 3-Month T-Bill)",
+    "STLFSI2": "St. Louis Fed Financial Stress Index",
+    "NFCI": "Chicago Fed National Financial Conditions Index",
+    # ── Economic activity ──
+    "INDPRO": "Industrial Production Index",
+    "RSAFS": "Advance Retail Sales: Retail and Food Services",
+    "UMCSENT": "University of Michigan Consumer Sentiment",
+    "TOTALSA": "Total Vehicle Sales",
+    "PERMIT": "New Privately-Owned Housing Units Authorized (Building Permits)",
+    # ── Housing ──
+    "CSUSHPISA": "S&P/Case-Shiller U.S. National Home Price Index",
+    "HOUST": "Housing Starts: Total New Privately Owned",
+    # ── Money supply & central bank ──
+    "M2SL": "M2 Money Stock",
+    "BOGMBASE": "Monetary Base; Total",
+    "WALCL": "Federal Reserve Total Assets (Balance Sheet)",
+    # ── Business lending ──
+    "BUSLOANS": "Commercial and Industrial Loans, All Commercial Banks",
+}
+
+# ---------------------------------------------------------------------------
+# Real estate metros (address anchors for RentCast radius search)
+# ---------------------------------------------------------------------------
+_ALL_METROS: list[str] = [
+    # ── Top 20 (original) ──
+    "350 5th Ave, New York, NY 10118",
+    "233 S Wacker Dr, Chicago, IL 60606",
+    "1000 Vin Scully Ave, Los Angeles, CA 90012",
+    "600 Travis St, Houston, TX 77002",
+    "400 S Tryon St, Charlotte, NC 28202",
+    "100 Peachtree St NW, Atlanta, GA 30303",
+    "200 E Las Olas Blvd, Fort Lauderdale, FL 33301",
+    "700 2nd Ave S, Nashville, TN 37210",
+    "1 N Central Ave, Phoenix, AZ 85004",
+    "2001 Ross Ave, Dallas, TX 75201",
+    "200 E Colfax Ave, Denver, CO 80203",
+    "1 S Broad St, Philadelphia, PA 19107",
+    "100 Summer St, Boston, MA 02110",
+    "700 5th Ave, Seattle, WA 98104",
+    "50 Fremont St, San Francisco, CA 94105",
+    "401 E Pratt St, Baltimore, MD 21202",
+    "1 S Main St, Salt Lake City, UT 84111",
+    "400 S Orange Ave, Orlando, FL 32801",
+    "100 NE 2nd Ave, Portland, OR 97232",
+    "325 John Knox Rd, Tallahassee, FL 32303",
+    # ── 21-40: Large metros ──
+    "1 Riverfront Plz, Newark, NJ 07102",
+    "100 N Main St, Memphis, TN 38103",
+    "200 W Washington St, Indianapolis, IN 46204",
+    "100 S Main St, Las Vegas, NV 89101",
+    "600 E Market St, San Antonio, TX 78205",
+    "200 E Pratt St, Milwaukee, WI 53202",
+    "100 N Broadway, Oklahoma City, OK 73102",
+    "500 Main St, Louisville, KY 40202",
+    "100 N Main St, Richmond, VA 23219",
+    "1 S Pinckney St, Madison, WI 53703",
+    "200 E Main St, Norfolk, VA 23510",
+    "100 W Capitol Ave, Little Rock, AR 72201",
+    "100 S Main St, Tulsa, OK 74103",
+    "1 Canal St, New Orleans, LA 70130",
+    "100 E Capitol St, Jackson, MS 39201",
+    "200 W Adams St, Jacksonville, FL 32202",
+    "100 N Main St, Wichita, KS 67202",
+    "100 State St, Hartford, CT 06103",
+    "1 Exchange Pl, Providence, RI 02903",
+    "100 N Tryon St, Raleigh, NC 27601",
+    # ── 41-60: Mid-size metros ──
+    "200 E Main St, Lexington, KY 40507",
+    "100 N Main St, Dayton, OH 45402",
+    "100 W 10th St, Wilmington, DE 19801",
+    "100 S Main St, Akron, OH 44308",
+    "200 N Main St, Greenville, SC 29601",
+    "100 E Washington St, Boise, ID 83702",
+    "1 City Hall Plz, Durham, NC 27701",
+    "100 W Trade St, Winston-Salem, NC 27101",
+    "100 S Virginia St, Reno, NV 89501",
+    "200 E Main St, Chattanooga, TN 37402",
+    "100 N Main St, Columbia, SC 29201",
+    "1 S Main St, Spokane, WA 99201",
+    "100 E Congress St, Tucson, AZ 85701",
+    "200 W Markham St, Birmingham, AL 35203",
+    "100 S Main St, Omaha, NE 68102",
+    "100 W Broad St, Columbus, OH 43215",
+    "100 W Michigan Ave, Kalamazoo, MI 49007",
+    "200 N Main St, Ann Arbor, MI 48104",
+    "100 E 8th St, Cincinnati, OH 45202",
+    "100 S 4th St, Minneapolis, MN 55401",
+    # ── 61-80: Growing metros ──
+    "100 N Main St, Knoxville, TN 37902",
+    "200 W Camelback Rd, Scottsdale, AZ 85251",
+    "100 S State St, Provo, UT 84601",
+    "100 N College Ave, Fort Collins, CO 80524",
+    "200 E Main St, Lakeland, FL 33801",
+    "100 S Main St, Savannah, GA 31401",
+    "100 W Liberty St, Roanoke, VA 24011",
+    "200 E Bay St, Charleston, SC 29401",
+    "100 N Main St, Greensburg, PA 15601",
+    "100 S Palafox St, Pensacola, FL 32502",
+    "200 W Capitol Dr, Baton Rouge, LA 70801",
+    "100 E Main St, Mesa, AZ 85201",
+    "100 N Central Ave, St. Louis, MO 63101",
+    "200 Ross St, Pittsburgh, PA 15219",
+    "100 Woodward Ave, Detroit, MI 48226",
+    "100 W Main St, Bozeman, MT 59715",
+    "100 S 1st Ave, Sioux Falls, SD 57104",
+    "200 N Main St, Santa Fe, NM 87501",
+    "100 N Stone Ave, Albuquerque, NM 87102",
+    "100 S Capitol Blvd, Boise, ID 83702",
+    # ── 81-100: Smaller / emerging metros ──
+    "200 E Main St, Asheville, NC 28801",
+    "100 Congress Ave, Austin, TX 78701",
+    "200 E Commerce St, San Jose, CA 95113",
+    "100 W Flagler St, Miami, FL 33130",
+    "200 S Orange Ave, Sarasota, FL 34236",
+    "100 N Main St, Gainesville, FL 32601",
+    "200 E College Ave, Tallahassee, FL 32301",
+    "100 N Main St, Fayetteville, AR 72701",
+    "100 E Market St, Des Moines, IA 50309",
+    "200 N Main St, McAllen, TX 78501",
+    "100 S Broadway, Wichita Falls, TX 76301",
+    "100 W Front St, Missoula, MT 59802",
+    "200 E Main St, Rapid City, SD 57701",
+    "100 N 1st St, Bismarck, ND 58501",
+    "200 W Superior St, Duluth, MN 55802",
+    "100 E Main St, Rochester, NY 14604",
+    "200 S Warren St, Syracuse, NY 13202",
+    "100 Main St, Buffalo, NY 14202",
+    "200 E State St, Trenton, NJ 08608",
+    "100 S Main St, Harrisburg, PA 17101",
+]
+# For testing: set MAX_METROS to limit (None = all 100)
+MAX_METROS: int | None = None
+METROS: list[str] = _ALL_METROS[:MAX_METROS] if MAX_METROS else _ALL_METROS
+RENTCAST_PROPERTY_TYPES = ["Multi-Family", "Apartment", "Single Family", "Condo", "Townhouse"]
+RENTCAST_RADIUS_MILES = 5.0
+RENTCAST_MAX_RESULTS = 500  # max properties per endpoint per metro (1 page)
+
+# ---------------------------------------------------------------------------
+# Preprocessing (Layer 2)
+# ---------------------------------------------------------------------------
+# Key metrics to extract from per-ticker financial statement CSVs
+INCOME_KEYS: dict[str, str] = {
+    "Total Revenue": "stmt_revenue",
+    "Net Income": "stmt_net_income",
+    "EBITDA": "stmt_ebitda",
+    "EBIT": "stmt_ebit",
+    "Gross Profit": "stmt_gross_profit",
+    "Operating Income": "stmt_operating_income",
+    "Basic EPS": "stmt_basic_eps",
+    # Valuation inputs (WACC / effective tax rate / cost of debt)
+    "Tax Provision": "stmt_tax_provision",
+    "Pretax Income": "stmt_pretax_income",
+    "Interest Expense": "stmt_interest_expense",
+    "Tax Rate For Calcs": "stmt_tax_rate",
+    # Income-statement detail items
+    "Cost Of Revenue": "stmt_cogs",
+    "Operating Expense": "stmt_operating_expenses",
+}
+BALANCE_KEYS: dict[str, str] = {
+    "Total Assets": "stmt_total_assets",
+    "Total Liabilities Net Minority Interest": "stmt_total_liabilities",
+    "Total Debt": "stmt_total_debt",
+    "Total Equity Gross Minority Interest": "stmt_total_equity",
+    "Cash And Cash Equivalents": "stmt_cash",
+    "Ordinary Shares Number": "stmt_shares_outstanding",
+    "Share Issued": "stmt_shares_issued",
+    # Balance-sheet detail items
+    "Accounts Receivable": "stmt_accounts_receivable",
+    "Net Receivables": "stmt_accounts_receivable",
+    "Inventory": "stmt_inventory",
+    "Current Assets": "stmt_current_assets",
+    "Net PPE": "stmt_ppe_net",
+    "Goodwill": "stmt_goodwill",
+    "Accounts Payable": "stmt_accounts_payable",
+    "Current Liabilities": "stmt_current_liabilities",
+    "Long Term Debt": "stmt_lt_debt",
+}
+CASHFLOW_KEYS: dict[str, str] = {
+    "Operating Cash Flow": "stmt_operating_cashflow",
+    "Free Cash Flow": "stmt_free_cashflow",
+    "Capital Expenditure": "stmt_capex",
+    "Financing Cash Flow": "stmt_financing_cashflow",
+}
+
+# XBRL tag → stmt_ column mapping (SEC EDGAR).
+# Each stmt_ column maps to a list of XBRL tags tried in priority order;
+# the first non-null value wins.  Tags are US-GAAP concepts reported in
+# 10-K / 10-Q filings stored in data/xbrl/parsed/company_facts.parquet.
+XBRL_TAG_MAP: dict[str, list[str]] = {
+    "stmt_revenue": [
+        "Revenues",
+        "RevenueFromContractWithCustomerExcludingAssessedTax",
+        "SalesRevenueNet",
+        "RevenueFromContractWithCustomerIncludingAssessedTax",
+        # Banking / Financial Services equivalents
+        "InterestAndDividendIncomeOperating",
+        "InterestIncomeExpenseNet",
+        "NetInterestIncome",
+        "NoninterestIncome",
+        "FinancialServicesRevenue",
+        # Insurance equivalents
+        "PremiumsEarnedNet",
+        "InsuranceServicesRevenue",
+        "PremiumsWrittenNet",
+        # IFRS equivalents
+        "Revenue",
+        "RevenueFromContractsWithCustomers",
+    ],
+    "stmt_net_income": [
+        "NetIncomeLoss",
+        # IFRS
+        "ProfitLoss",
+        "ProfitLossAttributableToOwnersOfParent",
+    ],
+    "stmt_ebit": [
+        "OperatingIncomeLoss",
+        # IFRS
+        "ProfitLossBeforeFinanceCostsAndTax",
+        "OperatingProfitLoss",
+    ],
+    "stmt_gross_profit": [
+        "GrossProfit",
+    ],
+    "stmt_operating_income": [
+        "OperatingIncomeLoss",
+        # IFRS
+        "ProfitLossFromOperatingActivities",
+        "OperatingProfitLoss",
+    ],
+    "stmt_basic_eps": [
+        "EarningsPerShareBasic",
+        # IFRS
+        "BasicEarningsLossPerShare",
+    ],
+    "stmt_tax_provision": [
+        "IncomeTaxExpenseBenefit",
+        # IFRS
+        "IncomeTaxExpenseContinuingOperations",
+    ],
+    "stmt_pretax_income": [
+        "IncomeLossFromContinuingOperationsBeforeIncomeTaxesExtraordinaryItemsNoncontrollingInterest",
+        # IFRS
+        "ProfitLossBeforeTax",
+    ],
+    "stmt_interest_expense": [
+        "InterestExpense",
+        # IFRS
+        "FinanceCosts",
+        "InterestExpenseOnBorrowings",
+    ],
+    "stmt_operating_cashflow": [
+        "NetCashProvidedByUsedInOperatingActivities",
+        # IFRS
+        "CashFlowsFromUsedInOperatingActivities",
+    ],
+    "stmt_capex": [
+        "PaymentsToAcquirePropertyPlantAndEquipment",
+        # IFRS
+        "PurchaseOfPropertyPlantAndEquipmentClassifiedAsInvestingActivities",
+    ],
+    "stmt_total_assets": ["Assets"],
+    "stmt_total_liabilities": ["Liabilities"],
+    "stmt_total_debt": [
+        "LongTermDebt",
+        "LongTermDebtNoncurrent",
+        # IFRS
+        "NoncurrentFinancialLiabilities",
+        "BorrowingsNoncurrent",
+        "NoncurrentPortionOfNoncurrentBorrowings",
+    ],
+    "stmt_total_equity": [
+        "StockholdersEquity",
+        "StockholdersEquityIncludingPortionAttributableToNoncontrollingInterest",
+        # IFRS
+        "Equity",
+        "EquityAttributableToOwnersOfParent",
+    ],
+    "stmt_cash": [
+        "CashAndCashEquivalentsAtCarryingValue",
+        "CashCashEquivalentsRestrictedCashAndRestrictedCashEquivalents",
+        # IFRS
+        "CashAndCashEquivalents",
+    ],
+    "stmt_shares_outstanding": [
+        "CommonStockSharesOutstanding",
+        "EntityCommonStockSharesOutstanding",
+        # Fallback: weighted-average for dual-class companies (CRWD, DDOG, etc.)
+        "WeightedAverageNumberOfSharesOutstandingBasic",
+        "WeightedAverageNumberOfDilutedSharesOutstanding",
+        "CommonSharesOutstanding",
+    ],
+    "stmt_shares_issued": [
+        "CommonStockSharesIssued",
+        # IFRS
+        "IssuedCapital",
+    ],
+    # ── Balance-sheet detail items ──
+    "stmt_accounts_receivable": [
+        "AccountsReceivableNetCurrent",
+        "AccountsReceivableNet",
+        # IFRS
+        "TradeAndOtherCurrentReceivables",
+    ],
+    "stmt_inventory": [
+        "InventoryNet",
+        "Inventories",
+        # IFRS
+        "CurrentInventories",
+    ],
+    "stmt_current_assets": [
+        "AssetsCurrent",
+        # IFRS
+        "CurrentAssets",
+    ],
+    "stmt_ppe_net": [
+        "PropertyPlantAndEquipmentNet",
+        # IFRS
+        "PropertyPlantAndEquipment",
+    ],
+    "stmt_goodwill": [
+        "Goodwill",
+        # IFRS
+        "GoodwillGross",
+    ],
+    "stmt_accounts_payable": [
+        "AccountsPayableCurrent",
+        "AccountsPayable",
+        # IFRS
+        "TradeAndOtherCurrentPayables",
+    ],
+    "stmt_current_liabilities": [
+        "LiabilitiesCurrent",
+        # IFRS
+        "CurrentLiabilities",
+    ],
+    "stmt_lt_debt": [
+        "LongTermDebtNoncurrent",
+        "LongTermDebt",
+        "LongTermDebtAndCapitalLeaseObligations",
+        # IFRS
+        "NoncurrentFinancialLiabilities",
+        "BorrowingsNoncurrent",
+    ],
+    # ── Income-statement detail items ──
+    "stmt_cogs": [
+        "CostOfGoodsAndServicesSold",
+        "CostOfRevenue",
+        "CostOfGoodsSold",
+        # IFRS
+        "CostOfSales",
+    ],
+    "stmt_operating_expenses": [
+        "OperatingExpenses",
+        # IFRS
+        "AdministrativeExpense",
+    ],
+    # ── Cash-flow detail items ──
+    "stmt_financing_cashflow": [
+        "NetCashProvidedByUsedInFinancingActivities",
+        # IFRS
+        "CashFlowsFromUsedInFinancingActivities",
+    ],
+}
+
+# Auxiliary XBRL tags used to derive composite metrics (EBITDA, FCF, tax rate).
+XBRL_DA_TAGS: list[str] = [
+    "DepreciationDepletionAndAmortization",
+    "DepreciationAndAmortization",
+    "Depreciation",
+    # IFRS
+    "DepreciationAmortisationAndImpairmentLossReversalOfImpairmentLossRecognisedInProfitOrLoss",
+    "DepreciationAndAmortisationExpense",
+]
+
+# ---------------------------------------------------------------------------
+# Benchmark assembly (Layer 3)
+# ---------------------------------------------------------------------------
+# Temporal split configuration.
+# Set TEMPORAL_SPLIT_DATE to a fixed date string (e.g. "2024-01-01") to split
+# at that exact date, OR set it to None and use TEMPORAL_SPLIT_RATIO instead.
+TEMPORAL_SPLIT_DATE: str | None = None
+
+# Train fraction of unique panel dates (e.g. 0.7 = 70% train, 30% test).
+# Only used when TEMPORAL_SPLIT_DATE is None.
+TEMPORAL_SPLIT_RATIO: float = 0.7
+
+# Forecasting task parameters -- granularity-aware.
+# Values are in *panel periods* (not calendar days).
+#   daily:   5d≈1w, 21d≈1mo, 63d≈1q, 126d≈6mo, 252d≈1y
+#   weekly:  4w≈1mo, 13w≈1q, 26w≈6mo, 52w≈1y
+#   monthly: 1mo, 3mo≈1q, 6mo, 12mo≈1y
+HORIZONS_BY_GRANULARITY: dict[str, list[int]] = {
+    "daily":   [5, 21, 63, 126, 252],
+    "weekly":  [4, 13, 26, 52],
+    "monthly": [1, 3, 6, 12],
+}
+LOOKBACK_WINDOWS_BY_GRANULARITY: dict[str, list[int]] = {
+    "daily":   [63, 126, 252],
+    "weekly":  [13, 26, 52],
+    "monthly": [3, 6, 12],
+}
+
+# Legacy flat aliases (default granularity) -- prefer the dicts above.
+HORIZONS: list[int] = HORIZONS_BY_GRANULARITY[GRANULARITY]
+LOOKBACK_WINDOWS: list[int] = LOOKBACK_WINDOWS_BY_GRANULARITY[GRANULARITY]
+
+
+def get_horizons(granularity: str | None = None) -> list[int]:
+    """Return forecast horizons for *granularity*."""
+    return HORIZONS_BY_GRANULARITY[granularity or GRANULARITY]
+
+
+def get_lookback_windows(granularity: str | None = None) -> list[int]:
+    """Return lookback windows for *granularity*."""
+    return LOOKBACK_WINDOWS_BY_GRANULARITY[granularity or GRANULARITY]
+
+# ---------------------------------------------------------------------------
+# Scenario detection thresholds (Layer 3 -- generate_scenarios.py)
+# ---------------------------------------------------------------------------
+# Fed funds: minimum absolute change in rate (percentage points) between
+# consecutive monthly observations to flag as a rate-change event.
+SCENARIO_FEDFUNDS_DELTA = 0.25  # 25 bps
+
+# VIX: spike ratio -- current value / rolling mean must exceed this.
+SCENARIO_VIX_SPIKE_RATIO = 1.4
+SCENARIO_VIX_ROLLING_WINDOW = 63  # observations (daily)
+
+# Oil (EIA commodity or FRED DCOILWTICO): pct move over rolling window.
+SCENARIO_OIL_PCT_CHANGE = 0.09  # 9 %
+SCENARIO_OIL_ROLLING_WINDOW = 21  # observations (daily)
+
+# Natural gas: minimum percentage move over a rolling window.
+SCENARIO_NATGAS_PCT_CHANGE = 0.15  # 15 %
+SCENARIO_NATGAS_ROLLING_WINDOW = 4  # observations (weekly data)
+
+# Market drawdown: minimum percentage drop in S&P 500 over a rolling window.
+SCENARIO_SP500_DRAWDOWN = 0.025  # 2.5 %
+SCENARIO_SP500_ROLLING_WINDOW = 21  # observations (daily)
+
+# NASDAQ: minimum percentage move (crash or rally divergence).
+SCENARIO_NASDAQ_PCT_CHANGE = 0.045  # 4.5 %
+SCENARIO_NASDAQ_ROLLING_WINDOW = 21  # observations (daily)
+
+# Yield curve: DGS10 - DGS2 spread thresholds.
+SCENARIO_YIELD_CURVE_INVERSION = 0.0  # spread crosses below 0 = inversion
+SCENARIO_YIELD_CURVE_STEEPENING = 0.50  # spread widens by ≥ 50bps over window
+SCENARIO_YIELD_CURVE_WINDOW = 63  # observations (daily)
+
+# Treasury rate (DGS10): large absolute move in 10-year yield.
+SCENARIO_DGS10_DELTA = 0.45  # 45 bps move over window
+SCENARIO_DGS10_ROLLING_WINDOW = 21  # observations (daily)
+
+# USD index (DTWEXBGS): large percentage move in trade-weighted dollar.
+SCENARIO_USD_PCT_CHANGE = 0.025  # 2.5 %
+SCENARIO_USD_ROLLING_WINDOW = 21  # observations (daily)
+
+# CPI / Inflation: large month-over-month change in annualized rate.
+SCENARIO_CPI_MOM_THRESHOLD = 0.004  # 0.4% month-over-month (≈4.8% annualized)
+
+# PPI: large month-over-month change.
+SCENARIO_PPI_MOM_THRESHOLD = 0.01  # 1% month-over-month
+
+# Unemployment: jump in rate between consecutive observations.
+SCENARIO_UNRATE_DELTA = 0.3  # 30 bps increase
+
+# Jobless claims (ICSA): spike ratio vs rolling mean.
+SCENARIO_ICSA_SPIKE_RATIO = 1.3
+SCENARIO_ICSA_ROLLING_WINDOW = 8  # observations (weekly)
+
+# Payrolls (PAYEMS): large month-over-month change in thousands.
+SCENARIO_PAYROLLS_DELTA = 0.002  # 0.2% month-over-month change
+
+# High-yield credit spread: large move over rolling window.
+SCENARIO_HY_SPREAD_DELTA = 1.0  # 100 bps widening/tightening over window
+SCENARIO_HY_SPREAD_WINDOW = 21  # observations (daily)
+
+# IG corporate spread: large move over rolling window.
+SCENARIO_IG_SPREAD_DELTA = 0.30  # 30 bps over window
+SCENARIO_IG_SPREAD_WINDOW = 21
+
+# TED spread: spike above threshold.
+SCENARIO_TED_SPIKE = 0.50  # 50 bps
+
+# Financial stress index: large move.
+SCENARIO_FSI_THRESHOLD = 1.0  # standard deviation units (index is z-scored)
+
+# Mortgage rate: large move over rolling window.
+SCENARIO_MORTGAGE_DELTA = 0.50  # 50 bps move over window
+SCENARIO_MORTGAGE_ROLLING_WINDOW = 4  # observations (weekly)
+
+# Consumer sentiment (UMCSENT): large drop.
+SCENARIO_SENTIMENT_PCT_CHANGE = 0.10  # 10% drop
+SCENARIO_SENTIMENT_ROLLING_WINDOW = 2  # observations (monthly)
+
+# Industrial production: large month-over-month change.
+SCENARIO_INDPRO_PCT_CHANGE = 0.01  # 1% month-over-month
+
+# Retail sales: large month-over-month change.
+SCENARIO_RETAIL_PCT_CHANGE = 0.02  # 2% month-over-month
+
+# Housing starts: large month-over-month change.
+SCENARIO_HOUSING_PCT_CHANGE = 0.10  # 10% month-over-month
+
+# Home prices (Case-Shiller): year-over-year deceleration/acceleration.
+SCENARIO_HOME_PRICE_YOY_DELTA = 0.03  # 3pp change in YoY rate
+
+# Money supply (M2): year-over-year contraction.
+SCENARIO_M2_YOY_THRESHOLD = -0.01  # YoY growth below -1% (contraction)
+
+# 30-year Treasury: large move.
+SCENARIO_DGS30_DELTA = 0.50  # 50 bps over window
+SCENARIO_DGS30_ROLLING_WINDOW = 21
+
+# Cross-asset: S&P 500 vs NASDAQ divergence.
+SCENARIO_SP_NASDAQ_DIVERGENCE = 0.05  # 5% divergence over window
+SCENARIO_SP_NASDAQ_WINDOW = 21
+
+# VIX regime: sustained elevated volatility.
+SCENARIO_VIX_REGIME_THRESHOLD = 25.0  # VIX above 25
+SCENARIO_VIX_REGIME_MIN_DAYS = 10  # sustained for at least 10 days
+
+# ── NEW: Major FX pair shocks (EUR, JPY, GBP, CNY) ──
+SCENARIO_FX_PCT_CHANGE = 0.03         # 3% move over window
+SCENARIO_FX_ROLLING_WINDOW = 21
+
+# ── NEW: Breakeven inflation shocks (T10YIE, T5YIE) ──
+SCENARIO_BEI_DELTA = 0.30             # 30 bps move over window
+SCENARIO_BEI_ROLLING_WINDOW = 21
+
+# ── NEW: DJIA large moves ──
+SCENARIO_DJIA_PCT_CHANGE = 0.03       # 3% move over window
+SCENARIO_DJIA_ROLLING_WINDOW = 21
+
+# ── NEW: JOLTS job openings ──
+SCENARIO_JOLTS_PCT_CHANGE = 0.05      # 5% month-over-month change
+SCENARIO_JOLTS_DEDUP_DAYS = 28
+
+# ── NEW: Average hourly earnings ──
+SCENARIO_EARNINGS_MOM_THRESHOLD = 0.005  # 0.5% month-over-month
+
+# ── NEW: Vehicle sales ──
+SCENARIO_VEHICLE_PCT_CHANGE = 0.08    # 8% month-over-month
+
+# ── NEW: Building permits ──
+SCENARIO_PERMIT_PCT_CHANGE = 0.08     # 8% month-over-month
+
+# ── NEW: Existing home sales ──
+SCENARIO_EXISTING_HOME_SALES_PCT = 0.05  # 5% month-over-month
+
+# ── NEW: Chicago Fed NFCI ──
+SCENARIO_NFCI_THRESHOLD = 0.0         # NFCI crosses above 0 (tighter than avg)
+
+# ── NEW: Fed balance sheet (WALCL) ──
+SCENARIO_FED_BS_PCT_CHANGE = 0.05     # 5% change over window (quarterly)
+SCENARIO_FED_BS_ROLLING_WINDOW = 13   # ~quarterly for weekly data
+
+# ── NEW: Monetary base (BOGMBASE) ──
+SCENARIO_MONETARY_BASE_PCT = 0.05     # 5% month-over-month
+
+# ── NEW: Business loans (BUSLOANS) ──
+SCENARIO_BUSLOANS_PCT_CHANGE = 0.02   # 2% month-over-month
+
+# ── NEW: PCE inflation ──
+SCENARIO_PCEPI_MOM_THRESHOLD = 0.004  # 0.4% month-over-month
+
+# ── NEW: SOFR rate shocks ──
+SCENARIO_SOFR_DELTA = 0.25            # 25 bps move
+SCENARIO_SOFR_WINDOW = 10             # observations
+
+# ── NEW: Cross-asset composites ──
+# Real yield: DGS10 - T10YIE (breakeven inflation)
+SCENARIO_REAL_YIELD_DELTA = 0.40      # 40 bps change in real yield
+SCENARIO_REAL_YIELD_WINDOW = 21
+# Credit compression: HY spread minus IG spread
+SCENARIO_CREDIT_COMPRESSION_DELTA = 0.75  # 75 bps change
+SCENARIO_CREDIT_COMPRESSION_WINDOW = 21
+# Term premium: DGS30 - DGS2
+SCENARIO_TERM_PREMIUM_DELTA = 0.50    # 50 bps change
+SCENARIO_TERM_PREMIUM_WINDOW = 21
+# ── NEW: Short-term shock windows (5-day) for daily series ──
+SCENARIO_SP500_SHORT_DRAWDOWN = 0.03  # 3% over 5 days (acute crash)
+SCENARIO_SP500_SHORT_WINDOW = 5
+SCENARIO_NASDAQ_SHORT_PCT = 0.04      # 4% over 5 days
+SCENARIO_NASDAQ_SHORT_WINDOW = 5
+SCENARIO_OIL_SHORT_PCT = 0.08         # 8% over 5 days
+SCENARIO_OIL_SHORT_WINDOW = 5
+SCENARIO_DGS10_SHORT_DELTA = 0.25     # 25 bps over 5 days
+SCENARIO_DGS10_SHORT_WINDOW = 5
+
+# Pre/post event windows for scenario context (calendar days).
+SCENARIO_PRE_WINDOW_DAYS = 63
+SCENARIO_POST_WINDOW_DAYS = 63
+
+# ---------------------------------------------------------------------------
+# News collection (Layer 1 -- collect_news.py, Step 10)
+# ---------------------------------------------------------------------------
+NEWS_WORKERS = 4          # ThreadPoolExecutor parallelism for yfinance news
+NEWS_PER_TICKER_COUNT = 50  # articles per ticker per tab (news / press releases)
+NEWS_SCENARIO_LIMIT = 10   # Firecrawl results per scenario event
+NEWS_RATE_LIMIT_SEC = 1.0  # seconds between API calls
+
+# ---------------------------------------------------------------------------
+# Synthetic property generation (agents/synthetic_re/)
+# ---------------------------------------------------------------------------
+COMMERCIAL_RE_TYPES = ["Office", "Retail", "Industrial", "Mixed-Use"]
+COMMERCIAL_RE_SEED_LIMIT = 20  # Firecrawl results per type per metro
+
+# ---------------------------------------------------------------------------
+# Valuation (agents/valuation/)
+# ---------------------------------------------------------------------------
+VALUATION_DIR = DATA_DIR / "valuation"
+
+# DCF parameters
+DCF_PROJECTION_YEARS = 5
+DCF_TERMINAL_GROWTH_DEFAULT = 0.025   # 2.5% long-term GDP growth
+MARKET_RISK_PREMIUM = 0.06            # 6% historical equity risk premium
+BETA_LOOKBACK_DAYS = 252              # 1 year of trading days for rolling beta
+
+# Comparable company analysis
+COMPS_MAX_PEERS = 10
+COMPS_MARKET_CAP_BAND = 0.5           # +/- 50 % for peer filtering by size
+
+# Valuation benchmark
+VALUATION_BENCHMARK_TASKS = [
+    "valuation_accuracy",              # Task A: estimate intrinsic value
+    "statement_generation",            # Task B: generate plausible financials
+    "scenario_forecast",               # Task C: forecast impact of what-if
+]
+VALUATION_HOLDOUT_RATIO = 0.3          # 30 % of tickers held out for eval (Hwang: 50/50 or 70/30)
+
+# ---------------------------------------------------------------------------
+# XBRL collection & ontology (Layer 1 -- collected via collect_filings.py)
+# ---------------------------------------------------------------------------
+# SEC XBRL API base URL (no auth, just User-Agent required)
+XBRL_COMPANY_FACTS_URL = "https://data.sec.gov/api/xbrl/companyfacts/CIK{cik}.json"
+XBRL_WORKERS = 8           # asyncio.Semaphore concurrency
+XBRL_RATE_LIMIT_SEC = 0.12 # seconds between requests (≤10 req/s SEC limit)
+# Filing forms to include in ontology extraction.
+# Policy: include EVERY form on which SEC accepts XBRL facts from our universe
+# (enumerated from raw responses — 37 distinct forms). Do not gate the
+# benchmark by form type: the parser keeps everything SEC deems a valid
+# XBRL-bearing filing, and downstream preprocessing picks the latest value
+# per (ticker, tag, unit) regardless of form.
+XBRL_FORMS: list[str] = [
+    # US domestic periodic statements
+    "10-K", "10-K/A", "10-Q", "10-Q/A",
+    "10-KT", "10-KT/A", "10-QT",  # fiscal-year transition period filings
+    # Foreign private issuer periodic (file US-GAAP or IFRS via these)
+    "20-F", "20-F/A", "40-F", "40-F/A", "6-K", "6-K/A",
+    # Current / event reports (earnings releases often carry full financials)
+    "8-K", "8-K/A",
+    # Registration statements — IPO, shelf, M&A, employee plans
+    "S-1", "S-1/A", "S-1MEF",
+    "F-1/A", "F-1MEF",
+    "S-3", "S-3ASR",
+    "S-4", "S-4/A",
+    "S-8",
+    "POS AM",
+    # Investment company filings (cef / invest taxonomy)
+    "N-CSR", "N-2",
+    # Prospectus supplements
+    "424B2", "424B5", "424B7",
+    # Proxy statements
+    "DEF 14A", "PRE 14A", "DEFR14A", "DEFC14A", "PREM14A",
+    # Tender offers
+    "SC TO-I",
+]
+# Ontology classification thresholds (fraction of companies in an industry)
+XBRL_CORE_THRESHOLD = 0.70     # tag appears in ≥70% → core
+XBRL_COMMON_THRESHOLD = 0.30   # tag appears in ≥30% → common (else extension)

code/dataloader/__init__.py

@@ -0,0 +1,36 @@
+"""MacroLens dataloader: canonical sample budgets + index generators.
+
+Sits between the immutable benchmark artifacts (`data_small_caps/benchmark/`)
+and the family runners (`baselines/`). Owns:
+
+- `budgets.EVAL_N_PER_TASK`, `budgets.TRAIN_N_PER_TASK`, `budgets.SEED`:
+  the canonical sample budgets per task. Single source of truth.
+- `canonical_indices.get_canonical_indices(task, split)`: deterministic,
+  stratified index generator with on-disk cache. Same indices for every
+  method, so cross-method comparison on each task is fair.
+
+Cache layout: `experiments/cache/canonical_indices/<key>/<split>_<task>.parquet`
+where `<key>` encodes (n_eval, n_train, seed, stratifier_version).
+Changing any cache-key dimension produces a new cache directory; the
+immutable benchmark artifacts under `data_small_caps/` are NEVER touched
+(the cache lives experiment-side, not in the dataset tree).
+"""
+
+from .budgets import (
+    EVAL_N_PER_TASK,
+    TRAIN_N_PER_TASK,
+    SEED,
+    STRATIFIER_VERSION,
+    cache_key,
+)
+from .canonical_indices import get_canonical_indices, build_all
+
+__all__ = [
+    "EVAL_N_PER_TASK",
+    "TRAIN_N_PER_TASK",
+    "SEED",
+    "STRATIFIER_VERSION",
+    "cache_key",
+    "get_canonical_indices",
+    "build_all",
+]

code/dataloader/_ablation.py

@@ -0,0 +1,240 @@
+"""Feature-group filter for the 5-step context ablation (A--E).
+
+The ablation isolates the marginal value of each context source on the
+panel-best LLM. Settings nest:
+
+    A: OHLCV only
+    B: A + Fundamentals (XBRL stmt_* + derived_* + shares_outstanding + fullTimeEmployees)
+    C: B + Macro (fred_* + eia_*)
+    D: C + Scenario flags (days_since_filing, filing_8k_count_30d,
+                            news_count_7d, has_press_release_7d)
+    E: D + Filing text (handled in the LLM prompt; numeric features
+                          identical to D)
+
+Only the LLM ablation runs use this filter; classical / sequence / TSFM
+methods always see the full feature set in the main panel results.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+ABLATION_SETTINGS: tuple[str, ...] = ("A", "B", "C", "D", "E")
+
+OHLCV: tuple[str, ...] = (
+    "open", "high", "low", "close", "volume", "adj_close",
+)
+
+# Static fundamentals not following a prefix
+_STATIC_FUNDAMENTALS: tuple[str, ...] = (
+    "shares_outstanding", "fullTimeEmployees",
+)
+
+# Scenario / event flags (proxy for macro-event signal in the panel;
+# the broader 1,130-event scenario layer enters via the prompt for T4
+# and via news/8K density features here).
+SCENARIO_FLAGS: tuple[str, ...] = (
+    "days_since_filing",
+    "filing_8k_count_30d",
+    "news_count_7d",
+    "has_press_release_7d",
+)
+
+
+def _is_fundamentals(name: str) -> bool:
+    return (
+        name.startswith("stmt_")
+        or name.startswith("derived_")
+        or name in _STATIC_FUNDAMENTALS
+    )
+
+
+def _is_macro(name: str) -> bool:
+    return name.startswith("fred_") or name.startswith("eia_")
+
+
+def _is_scenario(name: str) -> bool:
+    return name in SCENARIO_FLAGS
+
+
+def column_mask(feature_names: list[str], setting: str) -> list[bool]:
+    """Return a per-column bool mask for the requested setting.
+
+    The mask is over ``feature_names``; elements set to True are KEPT.
+    """
+    if setting not in ABLATION_SETTINGS:
+        raise ValueError(
+            f"setting must be one of {ABLATION_SETTINGS}, got {setting!r}"
+        )
+
+    keep: list[bool] = []
+    for n in feature_names:
+        if n in OHLCV:
+            keep.append(True)
+            continue
+        if setting == "A":
+            keep.append(False)
+            continue
+        if _is_fundamentals(n):
+            keep.append(True)
+            continue
+        if setting == "B":
+            keep.append(False)
+            continue
+        if _is_macro(n):
+            keep.append(True)
+            continue
+        if setting == "C":
+            keep.append(False)
+            continue
+        if _is_scenario(n):
+            keep.append(True)
+            continue
+        # setting D or E: keep nothing else (unknown columns excluded)
+        keep.append(False)
+    return keep
+
+
+def filter_columns(
+    feature_names: list[str], setting: str,
+) -> list[str]:
+    """Return the kept feature names for ``setting``."""
+    mask = column_mask(feature_names, setting)
+    return [n for n, k in zip(feature_names, mask) if k]
+
+
+def apply_to_t1_array(
+    X: np.ndarray, feature_names: list[str], setting: str,
+) -> tuple[np.ndarray, list[str]]:
+    """Filter T1 ``(N, L, F)`` array to the columns of ``setting``."""
+    if X.ndim != 3:
+        raise ValueError(f"T1 X must be 3D (N,L,F); got shape={X.shape}")
+    if X.shape[2] != len(feature_names):
+        raise ValueError(
+            f"T1 X feature dim {X.shape[2]} != len(feature_names) "
+            f"{len(feature_names)}"
+        )
+    mask = column_mask(feature_names, setting)
+    keep_idx = [i for i, k in enumerate(mask) if k]
+    if not keep_idx:
+        raise RuntimeError(
+            f"setting={setting!r} produced 0 kept columns from "
+            f"{len(feature_names)} features"
+        )
+    new_X = X[:, :, keep_idx].astype(X.dtype, copy=False)
+    new_names = [feature_names[i] for i in keep_idx]
+    return new_X, new_names
+
+
+def apply_to_dataframe(
+    X: pd.DataFrame, setting: str, *, lookback_cell_col: str | None = None,
+) -> pd.DataFrame:
+    """Filter a 2D DataFrame to the columns of ``setting``.
+
+    For T4 the dataframe carries a ``lookback`` cell column whose values
+    are ``(L, F)`` numpy arrays; pass ``lookback_cell_col`` so we can also
+    project the cell-arrays to the same column subset. The prefix-based
+    test on the dataframe's own columns still runs for any side-by-side
+    numeric columns.
+    """
+    df = X.copy()
+
+    if lookback_cell_col and lookback_cell_col in df.columns:
+        # The (L, F) arrays in this column do not carry their feature
+        # names with them. Trust meta.attrs["feature_names"]; resolve at
+        # the call site that has access to it. This branch is wired
+        # through ``apply_to_loaded`` below.
+        pass
+
+    # Project numeric columns if any exist
+    keep = []
+    for c in df.columns:
+        if c in OHLCV:
+            keep.append(c)
+            continue
+        if setting == "A":
+            continue
+        if _is_fundamentals(c):
+            keep.append(c)
+            continue
+        if setting == "B":
+            continue
+        if _is_macro(c):
+            keep.append(c)
+            continue
+        if setting == "C":
+            continue
+        if _is_scenario(c):
+            keep.append(c)
+            continue
+    # Always preserve non-feature object cols (sector dummies, text fields
+    # that the method may consume) by keeping any column that has no
+    # known prefix and is not numeric.
+    extra = [c for c in df.columns if c not in keep and df[c].dtype == object]
+    return df[keep + extra]
+
+
+def apply_to_loaded(
+    loaded: "Any", setting: str,  # type: ignore[name-defined]
+):  # -> LoadedData
+    """Filter a ``LoadedData`` tuple in-place semantics; returns a new tuple.
+
+    Handles the four ablation tasks:
+        T1: 3D ndarray (N, L, F) -- mask axis 2
+        T2 / T5: 2D DataFrame -- drop columns
+        T4: DataFrame with `lookback` cell column -- project each cell
+    """
+    from typing import NamedTuple
+    X, y, meta = loaded
+
+    feat_names = list(meta.attrs.get("feature_names") or [])
+    task = meta.attrs.get("task")
+
+    if task == "T1":
+        new_X, new_names = apply_to_t1_array(X, feat_names, setting)
+        new_meta = meta.copy()
+        new_meta.attrs.update(meta.attrs)
+        new_meta.attrs["feature_names"] = new_names
+        new_meta.attrs["ablation_setting"] = setting
+        return type(loaded)(new_X, y, new_meta)
+
+    if task in ("T2", "T5"):
+        if not isinstance(X, pd.DataFrame):
+            raise TypeError(f"T2/T5 X expected DataFrame, got {type(X)}")
+        new_X = apply_to_dataframe(X, setting)
+        new_meta = meta.copy()
+        new_meta.attrs.update(meta.attrs)
+        new_meta.attrs["feature_names"] = list(new_X.columns)
+        new_meta.attrs["ablation_setting"] = setting
+        return type(loaded)(new_X, y, new_meta)
+
+    if task == "T4":
+        if not isinstance(X, pd.DataFrame):
+            raise TypeError(f"T4 X expected DataFrame, got {type(X)}")
+        if not feat_names:
+            raise RuntimeError(
+                "T4 ablation requires meta.attrs['feature_names'] to be "
+                "set by the loader; was None/empty."
+            )
+        mask = column_mask(feat_names, setting)
+        keep_idx = [i for i, k in enumerate(mask) if k]
+        new_X = X.copy()
+        if "lookback" in new_X.columns:
+            def _project(arr):
+                if arr is None:
+                    return arr
+                if hasattr(arr, "shape") and arr.ndim == 2:
+                    return arr[:, keep_idx]
+                return arr
+            new_X["lookback"] = new_X["lookback"].apply(_project)
+        new_meta = meta.copy()
+        new_meta.attrs.update(meta.attrs)
+        new_meta.attrs["feature_names"] = [feat_names[i] for i in keep_idx]
+        new_meta.attrs["ablation_setting"] = setting
+        return type(loaded)(new_X, y, new_meta)
+
+    raise ValueError(
+        f"Ablation not supported for task={task!r}; "
+        "ABLATION_TASKS = (T1, T2, T4, T5)"
+    )

code/dataloader/_provenance.py

@@ -0,0 +1,44 @@
+"""SHA256 helpers for canonical-indices cache invalidation + result-record
+provenance. Computing the digest of every upstream parquet a loader reads,
+embedded into ``meta.attrs["data_sha256"]``, makes silent dataset drift
+detectable: if a panel parquet mutates, the canonical-indices cache key
+changes and any downstream ``RunRecord`` carries a different hash.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+
+_BUF_SIZE = 1 << 20  # 1 MB
+
+
+def sha256_file(path: str | Path) -> str:
+    """Return the hex SHA-256 of ``path`` (full file)."""
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"sha256_file: {p} does not exist")
+    h = hashlib.sha256()
+    with p.open("rb") as fh:
+        while chunk := fh.read(_BUF_SIZE):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def sha256_dataset(paths: list[str | Path]) -> dict[str, str]:
+    """Return ``{path_str: sha256}`` for every existing path in ``paths``."""
+    return {str(Path(p)): sha256_file(p) for p in paths}
+
+
+def sha256_combined(paths: list[str | Path]) -> str:
+    """Return a single hex digest combining every file in ``paths``.
+
+    Used as a cache-key suffix for canonical-indices: if ANY upstream
+    parquet mutates, the suffix changes and the cache regenerates.
+    """
+    h = hashlib.sha256()
+    for p in sorted(str(Path(x)) for x in paths):
+        sub = sha256_file(p).encode()
+        h.update(p.encode() + b":" + sub + b"\n")
+    return h.hexdigest()[:16]

code/dataloader/budgets.py

@@ -0,0 +1,93 @@
+"""Canonical sample budgets per task.
+
+Single source of truth. Every family runner reads from here so that
+cross-method comparison on each task is fair (same N for every method,
+same instances, same indices).
+
+Normalization principle:
+- Forecasting / regression-with-subsample tasks (T1, T4, T7):
+  N_eval = 1,000 / N_train = 10,000  (stratified subsample from larger pools)
+- Ticker-holdout valuation tasks (T2, T5):
+  N_eval = 1,324 / N_train = 2,673   (full 30% holdout, no subsampling)
+- Filing-level generation tasks (T3, T6):
+  N_eval = 1,058 (some holdout tickers lack complete XBRL); train varies
+
+Sample sizes are intentionally conservative -- ~10x the median peer-benchmark
+scale (CiK 125 / WIT 446 / EDINET 350 / SciTS 1,250) so reviewers cannot
+claim small-sample noise, while keeping LLM eval (4 LLMs x 7 tasks x ~1K
+samples = ~28K calls) tractable on 4xA100 within the wall-clock budget.
+
+The values here are DEFAULTS; runners may override via the
+`get_canonical_indices(task, split, n_eval=..., n_train=...)` keyword
+arguments to regenerate (and re-cache) for a re-tune without rebuilding
+any artifacts.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+
+Task = Literal["T1", "T2", "T3", "T4", "T5", "T6", "T7"]
+
+
+# ── Canonical budgets ─────────────────────────────────────────────────────
+
+EVAL_N_PER_TASK: dict[Task, int] = {
+    "T1": 1_000,   # subsampled (full ~1.3M)
+    "T2": 1_324,   # full 30% ticker holdout
+    "T3": 1_058,   # filing-level holdout (subset of 1,324 with full XBRL)
+    "T4": 1_000,   # subsampled (full ~3M scenario-ticker pairs)
+    "T5": 1_324,   # full 30% ticker holdout
+    "T6": 1_058,   # filing-level holdout
+    "T7": 1_000,   # subsampled (full ~23K properties)
+}
+
+TRAIN_N_PER_TASK: dict[Task, int] = {
+    "T1": 10_000,  # subsampled training windows, sector x mcap_q
+    "T2": 2_673,   # latest snapshot per non-holdout ticker
+    "T3": 9_458,   # prior fiscal years across non-holdout tickers
+    "T4": 10_000,  # subsampled scenario-conditioned windows
+    "T5": 2_673,   # latest snapshot per non-holdout ticker
+    "T6": 1_377,   # prior fiscal years for filing-level holdout
+    "T7": 10_000,  # subsampled training properties, property_type x state
+}
+
+
+# ── Seed + stratifier ─────────────────────────────────────────────────────
+
+SEED: int = 42
+
+# Bumped if the stratifier logic changes (forces cache invalidation
+# without changing N values). Increment when:
+#   - the panel column used for stratification changes
+#   - the per-task stratifier columns change
+#   - the sampler's tie-breaking / fallback logic changes
+STRATIFIER_VERSION: int = 1
+
+
+# ── Cache key derivation ──────────────────────────────────────────────────
+
+def cache_key(
+    *,
+    n_eval: dict[Task, int] | None = None,
+    n_train: dict[Task, int] | None = None,
+    seed: int | None = None,
+    stratifier_version: int | None = None,
+) -> str:
+    """Stable cache-directory name for the (budgets, seed, stratifier) tuple.
+
+    Defaults to the module-level canonical values. Override any subset to
+    generate a non-canonical cache (e.g. a re-tune at N_eval=2000 produces
+    its own cache dir leaving the canonical cache intact).
+    """
+    ne = n_eval or EVAL_N_PER_TASK
+    nt = n_train or TRAIN_N_PER_TASK
+    s = SEED if seed is None else seed
+    sv = STRATIFIER_VERSION if stratifier_version is None else stratifier_version
+
+    # Compact, readable encoding -- avoids sha hashes so the directory
+    # contents are inspectable.
+    eval_str = "-".join(f"{t}={ne[t]}" for t in ("T1", "T2", "T3", "T4", "T5", "T6", "T7"))
+    train_str = "-".join(f"{t}={nt[t]}" for t in ("T1", "T2", "T3", "T4", "T5", "T6", "T7"))
+    return f"seed={s}_strat=v{sv}_eval[{eval_str}]_train[{train_str}]"

code/dataloader/canonical_indices.py

@@ -0,0 +1,569 @@
+"""Canonical-indices generator.
+
+Reads the immutable benchmark artifacts and produces deterministic,
+stratified train/eval index lists per task. Every family runner reads
+from here so cross-method comparison is fair: same N, same instances,
+same indices.
+
+The cache lives under `experiments/cache/canonical_indices/<key>/`
+where `<key>` encodes (n_eval, n_train, seed, stratifier_version) -- so
+changing any sample-budget parameter produces a new cache directory.
+The cache is an experiment-side speed optimisation; the canonical
+dataset tree under `data_small_caps/` contains only raw and derived
+benchmark artifacts (which are immutable).
+
+Per-task stratification:
+  T1 (TSF):       sector x market_cap_quartile        -> (ticker, anchor_date)
+  T2 (Val-PT):    full 30% ticker holdout              -> (ticker, date)
+  T3 (Stmt-Gen):  per-(ticker, fiscal_year) holdout    -> (ticker, fiscal_year)
+  T4 (Scen-Ret):  sector x mcap_q x event_type        -> (scenario_id, ticker)
+  T5 (Val-Priv):  full 30% ticker holdout              -> (ticker, date)
+  T6 (Gen-Eval):  per-(ticker, fiscal_year) holdout    -> (ticker, fiscal_year)
+  T7 (RE-Val):    property_type x state                -> address
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Literal
+
+import numpy as np
+import pandas as pd
+
+from .. import config
+from . import budgets
+from .budgets import EVAL_N_PER_TASK, TRAIN_N_PER_TASK, SEED, Task
+
+logger = logging.getLogger(__name__)
+
+
+Split = Literal["train", "eval"]
+
+
+def _cfg_get_lookback(granularity: str) -> int:
+    """Return the canonical (shortest) lookback for ``granularity``."""
+    return config.get_lookback_windows(granularity)[0] if hasattr(config, "get_lookback_windows") else 63
+
+
+def _provenance_suffix(granularity: str) -> str:
+    """16-char SHA-256-derived suffix encoding the relevant benchmark
+    parquets for ``granularity``. Mutating any of those parquets changes
+    the cache key, forcing canonical-indices regeneration.
+    """
+    from ._provenance import sha256_combined
+
+    bench_dir = config.get_benchmark_dir(granularity)
+    candidates = [
+        bench_dir / "panel_train.parquet",
+        bench_dir / "panel_test.parquet",
+        bench_dir / "valuation_inputs.parquet",
+        bench_dir / "valuation_ground_truth.parquet",
+        bench_dir / "private_valuation_inputs.parquet",
+        bench_dir / "private_valuation_ground_truth.parquet",
+        bench_dir / "generation_inputs.parquet",
+        bench_dir / "generation_ground_truth.parquet",
+        bench_dir / "generator_eval_inputs.parquet",
+        bench_dir / "generator_eval_ground_truth.parquet",
+        bench_dir / "scenario_forecast_ground_truth.parquet",
+        bench_dir / "scenarios.parquet",
+        bench_dir / "re_train_properties.parquet",
+        bench_dir / "re_eval_inputs.parquet",
+        bench_dir / "re_eval_ground_truth.parquet",
+    ]
+    existing = [p for p in candidates if p.exists()]
+    if not existing:
+        return "noprov"
+    return sha256_combined(existing)
+
+
+def _cache_dir(granularity: str, key: str | None = None) -> Path:
+    """Return the cache directory for a given budget key.
+
+    Lives under ``experiments/cache/canonical_indices/`` (experiment-side
+    speed optimisation, regenerable on miss). The canonical dataset tree
+    under ``data_small_caps/`` contains only raw and derived benchmark
+    artifacts; experiment-side caches NEVER live there.
+
+    The cache key suffix encodes (i) a SHA-256 over the benchmark
+    parquets and (ii) the current ``max(lookback)`` and ``max(horizon)``
+    for ``granularity``. Either upstream-data drift or a horizon/lookback
+    config change atomically invalidates the cache.
+    """
+    k = key or budgets.cache_key()
+    suffix = _provenance_suffix(granularity)
+    max_lb = max(config.get_lookback_windows(granularity))
+    max_h = max(config.get_horizons(granularity))
+    # Resolve experiments/ as a sibling of dataloader/ (this file lives
+    # at projects/.../whatif_bench/dataloader/canonical_indices.py).
+    experiments_dir = Path(__file__).resolve().parents[1] / "experiments"
+    return (
+        experiments_dir
+        / "cache"
+        / "canonical_indices"
+        / granularity
+        / f"{k}_prov={suffix}_lb={max_lb}_h={max_h}"
+    )
+
+
+def _stratified_sample(
+    df: pd.DataFrame,
+    n: int,
+    strata_cols: list[str],
+    seed: int,
+) -> pd.DataFrame:
+    """Stratified subsample of `df` to size `n`, preserving the joint
+    distribution of `strata_cols` (Cartesian-product strata, with
+    proportional allocation and remainder spread by row order).
+
+    Deterministic at fixed `seed`. If `n >= len(df)`, returns df shuffled.
+    """
+    if n >= len(df):
+        return df.sample(frac=1.0, random_state=seed).reset_index(drop=True)
+
+    # Drop rows with NaN in any stratifier column -- they would form a
+    # spurious "missing" stratum.
+    valid_mask = df[strata_cols].notna().all(axis=1)
+    df_valid = df[valid_mask].copy()
+    if df_valid.empty:
+        # Fall back to uniform random
+        return df.sample(n=n, random_state=seed).reset_index(drop=True)
+
+    df_valid["_stratum"] = df_valid[strata_cols].astype(str).agg("|".join, axis=1)
+
+    rng = np.random.RandomState(seed)
+    out_rows: list[pd.DataFrame] = []
+    total = len(df_valid)
+
+    for stratum, grp in df_valid.groupby("_stratum"):
+        # Proportional allocation; at least 1 if stratum has rows.
+        q = max(1, round(len(grp) * n / total))
+        q = min(q, len(grp))
+        out_rows.append(grp.sample(n=q, random_state=rng.randint(0, 2**31 - 1)))
+
+    out = pd.concat(out_rows, ignore_index=True)
+    # Trim or top-up to exactly n
+    if len(out) > n:
+        out = out.sample(n=n, random_state=seed).reset_index(drop=True)
+    elif len(out) < n:
+        # Top up with non-selected rows (still stratified by selection above)
+        remaining = df_valid.loc[~df_valid.index.isin(out.index)]
+        extra = remaining.sample(n=min(n - len(out), len(remaining)), random_state=seed)
+        out = pd.concat([out, extra], ignore_index=True)
+
+    return out.drop(columns=["_stratum"]).reset_index(drop=True)
+
+
+# ── Per-task generators ───────────────────────────────────────────────────
+
+
+def _gen_t1(
+    granularity: str,
+    n_eval: int,
+    n_train: int,
+    seed: int,
+) -> dict[Split, pd.DataFrame]:
+    """T1 TSF: stratified by sector x market_cap_quartile.
+
+    Each (ticker, anchor_date) pair must admit a complete
+    ``(lookback, max_horizon)`` window inside the corresponding split's panel,
+    so every horizon evaluated by every T1 runner reuses the same anchor set.
+    Concretely, for a ticker with ``T`` panel rows we keep only anchor dates
+    at per-ticker positions ``[lookback, T - max_horizon - 1]``.
+
+    Returns DataFrames with columns (ticker, anchor_date, sector, mcap_q).
+    """
+    from .. import config as _cfg
+
+    # Build the canonical anchor pool against the SHORTEST lookback and
+    # the LONGEST horizon. The test panel (post-2024-09-03) is ~378
+    # trading days; pairing max_lookback (252) with max_horizon (252)
+    # exhausts it. Methods that want a longer lookback can request it
+    # at load time (load(..., lookback=252)); anchors with insufficient
+    # history will be dropped by _build_t1_x_y and counted in
+    # ``meta.attrs["n_canonical_dropped"]``.
+    lookback = _cfg.get_lookback_windows(granularity)[0]
+    max_horizon = max(_cfg.get_horizons(granularity))
+
+    bench_dir = config.get_benchmark_dir(granularity)
+    train = pd.read_parquet(
+        bench_dir / "panel_train.parquet",
+        columns=["ticker", "date", "sector", "derived_market_cap"],
+    )
+    test = pd.read_parquet(
+        bench_dir / "panel_test.parquet",
+        columns=["ticker", "date", "sector", "derived_market_cap"],
+    )
+
+    # Latest market_cap per ticker for the quartile assignment (across the
+    # full panel, so train and eval split on the same definition).
+    latest = (
+        pd.concat([train, test], ignore_index=True)
+        .sort_values("date")
+        .groupby("ticker")
+        .tail(1)[["ticker", "derived_market_cap"]]
+    )
+    latest["mcap_q"] = pd.qcut(
+        latest["derived_market_cap"].clip(lower=1),
+        4, labels=["Q1", "Q2", "Q3", "Q4"], duplicates="drop",
+    )
+    mcap_q = dict(zip(latest["ticker"], latest["mcap_q"]))
+
+    def _restrict_to_valid_anchors(df: pd.DataFrame) -> pd.DataFrame:
+        """Keep only rows at per-ticker positions [lookback, T-max_horizon-1]
+        so a complete (lookback + max_horizon) window fits."""
+        df = df.sort_values(["ticker", "date"]).reset_index(drop=True)
+        df["_row_in_ticker"] = df.groupby("ticker", sort=False).cumcount()
+        df["_ticker_len"] = df.groupby("ticker", sort=False)["date"].transform("size")
+        valid = (df["_row_in_ticker"] >= lookback) & (
+            df["_row_in_ticker"] < df["_ticker_len"] - max_horizon
+        )
+        return df.loc[valid].drop(columns=["_row_in_ticker", "_ticker_len"])
+
+    out: dict[Split, pd.DataFrame] = {}
+    for split, df in (("train", train), ("eval", test)):
+        df = _restrict_to_valid_anchors(df)
+        df = df.rename(columns={"date": "anchor_date"}).copy()
+        df["mcap_q"] = df["ticker"].map(mcap_q)
+        n = n_train if split == "train" else n_eval
+        sampled = _stratified_sample(df, n, ["sector", "mcap_q"], seed)
+        out[split] = sampled[["ticker", "anchor_date", "sector", "mcap_q"]]
+    return out
+
+
+def _gen_t2_t5(
+    granularity: str,
+    task: str,
+    n_eval: int,
+    n_train: int,
+    seed: int,
+) -> dict[Split, pd.DataFrame]:
+    """T2 (Val-PT) and T5 (Val-Priv): full 30% ticker holdout for eval;
+    latest snapshot per non-holdout ticker for train.
+
+    Returns DataFrames with columns (ticker, date).
+    """
+    bench_dir = config.get_benchmark_dir(granularity)
+    if task == "T2":
+        inputs_path = bench_dir / "valuation_inputs.parquet"
+        gt_path = bench_dir / "valuation_ground_truth.parquet"
+    else:
+        inputs_path = bench_dir / "private_valuation_inputs.parquet"
+        gt_path = bench_dir / "private_valuation_ground_truth.parquet"
+    inputs = pd.read_parquet(inputs_path, columns=["ticker", "date", "sector"])
+    gt = pd.read_parquet(gt_path, columns=["ticker", "date"])
+
+    # Restrict the eval pool to (ticker, date) pairs that are present in
+    # BOTH inputs and gt. Without this, ~21 quarter-end snapshots per
+    # task have inputs but no gt (close or shares_outstanding missing
+    # on that date), and the loader silently dropped them at merge
+    # time so canonical-eval N came up short of the budget.
+    inputs["date"] = pd.to_datetime(inputs["date"])
+    gt["date"] = pd.to_datetime(gt["date"])
+    eval_pool = inputs.merge(gt, on=["ticker", "date"], how="inner")
+
+    train_panel = pd.read_parquet(
+        bench_dir / "panel_train.parquet",
+        columns=["ticker", "date", "sector"],
+    )
+
+    holdout_tickers = set(inputs["ticker"].unique())
+    non_holdout = train_panel[~train_panel["ticker"].isin(holdout_tickers)]
+    # Latest snapshot per non-holdout ticker as the train set.
+    train_latest = (
+        non_holdout.sort_values("date").groupby("ticker").tail(1)
+        .reset_index(drop=True)
+    )
+
+    rng = np.random.RandomState(seed)
+    train_idx = train_latest.sample(
+        n=min(n_train, len(train_latest)), random_state=rng.randint(0, 2**31 - 1),
+    ).reset_index(drop=True)
+
+    eval_idx = eval_pool.sample(
+        n=min(n_eval, len(eval_pool)), random_state=rng.randint(0, 2**31 - 1),
+    ).reset_index(drop=True)
+
+    return {"train": train_idx, "eval": eval_idx}
+
+
+def _gen_t3_t6(
+    granularity: str,
+    task: str,
+    n_eval: int,
+    n_train: int,
+    seed: int,
+) -> dict[Split, pd.DataFrame]:
+    """T3 (Stmt-Gen) and T6 (Gen-Eval): per-(ticker, fiscal_year) split.
+
+    Every ticker in the per-task ground-truth file is also in the
+    holdout (`*_inputs.parquet` lists holdout tickers only), so a
+    plain ``~ticker.isin(holdout)`` train pool would always be empty.
+    Instead: per ticker, the **latest** fiscal year is the eval anchor
+    and **earlier** fiscal years are train anchors. Train-eval are
+    cleanly separated by fiscal year within ticker; both pools are
+    non-empty as long as a ticker has >=2 reported fiscal years.
+
+    Eval = unique (ticker, latest_fiscal_year) pairs across all tickers.
+    Train = unique (ticker, prior_fiscal_year) pairs across all tickers.
+    """
+    bench_dir = config.get_benchmark_dir(granularity)
+    if task == "T3":
+        gt_path = bench_dir / "generation_ground_truth.parquet"
+    else:
+        gt_path = bench_dir / "generator_eval_ground_truth.parquet"
+
+    gt = pd.read_parquet(gt_path)
+    if "fiscal_year" not in gt.columns:
+        if "filing_date" in gt.columns:
+            gt["fiscal_year"] = pd.to_datetime(gt["filing_date"]).dt.year
+        else:
+            gt["fiscal_year"] = 0
+
+    pairs = gt[["ticker", "fiscal_year"]].drop_duplicates().reset_index(drop=True)
+    pairs["fiscal_year"] = pd.to_numeric(pairs["fiscal_year"], errors="coerce")
+    pairs = pairs.dropna(subset=["fiscal_year"]).copy()
+    pairs["fiscal_year"] = pairs["fiscal_year"].astype(int)
+
+    # Per-ticker: latest FY -> eval, earlier FYs -> train
+    pairs = pairs.sort_values(["ticker", "fiscal_year"]).reset_index(drop=True)
+    pairs["_rank_desc"] = pairs.groupby("ticker")["fiscal_year"].rank(
+        method="first", ascending=False,
+    )
+    eval_pairs = pairs[pairs["_rank_desc"] == 1][["ticker", "fiscal_year"]]
+    train_pairs = pairs[pairs["_rank_desc"] > 1][["ticker", "fiscal_year"]]
+
+    rng = np.random.RandomState(seed)
+    eval_idx = eval_pairs.sample(
+        n=min(n_eval, len(eval_pairs)), random_state=rng.randint(0, 2**31 - 1),
+    ).reset_index(drop=True)
+    train_idx = train_pairs.sample(
+        n=min(n_train, len(train_pairs)), random_state=rng.randint(0, 2**31 - 1),
+    ).reset_index(drop=True)
+
+    return {"train": train_idx, "eval": eval_idx}
+
+
+def _gen_t4(
+    granularity: str,
+    n_eval: int,
+    n_train: int,
+    seed: int,
+) -> dict[Split, pd.DataFrame]:
+    """T4 Scen-Ret: stratified by sector x mcap_q x event_type.
+
+    Returns DataFrames with columns (scenario_id, ticker, event_type).
+    """
+    bench_dir = config.get_benchmark_dir(granularity)
+    gt = pd.read_parquet(
+        bench_dir / "scenario_forecast_ground_truth.parquet",
+        columns=["scenario_id", "ticker", "event_type", "event_date",
+                 "actual_return_pct"],
+    )
+    gt = gt.dropna(subset=["actual_return_pct"])
+
+    # Use the panel-train cutoff as the train/eval split anchor (matches
+    # the canonical T1 split semantics).
+    panel_train_df = pd.read_parquet(
+        bench_dir / "panel_train.parquet", columns=["ticker", "date"],
+    )
+    panel_test_df = pd.read_parquet(
+        bench_dir / "panel_test.parquet", columns=["ticker", "date"],
+    )
+    panel_train_df["date"] = pd.to_datetime(panel_train_df["date"])
+    panel_test_df["date"] = pd.to_datetime(panel_test_df["date"])
+    split_date = panel_train_df["date"].max()
+    gt["event_date"] = pd.to_datetime(gt["event_date"])
+
+    # Restrict the eval/train pools to events whose ticker has at least
+    # ``min_history`` panel days BEFORE the event date in the combined
+    # panel. Without this filter, ~6.5% of train events sampled at the
+    # canonical step cannot produce a valid 63-day lookback at load
+    # time and were silently zero-padded then dropped.
+    min_history = max(_cfg_get_lookback(granularity), 63)
+    panel_full = pd.concat([panel_train_df, panel_test_df], ignore_index=True)
+    panel_full = panel_full.drop_duplicates(subset=["ticker", "date"])
+    panel_dates_per_ticker = (
+        panel_full.sort_values(["ticker", "date"]).groupby("ticker")["date"]
+    )
+    first_panel_date = panel_dates_per_ticker.first().to_dict()
+
+    def _has_lookback_history(row) -> bool:
+        first = first_panel_date.get(row["ticker"])
+        if first is None:
+            return False
+        # need at least min_history trading-day rows prior (use calendar
+        # days as a fast upper bound: 252 trading days ~ 365 calendar days).
+        return (row["event_date"] - first).days >= int(min_history * 1.45)
+
+    gt = gt[gt.apply(_has_lookback_history, axis=1)].copy()
+
+    train_pool = gt[gt["event_date"] <= split_date].copy()
+    eval_pool = gt[gt["event_date"] > split_date].copy()
+
+    # Sector and mcap_q come from the panel (across full date range).
+    full_panel = pd.read_parquet(
+        bench_dir / "panel_train.parquet",
+        columns=["ticker", "sector", "derived_market_cap"],
+    )
+    latest = full_panel.groupby("ticker").tail(1)[["ticker", "sector", "derived_market_cap"]]
+    latest["mcap_q"] = pd.qcut(
+        latest["derived_market_cap"].clip(lower=1),
+        4, labels=["Q1", "Q2", "Q3", "Q4"], duplicates="drop",
+    )
+    sector_map = dict(zip(latest["ticker"], latest["sector"]))
+    mcap_map = dict(zip(latest["ticker"], latest["mcap_q"]))
+
+    out: dict[Split, pd.DataFrame] = {}
+    for split, pool in (("train", train_pool), ("eval", eval_pool)):
+        pool = pool.copy()
+        pool["sector"] = pool["ticker"].map(sector_map)
+        pool["mcap_q"] = pool["ticker"].map(mcap_map)
+        n = n_train if split == "train" else n_eval
+        sampled = _stratified_sample(
+            pool, n, ["sector", "mcap_q", "event_type"], seed,
+        )
+        out[split] = sampled[["scenario_id", "ticker", "event_type"]]
+    return out
+
+
+def _gen_t7(
+    granularity: str,
+    n_eval: int,
+    n_train: int,
+    seed: int,
+) -> dict[Split, pd.DataFrame]:
+    """T7 RE-Val: stratified by property_type x state."""
+    bench_dir = config.get_benchmark_dir(granularity)
+    train = pd.read_parquet(bench_dir / "re_train_properties.parquet")
+    eval_in = pd.read_parquet(bench_dir / "re_eval_inputs.parquet")
+    # ``re_train_properties`` carries 854 duplicate-address rows from
+    # multiple RentCast variants of the same listing. Dedup BEFORE
+    # sampling so the canonical eval set has unique addresses (the
+    # loader otherwise dedups, leaving the canon n short of budget).
+    if "address" in train.columns:
+        train = train.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
+    if "address" in eval_in.columns:
+        eval_in = eval_in.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
+
+    def _sample(df: pd.DataFrame, n: int) -> pd.DataFrame:
+        ptype_col = next(
+            (c for c in ("property_type", "propertyType", "type") if c in df.columns),
+            None,
+        )
+        state_col = next(
+            (c for c in ("state", "State") if c in df.columns), None,
+        )
+        addr_col = next(
+            (c for c in ("address", "addressLine1", "Address") if c in df.columns),
+            None,
+        )
+        strata = [c for c in (ptype_col, state_col) if c is not None]
+        if not strata or addr_col is None:
+            return df.sample(n=min(n, len(df)), random_state=seed).reset_index(drop=True)
+        sampled = _stratified_sample(df, n, strata, seed)
+        cols_to_keep = [addr_col] + strata
+        return sampled[cols_to_keep].rename(columns={addr_col: "address"})
+
+    return {"train": _sample(train, n_train), "eval": _sample(eval_in, n_eval)}
+
+
+_GENERATORS = {
+    "T1": _gen_t1,
+    "T2": lambda g, ne, nt, s: _gen_t2_t5(g, "T2", ne, nt, s),
+    "T3": lambda g, ne, nt, s: _gen_t3_t6(g, "T3", ne, nt, s),
+    "T4": _gen_t4,
+    "T5": lambda g, ne, nt, s: _gen_t2_t5(g, "T5", ne, nt, s),
+    "T6": lambda g, ne, nt, s: _gen_t3_t6(g, "T6", ne, nt, s),
+    "T7": _gen_t7,
+}
+
+
+# ── Public API ────────────────────────────────────────────────────────────
+
+
+def get_canonical_indices(
+    task: Task,
+    split: Split = "eval",
+    *,
+    granularity: str = "daily",
+    n_eval: dict[Task, int] | None = None,
+    n_train: dict[Task, int] | None = None,
+    seed: int | None = None,
+) -> pd.DataFrame:
+    """Return the canonical index list for `(task, split)`.
+
+    Reads from cache if available; otherwise generates, persists to cache,
+    and returns. The cache key encodes (n_eval, n_train, seed,
+    stratifier_version) so non-canonical re-tunes get their own cache dir.
+
+    Smoke-mode override: when ``MACROLENS_N_TRAIN`` and / or
+    ``MACROLENS_N_EVAL`` env vars are set (positive int), they replace the
+    default budget for every task in this call. This lets the runner do an
+    end-to-end smoke (e.g. n_train=2, n_eval=1 across all 22 methods × 7
+    tasks) without touching the canonical cache or the CLI signature.
+    Explicit ``n_eval`` / ``n_train`` kwargs still take precedence.
+    """
+    import os as _os
+    env_n_eval = _os.environ.get("MACROLENS_N_EVAL")
+    env_n_train = _os.environ.get("MACROLENS_N_TRAIN")
+    if n_eval is None and env_n_eval is not None:
+        try:
+            v = int(env_n_eval)
+            if v > 0:
+                n_eval = {t: v for t in EVAL_N_PER_TASK}
+        except ValueError:
+            pass
+    if n_train is None and env_n_train is not None:
+        try:
+            v = int(env_n_train)
+            if v > 0:
+                n_train = {t: v for t in TRAIN_N_PER_TASK}
+        except ValueError:
+            pass
+    n_eval_map = n_eval or EVAL_N_PER_TASK
+    n_train_map = n_train or TRAIN_N_PER_TASK
+    s = SEED if seed is None else seed
+
+    key = budgets.cache_key(n_eval=n_eval_map, n_train=n_train_map, seed=s)
+    cache_dir = _cache_dir(granularity, key)
+    cache_path = cache_dir / f"{split}_{task}.parquet"
+
+    if cache_path.exists():
+        return pd.read_parquet(cache_path)
+
+    # Cache miss: generate both splits for this task and persist.
+    gen = _GENERATORS[task]
+    pair = gen(granularity, n_eval_map[task], n_train_map[task], s)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    for sp, df in pair.items():
+        df.to_parquet(cache_dir / f"{sp}_{task}.parquet", index=False)
+        logger.info(
+            "Canonical-indices cache write: %s (%d rows)",
+            cache_dir / f"{sp}_{task}.parquet", len(df),
+        )
+
+    return pair[split]
+
+
+def build_all(
+    granularity: str = "daily",
+    *,
+    n_eval: dict[Task, int] | None = None,
+    n_train: dict[Task, int] | None = None,
+    seed: int | None = None,
+) -> dict[str, int]:
+    """Build canonical indices for every (task, split) pair.
+
+    Returns a summary dict mapping `<task>_<split>` -> n_rows. Idempotent:
+    re-running with the same budgets is a no-op (cache hits).
+    """
+    summary: dict[str, int] = {}
+    for task in ("T1", "T2", "T3", "T4", "T5", "T6", "T7"):
+        for split in ("train", "eval"):
+            df = get_canonical_indices(
+                task, split, granularity=granularity,
+                n_eval=n_eval, n_train=n_train, seed=seed,
+            )
+            summary[f"{task}_{split}"] = len(df)
+    return summary

code/dataloader/load.py

@@ -0,0 +1,684 @@
+"""Canonical data loader for the MacroLens benchmark.
+
+Sklearn-style: every call to ``load(task, split)`` returns a
+``LoadedData = NamedTuple[X, y, meta]`` triple. Train and test schemas are
+identical for every task (the v0.1 T2/T5 schema-mismatch bug is fixed
+here). Methods MUST consume only ``X`` (and at fit time, ``y``); they
+must NOT consume ``meta``. The runner uses ``meta`` to join predictions
+back to canonical keys.
+
+Per-task contract (definitive):
+
+* T1 (TSF):       X = (N, lookback, F) float32, y = (N, horizon) float32
+* T2 (Val-PT):    X = pd.DataFrame, y = (N,) float32 actual_market_cap
+* T3 (Stmt-Gen):  X = pd.DataFrame keyed by (ticker, fiscal_year),
+                  y = long-form pd.DataFrame[ticker, fiscal_year, field, value]
+* T4 (Scen-Ret):  X = pd.DataFrame[lookback (object), event_type, event_description],
+                  y = (N,) float32 return_pct
+* T5 (Val-Priv):  same shape as T2; price-derived inputs stripped
+* T6 (Gen-Eval):  same shape as T3; X has no stmt_*, only NL company_description
+* T7 (RE-Val):    X = pd.DataFrame[property attrs],
+                  y = pd.DataFrame[address, rent, price]
+
+``meta.attrs`` is populated by every loader with::
+
+    {
+        "task": str, "split": str, "granularity": str,
+        "lookback": int | None, "horizon": int | None,
+        "feature_names": list[str],            # T1 / T4 only (lookback panel column names)
+        "schema_version": int,
+        "data_sha256": dict[str, str],         # SHA-256 of every upstream parquet read
+        "n_canonical_dropped": int,            # canonical anchors lost (T1 only); RuntimeError if > 1%
+    }
+"""
+
+from __future__ import annotations
+
+from typing import Any, NamedTuple
+
+import numpy as np
+import pandas as pd
+
+from .. import config
+from ._provenance import sha256_dataset
+from .canonical_indices import get_canonical_indices
+
+
+_LOADED_DATA_SCHEMA_VERSION = 2
+
+
+# Curated dense-field panel for T3 (Stmt-Gen). The released T3 ground truth
+# parquet carries the full XBRL field universe (~10K tags, ~467K rows), but
+# long-tail company-extension tags appear in only 1–2 (ticker, fiscal_year)
+# pairs each, which makes whole-universe scoring scientifically meaningless.
+# We project T3's `y` to the same 11 standard XBRL line items released in
+# T6's curated panel. Projection lives in the loader; the on-disk parquet
+# is untouched.
+_T3_DENSE_FIELDS = frozenset({
+    "Assets",
+    "Liabilities",
+    "StockholdersEquity",
+    "Revenues",
+    "NetIncomeLoss",
+    "OperatingIncomeLoss",
+    "CashAndCashEquivalentsAtCarryingValue",
+    "PropertyPlantAndEquipmentNet",
+    "LongTermDebt",
+    "ResearchAndDevelopmentExpense",
+    "NetCashProvidedByUsedInOperatingActivities",
+})
+
+
+# ── Public NamedTuple ─────────────────────────────────────────────────────
+
+
+class LoadedData(NamedTuple):
+    """Sklearn-style ``(X, y, meta)`` triple returned by :func:`load`."""
+
+    X: Any
+    y: Any
+    meta: pd.DataFrame
+
+
+# ── Public entrypoint ─────────────────────────────────────────────────────
+
+
+def load(
+    task: str,
+    split: str,
+    *,
+    granularity: str = "daily",
+    lookback: int | None = None,
+    horizon: int | None = None,
+    setting: str | None = None,
+) -> LoadedData:
+    """Load canonical task data for one ``(task, split)``. Identical across methods.
+
+    ``setting`` (optional, one of ``"A".."E"``) projects the panel feature
+    space to the named ablation tier. Applies only to T1, T2, T4, T5.
+    """
+    if split not in ("train", "test"):
+        raise ValueError(f"split must be 'train' or 'test', got {split!r}")
+    canon_split = "eval" if split == "test" else "train"
+
+    if lookback is None:
+        lookback = config.get_lookback_windows(granularity)[0]
+    if horizon is None:
+        # Use the LONGEST horizon as the default (e.g. daily 63 trading days):
+        # the headline T1 evaluation horizon per the project plan.
+        horizon = config.get_horizons(granularity)[-1]
+
+    if task == "T1":
+        loaded = _load_t1(canon_split, split, granularity, lookback, horizon)
+    elif task in ("T2", "T5"):
+        loaded = _load_t2_t5(task, canon_split, split, granularity)
+    elif task in ("T3", "T6"):
+        loaded = _load_t3_t6(task, canon_split, split, granularity)
+    elif task == "T4":
+        loaded = _load_t4(canon_split, split, granularity, lookback)
+    elif task == "T7":
+        loaded = _load_t7(canon_split, split, granularity)
+    else:
+        raise ValueError(f"Unknown task: {task!r}")
+
+    if setting is not None:
+        from ._ablation import apply_to_loaded, ABLATION_SETTINGS
+        if setting not in ABLATION_SETTINGS:
+            raise ValueError(
+                f"setting must be one of {ABLATION_SETTINGS} or None, "
+                f"got {setting!r}"
+            )
+        if task in ("T3", "T6", "T7"):
+            raise ValueError(
+                f"Ablation setting={setting!r} not supported for task={task!r}; "
+                "ABLATION_TASKS = (T1, T2, T4, T5)"
+            )
+        loaded = apply_to_loaded(loaded, setting)
+    return loaded
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────
+
+
+def _panel_path(granularity: str, split: str) -> str:
+    bench_dir = config.get_benchmark_dir(granularity)
+    return str(bench_dir / f"panel_{split}.parquet")
+
+
+def _set_meta_attrs(
+    meta: pd.DataFrame,
+    *,
+    task: str,
+    split: str,
+    granularity: str,
+    parquets_read: list,
+    lookback: int | None = None,
+    horizon: int | None = None,
+    feature_names: list[str] | None = None,
+    n_canonical_dropped: int = 0,
+) -> None:
+    meta.attrs.update({
+        "task": task,
+        "split": split,
+        "granularity": granularity,
+        "lookback": lookback,
+        "horizon": horizon,
+        "feature_names": list(feature_names) if feature_names is not None else None,
+        "schema_version": _LOADED_DATA_SCHEMA_VERSION,
+        "data_sha256": sha256_dataset([str(p) for p in parquets_read]),
+        "n_canonical_dropped": n_canonical_dropped,
+    })
+
+
+# ── T1 ────────────────────────────────────────────────────────────────────
+
+
+def _build_t1_x_y(
+    panel: pd.DataFrame,
+    canon: pd.DataFrame,
+    lookback: int,
+    horizon: int,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, list[str], np.ndarray]:
+    """Build T1 ``(X, y, close_last, feat_names, keep_rows)`` given the
+    canonical anchor pairs.
+    """
+    panel = panel.sort_values(["ticker", "date"]).reset_index(drop=True)
+    panel["date"] = pd.to_datetime(panel["date"])
+
+    exclude = {
+        "ticker", "date", "label", "split",
+        "nearest_filing_type", "nearest_filing_date", "nearest_filing_path",
+    }
+    feat_cols = [
+        c for c in panel.columns
+        if c not in exclude and panel[c].dtype.kind in "fiub"
+    ]
+
+    per_ticker_feats: dict[str, np.ndarray] = {}
+    per_ticker_close: dict[str, np.ndarray] = {}
+    per_ticker_dates: dict[str, np.ndarray] = {}
+    for ticker, grp in panel.groupby("ticker", sort=False):
+        per_ticker_feats[str(ticker)] = grp[feat_cols].values.astype(np.float32)
+        per_ticker_close[str(ticker)] = grp["close"].values.astype(np.float32)
+        per_ticker_dates[str(ticker)] = grp["date"].values.astype("datetime64[ns]")
+
+    canon = canon.copy()
+    canon["ticker"] = canon["ticker"].astype(str)
+    canon["anchor_date"] = pd.to_datetime(canon["anchor_date"]).values.astype("datetime64[ns]")
+
+    X_list, y_list, cl_list, keep_rows = [], [], [], []
+    for i, (ticker, anchor) in enumerate(zip(canon["ticker"].values, canon["anchor_date"].values)):
+        feats = per_ticker_feats.get(ticker)
+        if feats is None:
+            continue
+        dates = per_ticker_dates[ticker]
+        close = per_ticker_close[ticker]
+        idx = np.searchsorted(dates, anchor)
+        if idx >= len(dates) or dates[idx] != anchor:
+            continue
+        if idx + 1 < lookback or idx + horizon >= len(dates):
+            continue
+        lb = feats[idx - lookback + 1 : idx + 1]
+        tg = close[idx + 1 : idx + 1 + horizon]
+        if lb.shape != (lookback, len(feat_cols)) or tg.shape != (horizon,):
+            continue
+        X_list.append(lb)
+        y_list.append(tg)
+        cl_list.append(float(close[idx]))
+        keep_rows.append(i)
+
+    if not X_list:
+        raise RuntimeError(
+            f"T1 loader produced 0 windows from {len(canon)} canonical anchors; "
+            "panel and canonical-index cache are out of sync."
+        )
+
+    X = np.stack(X_list, axis=0)
+    y = np.stack(y_list, axis=0)
+    cl = np.array(cl_list, dtype=np.float32)
+    return X, y, cl, feat_cols, np.array(keep_rows, dtype=np.int64)
+
+
+def _load_t1(
+    canon_split: str,
+    out_split: str,
+    granularity: str,
+    lookback: int,
+    horizon: int,
+) -> LoadedData:
+    canon = get_canonical_indices("T1", canon_split, granularity=granularity)
+    if canon.empty:
+        raise RuntimeError(f"Canonical T1/{canon_split} index set is empty.")
+
+    panel_path = _panel_path(granularity, out_split)
+    panel = pd.read_parquet(panel_path)
+    X, y, close_last, feat_cols, keep_rows = _build_t1_x_y(panel, canon, lookback, horizon)
+
+    n_dropped = len(canon) - len(keep_rows)
+    drop_frac = n_dropped / max(1, len(canon))
+    if drop_frac > 0.01:
+        raise RuntimeError(
+            f"T1/{out_split} loader dropped {n_dropped}/{len(canon)} canonical "
+            f"anchors ({drop_frac:.1%} > 1% tolerance). The canonical generator "
+            "and the benchmark panel are out of sync; rebuild the canonical-indices "
+            "cache or fix the benchmark parquet."
+        )
+
+    meta = canon.iloc[keep_rows][["ticker", "anchor_date", "sector", "mcap_q"]].copy()
+    meta["close_last"] = close_last
+    meta = meta.reset_index(drop=True)
+    _set_meta_attrs(
+        meta, task="T1", split=out_split, granularity=granularity,
+        parquets_read=[panel_path], lookback=lookback, horizon=horizon,
+        feature_names=feat_cols, n_canonical_dropped=n_dropped,
+    )
+    return LoadedData(X=X, y=y, meta=meta)
+
+
+# ── T2 / T5 ───────────────────────────────────────────────────────────────
+
+
+def _t2_t5_paths(task: str, granularity: str):
+    bench_dir = config.get_benchmark_dir(granularity)
+    if task == "T2":
+        return bench_dir / "valuation_inputs.parquet", bench_dir / "valuation_ground_truth.parquet"
+    return bench_dir / "private_valuation_inputs.parquet", bench_dir / "private_valuation_ground_truth.parquet"
+
+
+def _load_t2_t5(
+    task: str, canon_split: str, out_split: str, granularity: str,
+) -> LoadedData:
+    canon = get_canonical_indices(task, canon_split, granularity=granularity)
+    if canon.empty:
+        raise RuntimeError(f"Canonical {task}/{canon_split} index set is empty.")
+
+    inputs_path, gt_path = _t2_t5_paths(task, granularity)
+    panel_train_path = _panel_path(granularity, "train")
+    panel_test_path = _panel_path(granularity, "test")
+
+    inputs = pd.read_parquet(inputs_path)
+    gt = pd.read_parquet(gt_path)
+    inputs["date"] = pd.to_datetime(inputs["date"])
+    gt["date"] = pd.to_datetime(gt["date"])
+    canon = canon.copy()
+    canon["date"] = pd.to_datetime(canon["date"])
+
+    parquets_read: list = [inputs_path, gt_path]
+
+    # Schema = inputs-file columns + macro snapshot (fred_*/eia_*) joined
+    # from the panel. The construction pipeline emits identical macro
+    # columns in panel_train and panel_test, so the train/test schemas
+    # match exactly after the merge.
+    inputs_feature_cols = [c for c in inputs.columns if c not in {"ticker", "date"}]
+    panel_train = pd.read_parquet(panel_train_path)
+    panel_train["date"] = pd.to_datetime(panel_train["date"])
+    parquets_read.append(panel_train_path)
+    macro_cols = sorted([
+        c for c in panel_train.columns
+        if c.startswith("fred_") or c.startswith("eia_")
+    ])
+    feature_cols = inputs_feature_cols + macro_cols
+
+    if out_split == "train":
+        # panel_train carries both the inputs-file columns AND the macro
+        # snapshot, so a single inner merge populates everything.
+        canon_keep = ["ticker", "date"]
+        present = [c for c in inputs_feature_cols if c in panel_train.columns]
+        missing = [c for c in inputs_feature_cols if c not in panel_train.columns]
+
+        merged = canon[canon_keep].merge(
+            panel_train[["ticker", "date", *present, *macro_cols]],
+            on=["ticker", "date"], how="inner",
+        )
+        for c in missing:
+            merged[c] = np.nan
+
+        # Train labels: derived_market_cap from panel_train (already merged).
+        if "derived_market_cap" in panel_train.columns:
+            mcap = canon.merge(
+                panel_train[["ticker", "date", "derived_market_cap"]],
+                on=["ticker", "date"], how="inner",
+            )["derived_market_cap"]
+            y_series = pd.to_numeric(mcap, errors="coerce").reset_index(drop=True)
+        else:
+            raise RuntimeError(
+                f"{task}/train: panel_train has no derived_market_cap column"
+            )
+    else:
+        # Test side: inputs file does not carry fred_*/eia_*; left-join
+        # the macro snapshot from the panel. T2/T5 use a company-level
+        # holdout (not chronological), so a holdout-ticker's anchor date
+        # can fall in either the pre- or post-cutoff window. Union both
+        # panels so the macro lookup covers the full 2021–2026 range.
+        panel_test = pd.read_parquet(panel_test_path)
+        panel_test["date"] = pd.to_datetime(panel_test["date"])
+        parquets_read.append(panel_test_path)
+        macro_present_train = [c for c in macro_cols if c in panel_train.columns]
+        macro_present_test = [c for c in macro_cols if c in panel_test.columns]
+        macro_present = sorted(set(macro_present_train) & set(macro_present_test))
+        macro_lookup = pd.concat([
+            panel_train[["ticker", "date", *macro_present]],
+            panel_test[["ticker", "date", *macro_present]],
+        ], ignore_index=True).drop_duplicates(
+            subset=["ticker", "date"], keep="first",
+        )
+        merged = canon[["ticker", "date"]].merge(
+            inputs, on=["ticker", "date"], how="inner",
+        ).merge(
+            gt[["ticker", "date", "actual_market_cap"]],
+            on=["ticker", "date"], how="inner",
+        ).merge(
+            macro_lookup, on=["ticker", "date"], how="left",
+        )
+        for c in macro_cols:
+            if c not in merged.columns:
+                merged[c] = np.nan
+        y_series = pd.to_numeric(
+            merged.pop("actual_market_cap"), errors="coerce",
+        ).reset_index(drop=True)
+
+    if merged.empty:
+        raise RuntimeError(
+            f"{task}/{out_split} loader: zero rows after canonical join."
+        )
+
+    # Project to the unified schema (inputs cols + macro cols). Train and
+    # test now produce the exact same columns.
+    feat_cols_present = [c for c in feature_cols if c in merged.columns]
+    X = merged[feat_cols_present].copy().reset_index(drop=True)
+
+    meta_cols = ["ticker", "date"]
+    if "sector" in merged.columns:
+        meta_cols.append("sector")
+    meta = merged[meta_cols].copy().reset_index(drop=True)
+
+    # mcap_q (market-cap quartile) — derived from y on the held-out test
+    # rows so cross-sectional stratification can run without leaking the
+    # train distribution. For train rows we still compute quartiles over
+    # the train y for parity but downstream callers only stratify test.
+    if y_series.size:
+        try:
+            qs = pd.qcut(y_series, q=4, labels=["Q1", "Q2", "Q3", "Q4"],
+                         duplicates="drop")
+            meta["mcap_q"] = qs.astype(str).values
+        except ValueError:
+            meta["mcap_q"] = "Q?"
+
+    _set_meta_attrs(
+        meta, task=task, split=out_split, granularity=granularity,
+        parquets_read=parquets_read, feature_names=list(X.columns),
+    )
+    return LoadedData(X=X, y=y_series.to_numpy(dtype=np.float32), meta=meta)
+
+
+# ── T3 / T6 ───────────────────────────────────────────────────────────────
+
+
+def _t3_t6_paths(task: str, granularity: str):
+    bench_dir = config.get_benchmark_dir(granularity)
+    if task == "T3":
+        return bench_dir / "generation_inputs.parquet", bench_dir / "generation_ground_truth.parquet", "field"
+    return bench_dir / "generator_eval_inputs.parquet", bench_dir / "generator_eval_ground_truth.parquet", "generator_field"
+
+
+def _load_t3_t6(
+    task: str, canon_split: str, out_split: str, granularity: str,
+) -> LoadedData:
+    canon = get_canonical_indices(task, canon_split, granularity=granularity)
+    if canon.empty:
+        raise RuntimeError(f"Canonical {task}/{canon_split} index set is empty.")
+
+    inputs_path, gt_path, field_col = _t3_t6_paths(task, granularity)
+    inputs = pd.read_parquet(inputs_path)
+    gt = pd.read_parquet(gt_path)
+    if field_col not in gt.columns and "field" in gt.columns:
+        field_col = "field"
+    if "fiscal_year" not in gt.columns:
+        if "filing_date" in gt.columns:
+            gt["fiscal_year"] = pd.to_datetime(gt["filing_date"]).dt.year
+        else:
+            gt["fiscal_year"] = 0
+
+    canon = canon.copy()
+    canon["fiscal_year"] = pd.to_numeric(canon["fiscal_year"], errors="coerce").astype("Int64")
+
+    # X: per-(ticker, fiscal_year). For T3 inputs file is per-ticker (one
+    # row per holdout ticker); broadcast across the canonical (ticker,
+    # fiscal_year) pairs.
+    if "fiscal_year" in inputs.columns:
+        X = canon.merge(inputs, on=["ticker", "fiscal_year"], how="left")
+    else:
+        X = canon.merge(inputs, on="ticker", how="left")
+
+    # y: long-form restricted to canonical (ticker, fiscal_year) pairs.
+    canon_keys = set(zip(
+        canon["ticker"].astype(str),
+        canon["fiscal_year"].astype("Int64").astype(str),
+    ))
+    gt_filt = gt.copy()
+    gt_filt["fiscal_year"] = pd.to_numeric(gt_filt["fiscal_year"], errors="coerce").astype("Int64")
+    gt_filt["_key"] = list(zip(
+        gt_filt["ticker"].astype(str),
+        gt_filt["fiscal_year"].astype(str),
+    ))
+    gt_filt = gt_filt[gt_filt["_key"].isin(canon_keys)].drop(columns=["_key"]).reset_index(drop=True)
+
+    if field_col != "field":
+        gt_filt = gt_filt.rename(columns={field_col: "field"})
+    if task == "T3":
+        # T3 evaluates on the dense 11-field panel (same fields T6 uses).
+        # The released ``generation_ground_truth.parquet`` ships the full
+        # XBRL universe (10,279 unique tags including company-extension
+        # tags filed once by one issuer); per-field MAPE on those is noise.
+        # Projection happens at load time so the on-disk parquet is
+        # preserved; evaluation runs on the meaningful subset.
+        gt_filt = gt_filt[gt_filt["field"].astype(str).isin(_T3_DENSE_FIELDS)].reset_index(drop=True)
+    y = gt_filt[["ticker", "fiscal_year", "field", "value"]].copy()
+
+    meta = canon[["ticker", "fiscal_year"]].copy().reset_index(drop=True)
+    X = X.reset_index(drop=True)
+
+    _set_meta_attrs(
+        meta, task=task, split=out_split, granularity=granularity,
+        parquets_read=[inputs_path, gt_path],
+        feature_names=[c for c in X.columns if c not in {"ticker", "fiscal_year"}],
+    )
+    return LoadedData(X=X, y=y, meta=meta)
+
+
+# ── T4 ────────────────────────────────────────────────────────────────────
+
+
+def _load_t4(
+    canon_split: str, out_split: str, granularity: str, lookback: int,
+) -> LoadedData:
+    canon = get_canonical_indices("T4", canon_split, granularity=granularity)
+    if canon.empty:
+        raise RuntimeError(f"Canonical T4/{canon_split} index set is empty.")
+
+    bench_dir = config.get_benchmark_dir(granularity)
+    gt_path = bench_dir / "scenario_forecast_ground_truth.parquet"
+    scen_path = bench_dir / "scenarios.parquet"
+    # T4 lookback windows can span the train/test split (an event close to
+    # the cutoff needs ~63 trading days of history that may sit on the
+    # other side). Read both panels and merge for the lookback build.
+    panel_train_path = _panel_path(granularity, "train")
+    panel_test_path = _panel_path(granularity, "test")
+
+    gt = pd.read_parquet(gt_path).dropna(subset=["actual_return_pct"])
+    gt["event_date"] = pd.to_datetime(gt["event_date"])
+
+    scen_full = pd.read_parquet(scen_path)
+    desc_col = "event_description" if "event_description" in scen_full.columns else None
+    keep_scen_cols = ["scenario_id"] + ([desc_col] if desc_col else [])
+    scen = scen_full[keep_scen_cols].drop_duplicates("scenario_id")
+
+    canon = canon.copy()
+    canon["scenario_id"] = canon["scenario_id"].astype(str)
+    canon["ticker"] = canon["ticker"].astype(str)
+    gt["scenario_id"] = gt["scenario_id"].astype(str)
+    gt["ticker"] = gt["ticker"].astype(str)
+    scen["scenario_id"] = scen["scenario_id"].astype(str)
+
+    # Filter ground truth to canonical pairs
+    canon_keys = set(zip(canon["scenario_id"], canon["ticker"]))
+    gt["_key"] = list(zip(gt["scenario_id"], gt["ticker"]))
+    gt_filt = gt[gt["_key"].isin(canon_keys)].drop(columns=["_key"]).reset_index(drop=True)
+    if gt_filt.empty:
+        raise RuntimeError(f"T4/{out_split} loader: zero rows after canonical join.")
+
+    if desc_col is not None:
+        gt_filt = gt_filt.merge(
+            scen[["scenario_id", desc_col]], on="scenario_id", how="left",
+        )
+
+    # Lookback windows from the COMBINED panel (train + test) — a T4
+    # event near the chronological cutoff needs lookback rows on the
+    # other side of the split.
+    panel_train_df = pd.read_parquet(panel_train_path)
+    panel_test_df = pd.read_parquet(panel_test_path)
+    panel = pd.concat([panel_train_df, panel_test_df], ignore_index=True)
+    del panel_train_df, panel_test_df
+    panel["date"] = pd.to_datetime(panel["date"])
+    panel = panel.sort_values(["ticker", "date"]).drop_duplicates(
+        subset=["ticker", "date"], keep="first",
+    ).reset_index(drop=True)
+
+    exclude = {
+        "ticker", "date", "label", "split",
+        "nearest_filing_type", "nearest_filing_date", "nearest_filing_path",
+    }
+    feat_cols = [
+        c for c in panel.columns
+        if c not in exclude and panel[c].dtype.kind in "fiub"
+    ]
+
+    per_ticker_feats: dict[str, np.ndarray] = {}
+    per_ticker_dates: dict[str, np.ndarray] = {}
+    for ticker, grp in panel.groupby("ticker", sort=False):
+        per_ticker_feats[str(ticker)] = grp[feat_cols].values.astype(np.float32)
+        per_ticker_dates[str(ticker)] = grp["date"].values.astype("datetime64[ns]")
+
+    lb_list: list[np.ndarray] = []
+    valid = np.zeros(len(gt_filt), dtype=bool)
+    for i, (ticker, ev_date) in enumerate(zip(
+        gt_filt["ticker"].values,
+        gt_filt["event_date"].values.astype("datetime64[ns]"),
+    )):
+        feats = per_ticker_feats.get(str(ticker))
+        if feats is None:
+            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
+            continue
+        dates = per_ticker_dates[str(ticker)]
+        idx = np.searchsorted(dates, ev_date, side="right") - 1
+        if idx + 1 < lookback:
+            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
+            continue
+        lb = feats[idx - lookback + 1 : idx + 1]
+        if lb.shape != (lookback, len(feat_cols)):
+            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
+            continue
+        lb_list.append(lb)
+        valid[i] = True
+
+    keep = np.where(valid)[0]
+    if len(keep) == 0:
+        raise RuntimeError(f"T4/{out_split} loader: no valid lookback windows after panel join.")
+    gt_filt = gt_filt.iloc[keep].reset_index(drop=True)
+    lb_arr = [lb_list[i] for i in keep]
+
+    # T4 X is a DataFrame (not a dict): one row per (scenario_id, ticker),
+    # with `lookback` as an object-dtype column where each cell is a
+    # (lookback, F) np.ndarray. event_type and event_description are string
+    # columns. Methods consume X uniformly.
+    X = pd.DataFrame({
+        "lookback": lb_arr,
+        "event_type": gt_filt["event_type"].astype(str).values,
+        "event_description": (
+            gt_filt[desc_col].astype(str).values if desc_col is not None
+            else np.array([""] * len(gt_filt))
+        ),
+    })
+
+    y = gt_filt["actual_return_pct"].astype(np.float32).to_numpy()
+    meta = gt_filt[["scenario_id", "ticker", "event_type", "event_date"]].copy().reset_index(drop=True)
+
+    _set_meta_attrs(
+        meta, task="T4", split=out_split, granularity=granularity,
+        parquets_read=[gt_path, scen_path, panel_train_path, panel_test_path],
+        lookback=lookback, feature_names=feat_cols,
+    )
+    return LoadedData(X=X, y=y, meta=meta)
+
+
+# ── T7 ────────────────────────────────────────────────────────────────────
+
+
+def _load_t7(canon_split: str, out_split: str, granularity: str) -> LoadedData:
+    canon = get_canonical_indices("T7", canon_split, granularity=granularity)
+    if canon.empty:
+        raise RuntimeError(f"Canonical T7/{canon_split} index set is empty.")
+
+    bench_dir = config.get_benchmark_dir(granularity)
+    train_src_path = bench_dir / "re_train_properties.parquet"
+    test_src_path = bench_dir / "re_eval_inputs.parquet"
+    test_gt_path = bench_dir / "re_eval_ground_truth.parquet"
+
+    # Read BOTH src files to compute the column intersection (the smaller
+    # test schema is the canonical one; train rows are projected onto it
+    # so train ↔ test are schema-identical).
+    test_src = pd.read_parquet(test_src_path)
+    train_src = pd.read_parquet(train_src_path)
+    common_cols = [c for c in test_src.columns if c in train_src.columns]
+    if "address" not in common_cols:
+        raise RuntimeError(
+            "T7 loader: 'address' missing from re_eval_inputs ∩ re_train_properties columns"
+        )
+
+    if out_split == "train":
+        src = train_src[common_cols].copy()
+        # Train ground truth comes from re_train_properties' rent/price columns;
+        # they're already in train_src.
+        gt_cols = [c for c in ("address", "rent", "price") if c in train_src.columns]
+        gt = train_src[gt_cols].copy()
+        parquets_read = [train_src_path]
+    else:
+        src = test_src[common_cols].copy()
+        gt = pd.read_parquet(test_gt_path)
+        parquets_read = [test_src_path, test_gt_path]
+
+    canon = canon.copy()
+    canon["address"] = canon["address"].astype(str)
+    src["address"] = src["address"].astype(str)
+    gt["address"] = gt["address"].astype(str)
+
+    # Fix the v0.1 T7 duplicate-address Cartesian product bug. Dedup
+    # canon, src, and gt — canon itself can carry duplicates (the T7
+    # canonical sampler does not enforce address-uniqueness on the train
+    # pool), and an upstream duplicate quietly multiplies on the merge.
+    canon_dedup = canon.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
+    src_dedup = src.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
+    gt_dedup = gt.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
+
+    X = canon_dedup[["address"]].merge(src_dedup, on="address", how="left")
+    y_join = canon_dedup[["address"]].merge(gt_dedup, on="address", how="left")
+
+    if X.empty:
+        raise RuntimeError(
+            f"T7/{out_split} loader: zero rows after canonical address join."
+        )
+
+    # Lock the y column order so train and test produce identical column
+    # ordering. Methods may rely on positional column access.
+    y = y_join.reindex(columns=["address", "rent", "price"]).reset_index(drop=True)
+    X = X.reset_index(drop=True)
+
+    meta_cols = ["address"] + [c for c in ("property_type", "state") if c in canon_dedup.columns]
+    meta = canon_dedup[meta_cols].reset_index(drop=True)
+
+    _set_meta_attrs(
+        meta, task="T7", split=out_split, granularity=granularity,
+        parquets_read=parquets_read,
+        feature_names=[c for c in X.columns if c != "address"],
+    )
+    return LoadedData(X=X, y=y, meta=meta)

code/enrich_benchmark.py

@@ -0,0 +1,288 @@
+"""Step 11 – Enrich benchmark panels with news-derived features.
+
+Lightweight post-processing that adds columns to the **L3 benchmark**
+panels (not L2 processed) and enriches ``scenarios.parquet`` with
+collected news context.
+
+New columns added to ``panel_train.parquet`` / ``panel_test.parquet``:
+  * ``filing_8k_count_30d`` (int)  – 8-K filings in the past 30 days
+  * ``news_count_7d``       (int)  – yfinance news articles in past 7 days
+  * ``has_press_release_7d`` (bool) – press release in past 7 days
+
+New column added to ``scenarios.parquet``:
+  * ``news_context`` (str, JSON) – top-5 scenario news articles
+
+Resume: skips if columns already exist in parquet files.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Helper: rolling-window count via prefix-sum + searchsorted
+# ---------------------------------------------------------------------------
+
+def _rolling_window_count(
+    panel_dates_i64: np.ndarray,
+    panel_groups: dict[str, np.ndarray],
+    events: pd.DataFrame,
+    window_days: int,
+    n_rows: int,
+) -> np.ndarray:
+    """Count events within a rolling calendar-day window per ticker.
+
+    Uses cumulative-sum differencing with ``np.searchsorted`` – loops
+    over tickers that have events (typically a small subset), but each
+    iteration is pure numpy O(n log m).
+
+    Parameters
+    ----------
+    panel_dates_i64 : int64 nanosecond timestamps for all panel rows
+    panel_groups : dict mapping ticker → integer row indices in the panel
+    events : DataFrame with columns [ticker, date, n] (daily counts)
+    window_days : size of the look-back window (inclusive both ends)
+    n_rows : total number of rows in the panel
+
+    Returns
+    -------
+    np.ndarray[int64] of length *n_rows*.
+    """
+    result = np.zeros(n_rows, dtype=np.int64)
+
+    if events.empty:
+        return result
+
+    window_ns = np.int64((window_days + 1) * 86_400_000_000_000)
+
+    for ticker, ev_group in events.groupby("ticker"):
+        if ticker not in panel_groups:
+            continue
+
+        panel_idx = panel_groups[ticker]
+        p_dates = panel_dates_i64[panel_idx]
+
+        ev_sorted = ev_group.sort_values("date")
+        e_dates = ev_sorted["date"].values.astype("int64")
+        e_cumsum = ev_sorted["n"].values.cumsum()
+
+        upper_pos = np.searchsorted(e_dates, p_dates, side="right") - 1
+        upper_cs = np.where(upper_pos >= 0, e_cumsum[upper_pos], 0)
+
+        lower_dates = p_dates - window_ns
+        lower_pos = np.searchsorted(e_dates, lower_dates, side="right") - 1
+        lower_cs = np.where(lower_pos >= 0, e_cumsum[lower_pos], 0)
+
+        result[panel_idx] = upper_cs - lower_cs
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# 1. Filing 8-K count
+# ---------------------------------------------------------------------------
+
+def _add_8k_counts(panel: pd.DataFrame, corpus_path: Path) -> pd.DataFrame:
+    """Add ``filing_8k_count_30d`` (fully vectorised, no calendar reindexing)."""
+    if "filing_8k_count_30d" in panel.columns:
+        logger.info("  filing_8k_count_30d already present – skipping")
+        return panel
+
+    if not corpus_path.exists():
+        logger.warning("filing_corpus.parquet not found – filling 8k count with 0")
+        panel["filing_8k_count_30d"] = 0
+        return panel
+
+    corpus = pd.read_parquet(corpus_path)
+    eightk = corpus[corpus["filing_type"] == "8-K"].copy()
+
+    if eightk.empty:
+        logger.info("  No 8-K filings in corpus – filling with 0")
+        panel["filing_8k_count_30d"] = 0
+        return panel
+
+    panel["date"] = pd.to_datetime(panel["date"])
+    eightk["filing_date"] = pd.to_datetime(eightk["filing_date"])
+
+    daily = (
+        eightk.groupby(["ticker", "filing_date"])
+        .size()
+        .reset_index(name="n")
+        .rename(columns={"filing_date": "date"})
+    )
+
+    panel_dates_i64 = panel["date"].values.astype("int64")
+    panel_groups = {
+        t: idx for t, idx in panel.groupby("ticker", sort=False).indices.items()
+    }
+
+    panel["filing_8k_count_30d"] = _rolling_window_count(
+        panel_dates_i64, panel_groups, daily, window_days=30, n_rows=len(panel),
+    )
+    logger.info("  Added filing_8k_count_30d")
+    return panel
+
+
+# ---------------------------------------------------------------------------
+# 2. News/PR counts from SEC 8-K filings (covers full 2021-2026 period)
+# ---------------------------------------------------------------------------
+
+def _add_news_counts(panel: pd.DataFrame) -> pd.DataFrame:
+    """Add ``news_count_7d`` and ``has_press_release_7d`` from SEC 8-K filings.
+
+    8-K filings are material event disclosures — effectively press releases
+    filed with the SEC.  For small/micro-cap companies, 8-K filings are the
+    most reliable per-ticker news source (mainstream media coverage is sparse).
+    """
+    if "news_count_7d" in panel.columns:
+        logger.info("  news_count_7d already present – skipping")
+        return panel
+
+    panel["date"] = pd.to_datetime(panel["date"])
+
+    # Collect 8-K filing dates per ticker from the filings directory
+    filings_dir = config.FILINGS_DIR
+    rows_8k: list[dict] = []
+    if filings_dir.exists():
+        for ticker_dir in filings_dir.iterdir():
+            if not ticker_dir.is_dir():
+                continue
+            ticker = ticker_dir.name
+            for filing in ticker_dir.glob("*.md"):
+                # Filing names typically contain the type and date
+                # e.g., "8-K_2023-07-26.md" or "8-K_20230726_..."
+                fname = filing.stem
+                if "8-K" not in fname.upper() and "8K" not in fname.upper():
+                    continue
+                # Extract date from filename
+                import re
+                date_match = re.search(r"(\d{4}-\d{2}-\d{2})", fname)
+                if not date_match:
+                    date_match = re.search(r"(\d{4})(\d{2})(\d{2})", fname)
+                    if date_match:
+                        date_str = f"{date_match.group(1)}-{date_match.group(2)}-{date_match.group(3)}"
+                    else:
+                        continue
+                else:
+                    date_str = date_match.group(1)
+                try:
+                    ts = pd.Timestamp(date_str)
+                    rows_8k.append({"ticker": ticker, "date": ts})
+                except Exception:
+                    continue
+
+    panel_dates_i64 = panel["date"].values.astype("int64")
+    panel_groups = {
+        t: idx for t, idx in panel.groupby("ticker", sort=False).indices.items()
+    }
+
+    if rows_8k:
+        filing_df = pd.DataFrame(rows_8k)
+        filing_df["date"] = pd.to_datetime(filing_df["date"]).dt.normalize()
+        daily_8k = filing_df.groupby(["ticker", "date"]).size().reset_index(name="n")
+        logger.info("  Found %d 8-K filing events across %d tickers",
+                     len(daily_8k), filing_df["ticker"].nunique())
+        panel["news_count_7d"] = _rolling_window_count(
+            panel_dates_i64, panel_groups, daily_8k,
+            window_days=7, n_rows=len(panel),
+        )
+        panel["has_press_release_7d"] = panel["news_count_7d"] > 0
+    else:
+        logger.warning("  No 8-K filings found – filling with defaults")
+        panel["news_count_7d"] = 0
+        panel["has_press_release_7d"] = False
+
+    logger.info("  Added news_count_7d and has_press_release_7d (from 8-K filings)")
+    return panel
+
+
+# ---------------------------------------------------------------------------
+# 3. Scenario news context
+# ---------------------------------------------------------------------------
+
+def _enrich_scenarios(scenarios_path: Path) -> None:
+    """Add ``news_context`` column to scenarios.parquet."""
+    if not scenarios_path.exists():
+        logger.warning("scenarios.parquet not found – skipping scenario enrichment")
+        return
+
+    df = pd.read_parquet(scenarios_path)
+
+    if "news_context" in df.columns:
+        logger.info("  news_context already present – skipping")
+        return
+
+    scenarios_dir = config.NEWS_DIR / "scenarios"
+    contexts = []
+
+    for _, row in df.iterrows():
+        sc_id = row["scenario_id"]
+        news_path = scenarios_dir / f"{sc_id}.json"
+        if news_path.exists():
+            try:
+                articles = json.loads(news_path.read_text(encoding="utf-8"))
+                top_articles = [
+                    {
+                        "title": a.get("title", ""),
+                        "snippet": a.get("snippet", ""),
+                        "date": a.get("date", ""),
+                    }
+                    for a in articles
+                ]
+                contexts.append(json.dumps(top_articles))
+            except Exception:
+                contexts.append("[]")
+        else:
+            contexts.append("[]")
+
+    df["news_context"] = contexts
+    df.to_parquet(scenarios_path, index=False)
+    logger.info("  Added news_context to %d scenarios", len(df))
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def run(granularity: str | None = None) -> None:
+    """Enrich L3 benchmark panels and scenarios with news-derived features."""
+    if granularity is None:
+        granularity = config.GRANULARITY
+
+    benchmark_dir = config.get_benchmark_dir(granularity)
+    corpus_path = benchmark_dir / "filing_corpus.parquet"
+
+    for split in ("panel_train.parquet", "panel_test.parquet"):
+        panel_path = benchmark_dir / split
+        if not panel_path.exists():
+            logger.warning("%s not found – skipping", panel_path)
+            continue
+
+        logger.info("Enriching %s …", split)
+        panel = pd.read_parquet(panel_path)
+
+        panel = _add_8k_counts(panel, corpus_path)
+        panel.to_parquet(panel_path, index=False)
+        logger.info("  Checkpoint: saved after 8-K enrichment")
+
+        panel = _add_news_counts(panel)
+        panel.to_parquet(panel_path, index=False)
+        logger.info(
+            "  Saved enriched %s (%d rows, %d cols)",
+            split, len(panel), len(panel.columns),
+        )
+
+    scenarios_path = benchmark_dir / "scenarios.parquet"
+    _enrich_scenarios(scenarios_path)
+
+    logger.info("Benchmark enrichment complete.")

code/eval.py

@@ -0,0 +1,1556 @@
+"""MacroLens unified-API evaluation layer (Phase 1E).
+
+Public API
+----------
+
+    >>> import whatif_bench.eval as ev
+    >>> metrics = ev.score("T1", y_true, y_pred,
+    ...                    cluster_keys=meta["ticker"].values,
+    ...                    close_last=meta["close_last"].values)
+    >>> df = ev.compare_methods("T1", run_records, correction="holm")
+
+Hard rules (definitive — see the unified-API plan §5 / §7b):
+
+* **Default ``resample="cluster"``** — bootstrap by ``ticker`` for
+  T1 / T2 / T3 / T5 / T6 / T7, by ``scenario_id`` for T4. Statistically
+  correct on panel data.
+* **Adaptive ``n_boot``** — start at B=1,000; if
+  ``(ci_hi - ci_lo) / max(|mean|, 1e-12) > 0.05`` escalate to B=10,000.
+  Cap at 10,000. Actual ``B`` recorded on the returned ``MetricValue``.
+* **Close-anchor DA everywhere** — for T1, directional accuracy is
+  ``mean(sign(y_pred[t] - close_last) == sign(y_true[t] - close_last))``
+  over the horizon. The legacy ``np.diff``-based formula is REMOVED.
+  ``close_last`` is supplied via the ``close_last=`` kwarg (or
+  ``meta["close_last"]`` by the runner). When unavailable we fall back to
+  ``y_pred[:, 0]`` as the anchor and document the fallback in the metric's
+  metadata.
+* **APE clip uniformly at 10×.** With ``return_sensitivity=True`` we also
+  emit MAPE at clips ``{5, 10, 20, ∞}``.
+* **Multiple-comparisons correction is per-task** (Holm or BH). NO
+  cross-task FWER claim.
+* All metric values are wrapped in ``MetricValue`` Pydantic models.
+
+The per-task numerical logic is lifted verbatim from the legacy
+``agents/valuation/evaluate.py`` module (which still passes the
+``tests/test_evaluator_contract.py`` contract).
+
+This module is a leaf — it does NO IO, imports nothing from
+``methods/``, ``dataloader/`` or ``experiments/``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Iterable, Literal
+
+import numpy as np
+import pandas as pd
+
+from .macrolens._types import MetricValue
+
+logger = logging.getLogger(__name__)
+
+
+# ===================================================================
+# Constants
+# ===================================================================
+
+_BOOTSTRAP_INITIAL_N = 1_000
+_BOOTSTRAP_MAX_N = 10_000
+_BOOTSTRAP_CI_TOL = 0.05  # widen → escalate threshold
+
+_APE_CLIP_DEFAULT = 10.0  # 1000% per-instance cap
+_APE_SENSITIVITY_CLIPS: tuple[float, ...] = (5.0, 10.0, 20.0, float("inf"))
+
+
+# ===================================================================
+# Cluster bootstrap
+# ===================================================================
+
+
+def _bootstrap_ci(
+    values: np.ndarray,
+    *,
+    cluster_keys: np.ndarray | None = None,
+    agg_fn: Callable[[np.ndarray], float] = np.mean,
+    n_boot: int | Literal["adaptive"] = "adaptive",
+    alpha: float = 0.05,
+    seed: int = 42,
+) -> tuple[float, float, float, float, int]:
+    """Bootstrap confidence interval for ``agg_fn(values)``.
+
+    Parameters
+    ----------
+    values
+        1-D float array of per-instance summary statistics.
+    cluster_keys
+        Optional cluster ID per row. When supplied, performs **cluster
+        bootstrap** (resample whole clusters with replacement; aggregate
+        all member rows). When ``None``, performs IID bootstrap.
+    agg_fn
+        Aggregator (default ``np.mean``).
+    n_boot
+        Either an explicit integer, or ``"adaptive"`` to start at 1,000 and
+        escalate to 10,000 if the CI half-width is wider than 5% of the
+        point estimate.
+    alpha
+        Two-sided coverage; default 0.05 → 95% CI.
+    seed
+        RNG seed.
+
+    Returns
+    -------
+    ``(value, ci_lo, ci_hi, std, n_boot_used)``
+    """
+    values = np.asarray(values, dtype=np.float64).ravel()
+    n = values.size
+    if n == 0:
+        nan = float("nan")
+        return nan, nan, nan, nan, 0
+
+    point = float(agg_fn(values))
+
+    # Build cluster index lookup once.
+    if cluster_keys is not None:
+        ck = np.asarray(cluster_keys).ravel()
+        if ck.size != n:
+            raise ValueError(
+                f"cluster_keys length {ck.size} != values length {n}"
+            )
+        # Map cluster → row indices.
+        unique_clusters, inverse = np.unique(ck, return_inverse=True)
+        # cluster_idx[c] = np.array of row positions in `values`.
+        cluster_rows: list[np.ndarray] = [
+            np.where(inverse == c)[0] for c in range(unique_clusters.size)
+        ]
+        n_clusters = unique_clusters.size
+    else:
+        cluster_rows = []
+        n_clusters = 0
+
+    rng = np.random.default_rng(seed)
+
+    def _draw(b: int) -> np.ndarray:
+        out = np.empty(b, dtype=np.float64)
+        if cluster_keys is not None:
+            for i in range(b):
+                pick = rng.integers(0, n_clusters, size=n_clusters)
+                # Concatenate row indices for all picked clusters.
+                idx = np.concatenate([cluster_rows[c] for c in pick])
+                out[i] = agg_fn(values[idx])
+        else:
+            for i in range(b):
+                out[i] = agg_fn(values[rng.integers(0, n, size=n)])
+        return out
+
+    # Decide B.
+    if n_boot == "adaptive":
+        boot = _draw(_BOOTSTRAP_INITIAL_N)
+        lo = float(np.quantile(boot, alpha / 2))
+        hi = float(np.quantile(boot, 1 - alpha / 2))
+        rel_width = (hi - lo) / max(abs(point), 1e-12)
+        if rel_width > _BOOTSTRAP_CI_TOL and _BOOTSTRAP_MAX_N > _BOOTSTRAP_INITIAL_N:
+            extra = _draw(_BOOTSTRAP_MAX_N - _BOOTSTRAP_INITIAL_N)
+            boot = np.concatenate([boot, extra])
+            lo = float(np.quantile(boot, alpha / 2))
+            hi = float(np.quantile(boot, 1 - alpha / 2))
+        b_used = boot.size
+    else:
+        b_used = int(n_boot)
+        boot = _draw(b_used)
+        lo = float(np.quantile(boot, alpha / 2))
+        hi = float(np.quantile(boot, 1 - alpha / 2))
+
+    std = float(np.std(boot))
+    return point, lo, hi, std, b_used
+
+
+def _wrap_metric(
+    values: np.ndarray,
+    *,
+    cluster_keys: np.ndarray | None,
+    agg_fn: Callable[[np.ndarray], float],
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+) -> MetricValue:
+    """Bootstrap a per-instance vector and box it into a ``MetricValue``.
+
+    Returns a ``MetricValue`` with all fields ``None`` when ``values`` is
+    empty or every entry is non-finite (the metric cannot be defined).
+    """
+    arr = np.asarray(values, dtype=np.float64).ravel()
+    finite_mask = np.isfinite(arr)
+    if arr.size == 0 or not finite_mask.any():
+        return _none_metric(resample=resample)
+    if not finite_mask.all():
+        # Drop non-finite entries; align cluster_keys if supplied.
+        if cluster_keys is not None:
+            ck_arr = np.asarray(cluster_keys).ravel()
+            if ck_arr.size == arr.size:
+                cluster_keys = ck_arr[finite_mask]
+            # else: leave cluster_keys alone — _align_cluster_keys upstream
+            # may have already pre-filtered.
+        arr = arr[finite_mask]
+    if resample == "iid":
+        ck = None
+    else:
+        ck = cluster_keys
+    # Cluster bootstrap with one unique cluster collapses to a delta — fall
+    # back to IID resampling on that array so the std is still defined.
+    if ck is not None:
+        unique_ck = np.unique(np.asarray(ck).ravel())
+        if unique_ck.size < 2:
+            ck = None
+    point, lo, hi, std, b_used = _bootstrap_ci(
+        arr,
+        cluster_keys=ck,
+        agg_fn=agg_fn,
+        n_boot=n_boot,
+        alpha=alpha,
+        seed=seed,
+    )
+    if not np.isfinite(point):
+        return _none_metric(resample=resample)
+    # CI half-width / std may legitimately collapse to 0 (1-row arrays); keep
+    # those numerics rather than substituting None.
+    lo_v = lo if np.isfinite(lo) else point
+    hi_v = hi if np.isfinite(hi) else point
+    std_v = std if np.isfinite(std) else 0.0
+    return MetricValue(
+        value=float(point), ci_lo=float(lo_v), ci_hi=float(hi_v),
+        std=float(std_v), n_boot=int(b_used),
+        resample=resample,
+    )
+
+
+def _scalar_metric(
+    value: float | None,
+    *,
+    resample: Literal["cluster", "iid"],
+    n_boot: int = 0,
+) -> MetricValue:
+    """Wrap a deterministic scalar (e.g. counts) without a bootstrap.
+
+    When ``value`` is ``None`` or NaN we emit a ``MetricValue`` whose
+    ``value`` / ``ci_lo`` / ``ci_hi`` / ``std`` are all ``None`` so
+    consumers can detect "metric not applicable" via ``value is None``
+    rather than with a NaN finiteness probe.
+    """
+    if value is None or (isinstance(value, float) and np.isnan(value)):
+        return MetricValue(
+            value=None,
+            ci_lo=None,
+            ci_hi=None,
+            std=None,
+            n_boot=int(n_boot),
+            resample=resample,
+        )
+    v = float(value)
+    return MetricValue(
+        value=v,
+        ci_lo=v,
+        ci_hi=v,
+        std=0.0,
+        n_boot=int(n_boot),
+        resample=resample,
+    )
+
+
+def _none_metric(
+    *,
+    resample: Literal["cluster", "iid"],
+) -> MetricValue:
+    """Return a ``MetricValue`` indicating "metric not applicable / not computed"."""
+    return MetricValue(
+        value=None, ci_lo=None, ci_hi=None, std=None,
+        n_boot=0, resample=resample,
+    )
+
+
+# ===================================================================
+# Anchored DA helper
+# ===================================================================
+
+
+def _close_anchor_da(
+    y_true: np.ndarray, y_pred: np.ndarray, close_last: np.ndarray,
+) -> np.ndarray:
+    """Per-row close-anchor directional accuracy (T1).
+
+    For each row ``i`` and horizon step ``t`` we compare
+    ``sign(y_true[i, t] - close_last[i])`` to
+    ``sign(y_pred[i, t] - close_last[i])``. Per-row DA is the mean over
+    the horizon. Returns a length-N float array (NaN allowed for rows
+    where ``close_last`` is NaN).
+
+    NB: the legacy ``np.diff`` formula is intentionally removed.
+    """
+    y_true = np.asarray(y_true, dtype=np.float64)
+    y_pred = np.asarray(y_pred, dtype=np.float64)
+    cl = np.asarray(close_last, dtype=np.float64).reshape(-1, 1)
+    if y_true.shape != y_pred.shape:
+        raise ValueError(
+            f"_close_anchor_da: shape mismatch y_true {y_true.shape} vs y_pred {y_pred.shape}"
+        )
+    if cl.shape[0] != y_true.shape[0]:
+        raise ValueError(
+            f"_close_anchor_da: close_last length {cl.shape[0]} != y rows {y_true.shape[0]}"
+        )
+    true_sign = np.sign(y_true - cl)
+    pred_sign = np.sign(y_pred - cl)
+    agree = (true_sign == pred_sign).astype(np.float64)
+    return agree.mean(axis=1)
+
+
+# ===================================================================
+# Per-task helpers
+# ===================================================================
+
+
+def _ape_per_instance(
+    pred: np.ndarray, actual: np.ndarray, *, clip: float = _APE_CLIP_DEFAULT,
+    near_zero: float = 0.0,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return (ape_vector_pct, kept_row_mask) clipped at ``clip × 100 %``.
+
+    Rows where ``|actual| <= near_zero`` (or NaN) are dropped from the
+    returned vectors; the second return value is the boolean mask of rows
+    that survived (in the original ordering).
+    """
+    pred = np.asarray(pred, dtype=np.float64).ravel()
+    actual = np.asarray(actual, dtype=np.float64).ravel()
+    mask = (
+        np.isfinite(pred)
+        & np.isfinite(actual)
+        & (np.abs(actual) > near_zero)
+    )
+    p = pred[mask]
+    a = actual[mask]
+    ape = np.abs((p - a) / a)
+    if np.isfinite(clip):
+        ape = np.minimum(ape, clip)
+    return ape * 100.0, mask  # percent units
+
+
+def _normalize_field_col(df: pd.DataFrame) -> pd.DataFrame:
+    """T6 (Gen-Eval) GT uses ``generator_field``; T3 uses ``field``."""
+    if "field" not in df.columns and "generator_field" in df.columns:
+        return df.rename(columns={"generator_field": "field"})
+    return df
+
+
+# -------------------------------------------------------------------
+# T1 — Time-Series Forecasting
+# -------------------------------------------------------------------
+
+
+def _per_task_score_T1(
+    y_true: Any,
+    y_pred: Any,
+    *,
+    cluster_keys: np.ndarray | None,
+    close_last: np.ndarray | None,
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+    return_sensitivity: bool,
+) -> dict[str, MetricValue]:
+    y_true_a = np.asarray(y_true, dtype=np.float64)
+    y_pred_a = np.asarray(y_pred, dtype=np.float64).copy()
+    if y_true_a.ndim != 2 or y_pred_a.ndim != 2 or y_true_a.shape != y_pred_a.shape:
+        raise ValueError(
+            f"T1 score: shape mismatch — y_true {y_true_a.shape}, "
+            f"y_pred {y_pred_a.shape}; expected matching (N, horizon) arrays."
+        )
+    n, horizon = y_true_a.shape
+    if n == 0:
+        raise ValueError("T1 score: empty arrays.")
+
+    # NaN penalty: substitute any NaN/inf prediction row with ZERO.
+    # Failed parses thus get a clear no-signal penalty (MSE ≈ y_true²,
+    # MAE = |y_true|) that is distinct from any meaningful model output.
+    nan_row_mask = ~np.isfinite(y_pred_a).all(axis=1)
+    if nan_row_mask.any():
+        y_pred_a[nan_row_mask, :] = 0.0
+
+    # Per-instance aggregates (the bootstrap unit is the instance, with
+    # cluster bootstrap pooling across ticker rows).
+    per_inst_mse = ((y_pred_a - y_true_a) ** 2).mean(axis=1)
+    per_inst_mae = np.abs(y_pred_a - y_true_a).mean(axis=1)
+
+    # Close-anchor DA. Fall back to y_pred[:, 0] if unavailable (documented).
+    da_fallback = False
+    if close_last is None:
+        close_last_v = y_pred_a[:, 0].astype(np.float64)
+        da_fallback = True
+        logger.warning(
+            "T1 score: close_last not supplied; falling back to y_pred[:, 0] "
+            "as the directional anchor. This degrades the DA interpretation."
+        )
+    else:
+        close_last_v = np.asarray(close_last, dtype=np.float64).ravel()
+    per_inst_da = _close_anchor_da(y_true_a, y_pred_a, close_last_v)
+
+    out: dict[str, MetricValue] = {}
+    out["mse"] = _wrap_metric(
+        per_inst_mse, cluster_keys=cluster_keys, agg_fn=np.mean,
+        n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+    )
+    out["mae"] = _wrap_metric(
+        per_inst_mae, cluster_keys=cluster_keys, agg_fn=np.mean,
+        n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+    )
+    # rmse is sqrt(mean(mse_per_inst)) — bootstrap on the same sqrt(mean)
+    # aggregator gives an honest CI.
+    rmse_ck = cluster_keys if resample == "cluster" else None
+    if rmse_ck is not None:
+        unique_rmse_ck = np.unique(np.asarray(rmse_ck).ravel())
+        if unique_rmse_ck.size < 2:
+            rmse_ck = None
+    rmse_val, rmse_lo, rmse_hi, rmse_std, rmse_b = _bootstrap_ci(
+        per_inst_mse,
+        cluster_keys=rmse_ck,
+        agg_fn=lambda x: float(np.sqrt(np.mean(x))),
+        n_boot=n_boot, alpha=alpha, seed=seed,
+    )
+    if not np.isfinite(rmse_val):
+        out["rmse"] = _none_metric(resample=resample)
+    else:
+        out["rmse"] = MetricValue(
+            value=float(rmse_val),
+            ci_lo=float(rmse_lo) if np.isfinite(rmse_lo) else float(rmse_val),
+            ci_hi=float(rmse_hi) if np.isfinite(rmse_hi) else float(rmse_val),
+            std=float(rmse_std) if np.isfinite(rmse_std) else 0.0,
+            n_boot=int(rmse_b), resample=resample,
+        )
+    out["directional_accuracy"] = _wrap_metric(
+        per_inst_da, cluster_keys=cluster_keys, agg_fn=np.nanmean,
+        n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+    )
+
+    # MASE — Mean Absolute Scaled Error. Per-instance MASE divides each
+    # row's MAE by the in-sample seasonal-naive MAE (1-step persistence on
+    # close_last as the anchor: |y[h+1] - y[h]| averaged over the lookback
+    # is approximated by |y_true[i, 0] - close_last[i]| as a proxy when
+    # only the last close is available). Cluster-bootstraps over instances.
+    denom = np.abs(y_true_a[:, 0] - close_last_v)
+    denom_safe = np.where(denom > 1e-9, denom, np.nan)
+    per_inst_mase = per_inst_mae / denom_safe
+    valid_mase = np.isfinite(per_inst_mase)
+    if valid_mase.any():
+        ck_mase = (cluster_keys[valid_mase]
+                   if cluster_keys is not None else None)
+        out["mase"] = _wrap_metric(
+            per_inst_mase[valid_mase], cluster_keys=ck_mase, agg_fn=np.mean,
+            n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+        )
+    else:
+        out["mase"] = _none_metric(resample=resample)
+
+    out["n_instances"] = _scalar_metric(n, resample=resample)
+
+    if da_fallback:
+        # Best-effort metadata — store a sentinel so consumers can detect.
+        out["directional_accuracy_anchor_fallback"] = _scalar_metric(
+            1.0, resample=resample,
+        )
+
+    if return_sensitivity:
+        # T1's natural target is MSE/MAE; APE-style sensitivity is most
+        # meaningful relative to ``close_last``. Compute APE between
+        # final-step prediction and the realised final close.
+        if close_last is not None:
+            denom = np.abs(close_last_v)
+            denom_mask = denom > 0
+            if denom_mask.any():
+                final_err = np.abs(y_pred_a[:, -1] - y_true_a[:, -1])
+                ape_full = (final_err[denom_mask] / denom[denom_mask]) * 100.0
+                for clip in _APE_SENSITIVITY_CLIPS:
+                    if np.isfinite(clip):
+                        clipped = np.minimum(ape_full, clip * 100.0)
+                    else:
+                        clipped = ape_full
+                    key = (
+                        f"mape_at_clip_{int(clip)}x" if np.isfinite(clip)
+                        else "mape_at_clip_inf"
+                    )
+                    out[key] = _wrap_metric(
+                        clipped,
+                        cluster_keys=(
+                            cluster_keys[denom_mask] if cluster_keys is not None
+                            else None
+                        ),
+                        agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+                        resample=resample,
+                    )
+    return out
+
+
+# -------------------------------------------------------------------
+# T2 / T5 — Point-in-time valuation
+# -------------------------------------------------------------------
+
+
+def _adapt_t2_t5(y_true: Any, y_pred: Any) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Coerce (y_true, y_pred) into (predictions_df, ground_truth_df).
+
+    Accepts the unified-API loader contract for T2/T5: ``y_true`` is an
+    ``np.ndarray (N,)`` of ``actual_market_cap`` values. Also tolerates
+    the legacy DataFrame form ``[ticker, date, actual_market_cap]``.
+    """
+    if isinstance(y_true, pd.DataFrame) and "actual_market_cap" in y_true.columns:
+        gt = y_true.reset_index(drop=True)
+    elif isinstance(y_true, (np.ndarray, list, pd.Series)):
+        arr = np.asarray(y_true).ravel().astype(np.float64)
+        gt = pd.DataFrame({
+            "ticker": [f"row_{i}" for i in range(len(arr))],
+            "date": pd.NaT,
+            "actual_market_cap": arr,
+        })
+    else:
+        raise ValueError(
+            f"T2/T5 score: y_true must be ndarray (N,) or DataFrame; "
+            f"got {type(y_true).__name__}."
+        )
+
+    if isinstance(y_pred, pd.DataFrame):
+        if "predicted_equity_value" in y_pred.columns:
+            pred = y_pred.reset_index(drop=True)
+        else:
+            raise ValueError(
+                "T2/T5 score: y_pred DataFrame must have 'predicted_equity_value'."
+            )
+    else:
+        arr = np.asarray(y_pred).ravel()
+        if len(arr) != len(gt):
+            raise ValueError(
+                f"T2/T5 score: y_pred length {len(arr)} != y_true rows {len(gt)}."
+            )
+        pred = pd.DataFrame({
+            "ticker": gt["ticker"].values,
+            "date": gt["date"].values,
+            "predicted_equity_value": arr,
+        })
+    return pred, gt
+
+
+def _per_task_score_T2_T5(
+    y_true: Any,
+    y_pred: Any,
+    *,
+    cluster_keys: np.ndarray | None,
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+    return_sensitivity: bool,
+) -> dict[str, MetricValue]:
+    pred_df, gt_df = _adapt_t2_t5(y_true, y_pred)
+    merged = pred_df.merge(gt_df, on=["ticker", "date"], how="inner")
+    # NaN predictions: penalize as 100% APE (substitute median of y_true so the
+    # ratio is 1.0). Drops only rows with NaN ground truth or non-positive y_true
+    # — those are eval-side data issues, not method failures.
+    # Ground truth must never be NaN — if it is, that's a data-side bug
+    # (loader / preprocessing). Surface it instead of silently dropping.
+    gt_nan = merged["actual_market_cap"].isna().sum()
+    if gt_nan > 0:
+        raise ValueError(
+            f"T2/T5 score: {gt_nan} rows have NaN ground truth (actual_market_cap). "
+            "This is a loader/preprocessing bug — fix at data source."
+        )
+    valid = merged[merged["actual_market_cap"] > 0].reset_index(drop=True)
+    if valid.empty:
+        # No overlap between predictions and ground truth (or no positive
+        # ground truth): every gt row is "missing prediction" → fillna(0)
+        # penalty rule applies → APE = 100% per row. Saturate so the cell
+        # still scores (no silent score_failed).
+        gt_act = pd.to_numeric(gt_df["actual_market_cap"], errors="coerce").values.astype(np.float64)
+        gt_keep = np.isfinite(gt_act) & (gt_act > 0)
+        if gt_keep.any():
+            ape_gt = np.minimum(
+                np.abs(gt_act[gt_keep]) / np.abs(gt_act[gt_keep]),
+                _APE_CLIP_DEFAULT,
+            ) * 100.0
+            ck = gt_df["ticker"].astype(str).values[gt_keep] if resample == "cluster" else None
+            out: dict[str, MetricValue] = {
+                "mape": _wrap_metric(ape_gt, cluster_keys=ck, agg_fn=np.mean,
+                                     n_boot=n_boot, alpha=alpha, seed=seed, resample=resample),
+                "median_ape": _wrap_metric(ape_gt, cluster_keys=ck, agg_fn=np.median,
+                                           n_boot=n_boot, alpha=alpha, seed=seed, resample=resample),
+                "rank_correlation": _scalar_metric(None, resample=resample),
+                "rank_p_value": _scalar_metric(None, resample=resample),
+                "n_predictions": _scalar_metric(0, resample=resample),
+                "n_tickers": _scalar_metric(0, resample=resample),
+            }
+            return out
+        # Fully degenerate (no rows at all on either side) — last-resort scalar.
+        return {
+            "mape": _scalar_metric(100.0, resample=resample),
+            "median_ape": _scalar_metric(100.0, resample=resample),
+            "rank_correlation": _scalar_metric(None, resample=resample),
+            "rank_p_value": _scalar_metric(None, resample=resample),
+            "n_predictions": _scalar_metric(0, resample=resample),
+            "n_tickers": _scalar_metric(0, resample=resample),
+        }
+    # NaN penalty: substitute NaN predictions with ZERO (no-signal). APE
+    # = |0 - actual| / |actual| = 100% per row, then clipped at clip_default.
+    nan_mask = ~np.isfinite(valid["predicted_equity_value"].values)
+    n_nan_substituted = int(nan_mask.sum())
+    valid.loc[nan_mask, "predicted_equity_value"] = 0.0
+
+    # APE clipped at 10× = 1000%, returned in percent.
+    ape_pct, kept_mask = _ape_per_instance(
+        valid["predicted_equity_value"].values,
+        valid["actual_market_cap"].values,
+        clip=_APE_CLIP_DEFAULT,
+    )
+    valid_kept = valid.loc[kept_mask].reset_index(drop=True)
+    cluster_kept = (
+        valid_kept["ticker"].astype(str).values
+        if cluster_keys is None
+        else _align_cluster_keys(cluster_keys, len(valid), kept_mask)
+    )
+
+    out: dict[str, MetricValue] = {}
+    out["mape"] = _wrap_metric(
+        ape_pct, cluster_keys=cluster_kept, agg_fn=np.mean,
+        n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+    )
+    out["median_ape"] = _wrap_metric(
+        ape_pct, cluster_keys=cluster_kept, agg_fn=np.median,
+        n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+    )
+
+    # Spearman rank correlation (closed-form). When either input vector is
+    # constant (e.g. dry-run engines emit a single placeholder value) scipy
+    # returns NaN; emit None so the metric is treated as "not applicable".
+    from scipy.stats import spearmanr
+
+    rho_raw, p_raw = spearmanr(
+        valid_kept["predicted_equity_value"].values,
+        valid_kept["actual_market_cap"].values,
+    )
+    rho = float(rho_raw) if rho_raw is not None and not np.isnan(rho_raw) else None
+    p_val = float(p_raw) if p_raw is not None and not np.isnan(p_raw) else None
+    out["rank_correlation"] = _scalar_metric(rho, resample=resample)
+    out["rank_p_value"] = _scalar_metric(p_val, resample=resample)
+
+    out["n_predictions"] = _scalar_metric(int(len(valid_kept)), resample=resample)
+    out["n_tickers"] = _scalar_metric(
+        int(valid_kept["ticker"].nunique()), resample=resample,
+    )
+
+    if return_sensitivity:
+        raw_pred = valid["predicted_equity_value"].values
+        raw_act = valid["actual_market_cap"].values
+        for clip in _APE_SENSITIVITY_CLIPS:
+            ape_v, mask = _ape_per_instance(raw_pred, raw_act, clip=clip)
+            ck_v = _align_cluster_keys(
+                cluster_keys if cluster_keys is not None
+                else valid["ticker"].astype(str).values,
+                len(valid), mask,
+            )
+            key = (
+                f"mape_at_clip_{int(clip)}x" if np.isfinite(clip)
+                else "mape_at_clip_inf"
+            )
+            out[key] = _wrap_metric(
+                ape_v, cluster_keys=ck_v, agg_fn=np.mean,
+                n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+            )
+    return out
+
+
+# -------------------------------------------------------------------
+# T3 / T6 — Statement-/Generation-eval
+# -------------------------------------------------------------------
+
+
+def _per_task_score_T3_T6(
+    y_true: Any,
+    y_pred: Any,
+    *,
+    task: str,
+    cluster_keys: np.ndarray | None,
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+    return_sensitivity: bool,
+) -> dict[str, MetricValue]:
+    """Inputs are long-form DataFrames.
+
+    * y_true: ``[ticker, fiscal_year, field, value]`` (T6 GT may use
+      ``generator_field`` instead of ``field``; we normalise).
+    * y_pred: ``[ticker, fiscal_year, field, pred]`` (or ``value`` /
+      ``predicted_value`` — we accept either).
+    """
+    if not isinstance(y_true, pd.DataFrame) or not isinstance(y_pred, pd.DataFrame):
+        raise ValueError(
+            f"{task} score: y_true and y_pred must be long-form DataFrames."
+        )
+    gt = _normalize_field_col(y_true).copy()
+    pred = _normalize_field_col(y_pred).copy()
+
+    # Normalise the value column on the prediction side (accept both
+    # ``pred`` and ``value`` names so T6 short-circuit emitters can use
+    # either).
+    pred_value_col: str | None = None
+    for cand in ("pred", "value", "predicted_value"):
+        if cand in pred.columns:
+            pred_value_col = cand
+            break
+    if pred_value_col is None:
+        raise ValueError(
+            f"{task} score: y_pred must have a 'pred' (or 'value') column."
+        )
+
+    join_keys = ["ticker", "field"]
+    if "fiscal_year" in gt.columns and "fiscal_year" in pred.columns:
+        join_keys = ["ticker", "fiscal_year", "field"]
+
+    n_field_misses = 0
+    if "fiscal_year" in gt.columns:
+        gt_keys = set(zip(*[gt[k] for k in join_keys]))
+        pred_keys = set(zip(*[pred[k] for k in join_keys]))
+        n_field_misses = len(gt_keys - pred_keys)
+
+    merged = pred.merge(
+        gt, on=join_keys, how="inner",
+        suffixes=("_pred", "_actual"),
+    )
+    n_fields_matched = int(len(merged))
+
+    out: dict[str, MetricValue] = {
+        "n_fields_matched": _scalar_metric(n_fields_matched, resample=resample),
+        "n_field_misses": _scalar_metric(int(n_field_misses), resample=resample),
+        "n_tickers": _scalar_metric(
+            int(merged["ticker"].nunique()) if not merged.empty else 0,
+            resample=resample,
+        ),
+    }
+
+    if merged.empty:
+        # No (ticker, fiscal_year, field) overlap between predictions and
+        # ground truth: every y_true row is "missing" → fillna(0) penalty
+        # rule applies → APE = min(|0 - actual| / |actual|, clip) on
+        # |actual| ≥ 1.0 rows. Treat as a 100%-saturation failure so the
+        # cell still scores (no silent score_failed).
+        gt_act = pd.to_numeric(gt["value"], errors="coerce").values.astype(np.float64)
+        gt_keep = np.isfinite(gt_act) & (np.abs(gt_act) >= 1.0)
+        if gt_keep.any():
+            ape_gt = np.minimum(
+                np.abs(gt_act[gt_keep]) / np.abs(gt_act[gt_keep]),
+                _APE_CLIP_DEFAULT,
+            ) * 100.0  # =100% on every row (predict-zero penalty)
+            ck = gt["ticker"].astype(str).values[gt_keep] if resample == "cluster" else None
+            out["overall_mape"] = _wrap_metric(
+                ape_gt, cluster_keys=ck, agg_fn=np.mean,
+                n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+            )
+        else:
+            out["overall_mape"] = _scalar_metric(100.0, resample=resample)
+        out["per_field_mape"] = _none_metric(resample=resample)
+        if task == "T3":
+            out["balance_equation_accuracy"] = _scalar_metric(0.0, resample=resample)
+        out["success_rate"] = _scalar_metric(0.0, resample=resample)
+        return out
+
+    # Per-row APE in percent (clip 10×, |actual| ≥ 1.0).
+    pred_col = f"{pred_value_col}_pred" if pred_value_col != "value" else "value_pred"
+    if pred_col not in merged.columns:
+        # When pred_value_col == "value", the suffix path above lands at
+        # "value_pred"; otherwise the merge keeps the original name.
+        pred_col = pred_value_col + "_pred" if pred_value_col + "_pred" in merged.columns else pred_value_col
+    actual_col = "value_actual" if "value_actual" in merged.columns else "value"
+
+    pred_vals = pd.to_numeric(merged[pred_col], errors="coerce").values
+    act_vals = pd.to_numeric(merged[actual_col], errors="coerce").values
+    pred_arr = np.asarray(pred_vals, dtype=np.float64)
+    act_arr = np.asarray(act_vals, dtype=np.float64)
+    # NaN penalty: substitute NaN predictions with ZERO (no-signal)
+    # so unparseable field-tuples contribute APE=100% (clipped to
+    # _APE_CLIP_DEFAULT) rather than being silently excluded.
+    pred_nan = ~np.isfinite(pred_arr)
+    if pred_nan.any():
+        pred_arr[pred_nan] = 0.0
+    keep = np.isfinite(pred_arr) & np.isfinite(act_arr) & (np.abs(act_arr) >= 1.0)
+
+    ape = np.abs((pred_arr[keep] - act_arr[keep]) / act_arr[keep])
+    ape = np.minimum(ape, _APE_CLIP_DEFAULT) * 100.0
+
+    cluster_for_ape = merged.loc[keep, "ticker"].astype(str).values
+
+    out["overall_mape"] = _wrap_metric(
+        ape, cluster_keys=cluster_for_ape if resample == "cluster" else None,
+        agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+        resample=resample,
+    )
+
+    # Per-field MAPE table — single deterministic dict, not a Pydantic
+    # MetricValue. We expose the *count* of fields and a value-set under
+    # a separate key carrying the dict on `value` is awkward; instead
+    # we report n_fields_with_mape and the per-field dict is stored on the
+    # metric's dict via a stable plain key (caller can look up).
+    per_field: dict[str, float] = {}
+    field_weights: dict[str, int] = {}
+    for f, grp in merged.loc[keep].groupby(merged.loc[keep, "field"]):
+        gp = pd.to_numeric(grp[pred_col], errors="coerce")
+        ga = pd.to_numeric(grp[actual_col], errors="coerce")
+        valid = pd.DataFrame({"gp": gp, "ga": ga}).dropna()
+        valid = valid[valid["ga"].abs() >= 1.0]
+        if valid.empty:
+            continue
+        f_ape = np.minimum(
+            np.abs((valid["gp"].values - valid["ga"].values) / valid["ga"].values),
+            _APE_CLIP_DEFAULT,
+        )
+        per_field[str(f)] = float(f_ape.mean()) * 100.0
+        field_weights[str(f)] = int(len(valid))
+    # Surface per_field as a deterministic scalar metric (n_fields_with_mape).
+    out["n_fields_with_mape"] = _scalar_metric(
+        len(per_field), resample=resample,
+    )
+    # Stash the dict on a flat namespace key (callers extract via
+    # ``score(...)["per_field_mape_dict"].value`` won't work because
+    # MetricValue.value is a float — so we expose a side dict on the
+    # function's return as ``per_field_mape`` mapped to a degenerate
+    # MetricValue carrying the average MAPE. To preserve the legacy field
+    # name we expose the weighted-overall here too).
+    if per_field:
+        total_w = sum(field_weights.values())
+        weighted = sum(per_field[f] * field_weights[f] / total_w for f in per_field)
+        # We re-expose this under a stable name so legacy consumers can
+        # still pick it up.
+        out["per_field_mape_weighted_avg"] = _scalar_metric(
+            float(weighted), resample=resample,
+        )
+
+    if task in ("T3", "T6"):
+        # Balance-sheet equation accuracy (per ticker).
+        bs_checked = 0
+        bs_pass = 0
+        m = merged.loc[keep]
+        for tk in m["ticker"].unique():
+            tk_data = m[m["ticker"] == tk]
+            fields_str = tk_data["field"].astype(str)
+            arow = tk_data[fields_str == "Assets"]
+            lrow = tk_data[fields_str == "Liabilities"]
+            erow = tk_data[fields_str == "StockholdersEquity"]
+            if not arow.empty and not lrow.empty and not erow.empty:
+                bs_checked += 1
+                a = pd.to_numeric(arow[pred_col].iloc[0], errors="coerce")
+                l = pd.to_numeric(lrow[pred_col].iloc[0], errors="coerce")
+                e = pd.to_numeric(erow[pred_col].iloc[0], errors="coerce")
+                if (
+                    pd.notna(a) and pd.notna(l) and pd.notna(e)
+                    and float(a) > 0
+                    and abs(float(a) - float(l) - float(e)) / float(a) < 0.01
+                ):
+                    bs_pass += 1
+        out["balance_equation_accuracy"] = _scalar_metric(
+            float(bs_pass / bs_checked) if bs_checked > 0 else float("nan"),
+            resample=resample,
+        )
+        out["balance_equation_checked"] = _scalar_metric(
+            int(bs_checked), resample=resample,
+        )
+
+    # success_rate = unique tickers with a parseable prediction / total
+    # tickers requested (we approximate via the union of GT tickers).
+    n_attempted = int(gt["ticker"].nunique()) if "ticker" in gt.columns else 0
+    n_succeeded = int(pred["ticker"].nunique()) if "ticker" in pred.columns else 0
+    out["success_rate"] = _scalar_metric(
+        float(n_succeeded / n_attempted) if n_attempted > 0 else 0.0,
+        resample=resample,
+    )
+
+    if return_sensitivity:
+        raw_pred = pred_arr[keep]
+        raw_act = act_arr[keep]
+        for clip in _APE_SENSITIVITY_CLIPS:
+            ape_s = np.abs((raw_pred - raw_act) / raw_act)
+            if np.isfinite(clip):
+                ape_s = np.minimum(ape_s, clip)
+            ape_s = ape_s * 100.0
+            key = (
+                f"mape_at_clip_{int(clip)}x" if np.isfinite(clip)
+                else "mape_at_clip_inf"
+            )
+            out[key] = _wrap_metric(
+                ape_s,
+                cluster_keys=cluster_for_ape if resample == "cluster" else None,
+                agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+                resample=resample,
+            )
+    return out
+
+
+# -------------------------------------------------------------------
+# T4 — Scenario-conditioned forecasting
+# -------------------------------------------------------------------
+
+
+def _adapt_t4(y_true: Any, y_pred: Any) -> tuple[pd.DataFrame, pd.DataFrame]:
+    if isinstance(y_true, pd.DataFrame) and "actual_return_pct" in y_true.columns:
+        gt = y_true.reset_index(drop=True)
+    elif isinstance(y_true, (np.ndarray, list, pd.Series)):
+        arr = np.asarray(y_true).ravel().astype(np.float64)
+        gt = pd.DataFrame({
+            "scenario_id": [f"sc_{i}" for i in range(len(arr))],
+            "ticker": [f"row_{i}" for i in range(len(arr))],
+            "actual_return_pct": arr,
+        })
+    else:
+        raise ValueError(
+            f"T4 score: y_true must be ndarray (N,) or DataFrame; "
+            f"got {type(y_true).__name__}."
+        )
+    if isinstance(y_pred, pd.DataFrame):
+        if "predicted_return_pct" in y_pred.columns:
+            pred = y_pred.reset_index(drop=True)
+        else:
+            raise ValueError(
+                "T4 score: y_pred DataFrame must have 'predicted_return_pct'."
+            )
+    else:
+        arr = np.asarray(y_pred).ravel()
+        if len(arr) != len(gt):
+            raise ValueError(
+                f"T4 score: y_pred length {len(arr)} != y_true rows {len(gt)}."
+            )
+        pred_dict: dict[str, Any] = {
+            "scenario_id": gt["scenario_id"].values,
+            "ticker": gt["ticker"].values,
+            "predicted_return_pct": arr,
+        }
+        if "event_type" in gt.columns:
+            pred_dict["event_type"] = gt["event_type"].values
+        pred = pd.DataFrame(pred_dict)
+    return pred, gt
+
+
+def _per_task_score_T4(
+    y_true: Any,
+    y_pred: Any,
+    *,
+    cluster_keys: np.ndarray | None,
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+) -> dict[str, MetricValue]:
+    pred_df, gt_df = _adapt_t4(y_true, y_pred)
+    merged = pred_df.merge(gt_df, on=["scenario_id", "ticker"], how="inner")
+    merged = merged.reset_index(drop=True)
+    # Ground truth must never be NaN — surface data-side bugs.
+    gt_nan = merged["actual_return_pct"].isna().sum()
+    if gt_nan > 0:
+        raise ValueError(
+            f"T4 score: {gt_nan} rows have NaN ground truth (actual_return_pct). "
+            "This is a loader/preprocessing bug — fix at data source."
+        )
+    if merged.empty:
+        # No overlap between predictions and ground truth: fillna(0)
+        # penalty → MAE = mean(|actual_return_pct|) using gt rows.
+        gt_act = pd.to_numeric(gt_df["actual_return_pct"], errors="coerce").values.astype(np.float64)
+        gt_keep = np.isfinite(gt_act)
+        if gt_keep.any():
+            abs_err_gt = np.abs(gt_act[gt_keep])  # |0 - actual| = |actual|
+            ck = (
+                gt_df["scenario_id"].astype(str).values[gt_keep]
+                if resample == "cluster" and "scenario_id" in gt_df.columns else None
+            )
+            return {
+                "return_mae_pct": _wrap_metric(abs_err_gt, cluster_keys=ck, agg_fn=np.mean,
+                                               n_boot=n_boot, alpha=alpha, seed=seed, resample=resample),
+                "directional_accuracy": _scalar_metric(0.0, resample=resample),
+                "ci_calibration_95": _none_metric(resample=resample),
+                "n_predictions": _scalar_metric(0, resample=resample),
+                "n_scenarios": _scalar_metric(0, resample=resample),
+            }
+        return {
+            "return_mae_pct": _scalar_metric(0.0, resample=resample),
+            "directional_accuracy": _scalar_metric(0.0, resample=resample),
+            "ci_calibration_95": _none_metric(resample=resample),
+            "n_predictions": _scalar_metric(0, resample=resample),
+            "n_scenarios": _scalar_metric(0, resample=resample),
+        }
+    # NaN-prediction penalty: substitute with 0.0 (no-signal); MAE = |actual|.
+    nan_mask = ~np.isfinite(merged["predicted_return_pct"].values)
+    merged.loc[nan_mask, "predicted_return_pct"] = 0.0
+
+    pred = merged["predicted_return_pct"].values.astype(np.float64)
+    actual = merged["actual_return_pct"].values.astype(np.float64)
+    abs_err = np.abs(pred - actual)
+    dir_agree = (np.sign(pred) == np.sign(actual)).astype(np.float64)
+
+    # Cluster by scenario_id for T4 (default). Caller may override.
+    if cluster_keys is None:
+        cluster_v = merged["scenario_id"].astype(str).values
+    else:
+        cluster_v = np.asarray(cluster_keys).ravel()
+        if cluster_v.size != len(merged):
+            # Best-effort: rebuild from merged scenario_id if mismatch.
+            cluster_v = merged["scenario_id"].astype(str).values
+
+    out: dict[str, MetricValue] = {}
+    out["return_mae_pct"] = _wrap_metric(
+        abs_err, cluster_keys=cluster_v if resample == "cluster" else None,
+        agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+        resample=resample,
+    )
+    out["directional_accuracy"] = _wrap_metric(
+        dir_agree, cluster_keys=cluster_v if resample == "cluster" else None,
+        agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+        resample=resample,
+    )
+    if {"predicted_ci_low", "predicted_ci_high"}.issubset(merged.columns):
+        in_ci = (
+            (merged["actual_return_pct"] >= merged["predicted_ci_low"])
+            & (merged["actual_return_pct"] <= merged["predicted_ci_high"])
+        ).astype(np.float64).values
+        out["ci_calibration_95"] = _wrap_metric(
+            in_ci, cluster_keys=cluster_v if resample == "cluster" else None,
+            agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample,
+        )
+    else:
+        # No quantile predictions -> metric not applicable. Emit a
+        # MetricValue with value=None so downstream consumers can detect
+        # this case via `is None` rather than a NaN finiteness probe.
+        out["ci_calibration_95"] = _none_metric(resample=resample)
+
+    out["n_predictions"] = _scalar_metric(int(len(merged)), resample=resample)
+    out["n_scenarios"] = _scalar_metric(
+        int(merged["scenario_id"].nunique()), resample=resample,
+    )
+    return out
+
+
+# -------------------------------------------------------------------
+# T7 — Real-estate valuation
+# -------------------------------------------------------------------
+
+
+def _per_task_score_T7(
+    y_true: Any,
+    y_pred: Any,
+    *,
+    cluster_keys: np.ndarray | None,
+    n_boot: int | Literal["adaptive"],
+    alpha: float,
+    seed: int,
+    resample: Literal["cluster", "iid"],
+    return_sensitivity: bool,
+) -> dict[str, MetricValue]:
+    if not isinstance(y_true, pd.DataFrame) or not isinstance(y_pred, pd.DataFrame):
+        raise ValueError("T7 score: both y_true and y_pred must be DataFrames.")
+
+    if "address" not in y_true.columns or "address" not in y_pred.columns:
+        # Fall back to positional alignment.
+        merged = pd.concat([
+            y_pred.reset_index(drop=True),
+            y_true.reset_index(drop=True).add_suffix("_actual"),
+        ], axis=1)
+    else:
+        merged = y_pred.merge(
+            y_true, on="address", how="inner", suffixes=("_pred", "_actual"),
+        )
+    if merged.empty:
+        # No overlapping addresses: fillna(0) penalty per gt rent + price
+        # column. Saturates to 100% APE per row.
+        out: dict[str, MetricValue] = {
+            "n_predictions": _scalar_metric(0, resample=resample),
+        }
+        for target, actual_cands in [
+            ("rent", ["rent", "rentEstimate", "rent_estimate"]),
+            ("price", ["price", "lastSalePrice", "last_sale_price"]),
+        ]:
+            actual_col = next((c for c in actual_cands if c in y_true.columns), None)
+            if actual_col is None:
+                out[f"{target}_MAPE"] = _scalar_metric(float("nan"), resample=resample)
+                out[f"{target}_median_APE"] = _scalar_metric(float("nan"), resample=resample)
+                out[f"{target}_n_valid"] = _scalar_metric(0, resample=resample)
+                continue
+            gt_act = pd.to_numeric(y_true[actual_col], errors="coerce").values.astype(np.float64)
+            gt_keep = np.isfinite(gt_act) & (np.abs(gt_act) > 0)
+            if gt_keep.any():
+                ape_gt = np.minimum(
+                    np.abs(gt_act[gt_keep]) / np.abs(gt_act[gt_keep]),
+                    _APE_CLIP_DEFAULT,
+                ) * 100.0
+                ck = (
+                    y_true["address"].astype(str).values[gt_keep]
+                    if resample == "cluster" and "address" in y_true.columns else None
+                )
+                out[f"{target}_MAPE"] = _wrap_metric(
+                    ape_gt, cluster_keys=ck, agg_fn=np.mean,
+                    n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+                )
+                out[f"{target}_median_APE"] = _wrap_metric(
+                    ape_gt, cluster_keys=ck, agg_fn=np.median,
+                    n_boot=n_boot, alpha=alpha, seed=seed, resample=resample,
+                )
+                out[f"{target}_n_valid"] = _scalar_metric(int(gt_keep.sum()), resample=resample)
+            else:
+                out[f"{target}_MAPE"] = _scalar_metric(100.0, resample=resample)
+                out[f"{target}_median_APE"] = _scalar_metric(100.0, resample=resample)
+                out[f"{target}_n_valid"] = _scalar_metric(0, resample=resample)
+        return out
+
+    out: dict[str, MetricValue] = {
+        "n_predictions": _scalar_metric(int(len(merged)), resample=resample),
+    }
+
+    for target, pred_cands, actual_cands in [
+        ("rent",
+         ["pred_rent", "predicted_rent", "rent_pred"],
+         ["rent_actual", "rent", "rentEstimate_actual", "rent_estimate_actual"]),
+        ("price",
+         ["pred_price", "predicted_price", "price_pred"],
+         ["price_actual", "price", "lastSalePrice_actual", "last_sale_price_actual"]),
+    ]:
+        pred_col = next((c for c in pred_cands if c in merged.columns), None)
+        actual_col = next((c for c in actual_cands if c in merged.columns), None)
+        if pred_col is None or actual_col is None:
+            out[f"{target}_MAPE"] = _scalar_metric(float("nan"), resample=resample)
+            out[f"{target}_median_APE"] = _scalar_metric(
+                float("nan"), resample=resample,
+            )
+            out[f"{target}_n_valid"] = _scalar_metric(0, resample=resample)
+            continue
+
+        pred_vals = pd.to_numeric(merged[pred_col], errors="coerce").values
+        actual_vals = pd.to_numeric(merged[actual_col], errors="coerce").values
+        # NaN penalty: substitute NaN predictions with ZERO (no-signal).
+        # APE = 100% per row, clipped at clip_default.
+        nan_mask = ~np.isfinite(pred_vals)
+        if nan_mask.any():
+            pred_vals = np.where(nan_mask, 0.0, pred_vals)
+        ape_pct, mask = _ape_per_instance(
+            pred_vals, actual_vals, clip=_APE_CLIP_DEFAULT,
+        )
+        if ape_pct.size == 0:
+            out[f"{target}_MAPE"] = _scalar_metric(float("nan"), resample=resample)
+            out[f"{target}_median_APE"] = _scalar_metric(
+                float("nan"), resample=resample,
+            )
+            out[f"{target}_n_valid"] = _scalar_metric(0, resample=resample)
+            continue
+
+        # T7 cluster bootstrap = address-level (one cluster per row, so it
+        # collapses to IID) by convention. If the caller supplied
+        # cluster_keys (e.g. metro / property_type) honour that.
+        if cluster_keys is not None:
+            ck = _align_cluster_keys(cluster_keys, len(merged), mask)
+        else:
+            ck = merged.loc[mask, "address"].astype(str).values if "address" in merged.columns else None
+
+        out[f"{target}_MAPE"] = _wrap_metric(
+            ape_pct, cluster_keys=ck if resample == "cluster" else None,
+            agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample,
+        )
+        out[f"{target}_median_APE"] = _wrap_metric(
+            ape_pct, cluster_keys=ck if resample == "cluster" else None,
+            agg_fn=np.median, n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample,
+        )
+        out[f"{target}_n_valid"] = _scalar_metric(
+            int(ape_pct.size), resample=resample,
+        )
+
+        if return_sensitivity:
+            for clip in _APE_SENSITIVITY_CLIPS:
+                ape_v, mask_v = _ape_per_instance(
+                    pred_vals, actual_vals, clip=clip,
+                )
+                ck_v = (
+                    _align_cluster_keys(cluster_keys, len(merged), mask_v)
+                    if cluster_keys is not None
+                    else (
+                        merged.loc[mask_v, "address"].astype(str).values
+                        if "address" in merged.columns else None
+                    )
+                )
+                key = (
+                    f"{target}_MAPE_at_clip_{int(clip)}x"
+                    if np.isfinite(clip) else f"{target}_MAPE_at_clip_inf"
+                )
+                out[key] = _wrap_metric(
+                    ape_v, cluster_keys=ck_v if resample == "cluster" else None,
+                    agg_fn=np.mean, n_boot=n_boot, alpha=alpha, seed=seed,
+                    resample=resample,
+                )
+    return out
+
+
+# ===================================================================
+# Cluster-key alignment helper
+# ===================================================================
+
+
+def _align_cluster_keys(
+    cluster_keys: Any,
+    n_total: int,
+    mask: np.ndarray,
+) -> np.ndarray | None:
+    """Return cluster_keys masked to the rows kept (or None if no keys).
+
+    Tolerant fallbacks:
+    * If ``cluster_keys`` is shorter than ``n_total`` (the upstream merge
+      dropped rows beyond what the caller knows about), drop cluster_keys
+      and let the bootstrap fall back to IID — better than raising.
+    """
+    if cluster_keys is None:
+        return None
+    arr = np.asarray(cluster_keys).ravel()
+    if arr.size == n_total:
+        return arr[mask]
+    if arr.size == int(mask.sum()):
+        return arr  # already masked
+    # Length mismatch: typically because the eval-side merge / dropna
+    # discarded rows the caller didn't know about. Fall back to None
+    # (degenerate IID bootstrap) rather than raising.
+    return None
+
+
+# ===================================================================
+# Public API: score
+# ===================================================================
+
+
+def score(
+    task: str,
+    y_true: Any,
+    y_pred: Any,
+    *,
+    cluster_keys: Any = None,
+    close_last: Any = None,
+    resample: Literal["cluster", "iid"] = "cluster",
+    n_boot: int | Literal["adaptive"] = "adaptive",
+    alpha: float = 0.05,
+    seed: int = 42,
+    return_sensitivity: bool = False,
+) -> dict[str, MetricValue]:
+    """Score a (task, y_true, y_pred) triple.
+
+    Returns
+    -------
+    dict[str, MetricValue]
+        Per-task metric mapping. Keys per task are documented in the module
+        docstring; every value is a Pydantic ``MetricValue`` carrying
+        ``value, ci_lo, ci_hi, std, n_boot, resample``.
+
+    Notes
+    -----
+    * The default resample is ``"cluster"``; on panel data this is the
+      statistically correct choice.
+    * If ``cluster_keys`` is None, the function derives it from the inputs:
+      ``ticker`` for T1/T2/T3/T5/T6/T7, ``scenario_id`` for T4. The caller
+      may override.
+    * ``close_last`` is a 1-D float array aligned to ``y_true`` rows for T1.
+      If unavailable we fall back to ``y_pred[:, 0]`` and emit a warning;
+      the metric ``directional_accuracy_anchor_fallback`` is set to 1.0 so
+      consumers can detect the fallback.
+    * ``n_boot="adaptive"`` starts at 1,000 bootstrap draws and escalates
+      to 10,000 if the relative CI half-width exceeds 5%.
+    """
+    if resample not in ("cluster", "iid"):
+        raise ValueError(f"resample must be 'cluster' or 'iid', got {resample!r}")
+
+    ck_arr: np.ndarray | None
+    if cluster_keys is None:
+        ck_arr = None
+    else:
+        ck_arr = np.asarray(cluster_keys).ravel()
+
+    cl_arr: np.ndarray | None
+    if close_last is None:
+        cl_arr = None
+    else:
+        cl_arr = np.asarray(close_last, dtype=np.float64).ravel()
+
+    if task == "T1":
+        if ck_arr is None and isinstance(y_true, np.ndarray):
+            # No cluster keys — caller didn't pass meta["ticker"]; we cannot
+            # derive ticker from y_true alone. Run cluster bootstrap with a
+            # one-cluster-per-row degenerate (collapses to IID).
+            ck_arr = np.arange(len(y_true))
+        return _per_task_score_T1(
+            y_true, y_pred,
+            cluster_keys=ck_arr, close_last=cl_arr,
+            n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample, return_sensitivity=return_sensitivity,
+        )
+
+    if task in ("T2", "T5"):
+        return _per_task_score_T2_T5(
+            y_true, y_pred,
+            cluster_keys=ck_arr,
+            n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample, return_sensitivity=return_sensitivity,
+        )
+
+    if task in ("T3", "T6"):
+        return _per_task_score_T3_T6(
+            y_true, y_pred,
+            task=task,
+            cluster_keys=ck_arr,
+            n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample, return_sensitivity=return_sensitivity,
+        )
+
+    if task == "T4":
+        return _per_task_score_T4(
+            y_true, y_pred,
+            cluster_keys=ck_arr,
+            n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample,
+        )
+
+    if task == "T7":
+        return _per_task_score_T7(
+            y_true, y_pred,
+            cluster_keys=ck_arr,
+            n_boot=n_boot, alpha=alpha, seed=seed,
+            resample=resample, return_sensitivity=return_sensitivity,
+        )
+
+    raise ValueError(f"Unknown task: {task!r}")
+
+
+# ===================================================================
+# Multiple-comparisons correction — per task
+# ===================================================================
+
+
+def _holm_correction(p_values: np.ndarray, alpha: float = 0.05) -> tuple[np.ndarray, np.ndarray]:
+    """Holm-Bonferroni step-down correction.
+
+    Returns ``(p_adjusted, reject)`` arrays of the same length as
+    ``p_values``, where ``p_adjusted`` is monotone-increasing in original
+    rank and ``reject`` is the boolean rejection vector at family-wise
+    error rate ``alpha``.
+    """
+    p = np.asarray(p_values, dtype=np.float64).ravel()
+    m = p.size
+    if m == 0:
+        return p, np.array([], dtype=bool)
+    order = np.argsort(p)
+    p_sorted = p[order]
+    p_adj_sorted = np.empty(m, dtype=np.float64)
+    running_max = 0.0
+    for i in range(m):
+        adj = (m - i) * p_sorted[i]
+        running_max = max(running_max, adj)
+        p_adj_sorted[i] = min(running_max, 1.0)
+    # Unsort.
+    p_adj = np.empty_like(p_adj_sorted)
+    p_adj[order] = p_adj_sorted
+    return p_adj, p_adj <= alpha
+
+
+def _bh_correction(p_values: np.ndarray, alpha: float = 0.05) -> tuple[np.ndarray, np.ndarray]:
+    """Benjamini-Hochberg FDR correction."""
+    p = np.asarray(p_values, dtype=np.float64).ravel()
+    m = p.size
+    if m == 0:
+        return p, np.array([], dtype=bool)
+    order = np.argsort(p)
+    p_sorted = p[order]
+    ranks = np.arange(1, m + 1)
+    p_adj_sorted_raw = p_sorted * m / ranks
+    # Enforce monotonicity (running min from the right).
+    p_adj_sorted = np.minimum.accumulate(p_adj_sorted_raw[::-1])[::-1]
+    p_adj_sorted = np.minimum(p_adj_sorted, 1.0)
+    p_adj = np.empty_like(p_adj_sorted)
+    p_adj[order] = p_adj_sorted
+    return p_adj, p_adj <= alpha
+
+
+def _extract_record(rec: Any) -> dict[str, Any]:
+    """Coerce a record (Pydantic / dict / dataclass) to a plain dict."""
+    if isinstance(rec, dict):
+        return rec
+    if hasattr(rec, "model_dump"):
+        return rec.model_dump()
+    if hasattr(rec, "__dict__"):
+        return dict(rec.__dict__)
+    raise TypeError(f"Cannot extract record of type {type(rec).__name__}")
+
+
+def _extract_metric_value(metrics: Any, key: str) -> tuple[float, float, float, int]:
+    """Pull (value, std, n_boot, ok) out of a metric dict-or-MetricValue.
+
+    Returns ``ok=0`` when the metric is missing or its ``value`` is ``None``
+    (semantic "not applicable"); finite values pass through with ``ok=1``.
+    """
+    m = metrics.get(key) if isinstance(metrics, dict) else None
+    if m is None:
+        return float("nan"), float("nan"), 0, 0
+    if isinstance(m, MetricValue):
+        if m.value is None:
+            return float("nan"), float("nan"), int(m.n_boot), 0
+        std = float(m.std) if m.std is not None else float("nan")
+        return float(m.value), std, int(m.n_boot), 1
+    if isinstance(m, dict):
+        v = m.get("value", None)
+        if v is None:
+            return float("nan"), float("nan"), int(m.get("n_boot", 0)), 0
+        return (
+            float(v),
+            float(m.get("std", float("nan")) if m.get("std", None) is not None else float("nan")),
+            int(m.get("n_boot", 0)),
+            1,
+        )
+    return float("nan"), float("nan"), 0, 0
+
+
+# Default headline metric per task (lower-is-better unless noted).
+_HEADLINE_METRIC: dict[str, tuple[str, bool]] = {
+    "T1": ("mse", True),
+    "T2": ("mape", True),
+    "T3": ("overall_mape", True),
+    "T4": ("return_mae_pct", True),
+    "T5": ("mape", True),
+    "T6": ("overall_mape", True),
+    "T7": ("rent_MAPE", True),
+}
+
+
+def compare_methods(
+    task: str,
+    records: list,
+    *,
+    correction: Literal["holm", "bh"] = "holm",
+    alpha: float = 0.05,
+    headline_metric: str | None = None,
+) -> "pd.DataFrame":
+    """Pairwise compare every method on ``task`` against the best baseline.
+
+    Parameters
+    ----------
+    task
+        ``"T1"`` .. ``"T7"``.
+    records
+        Iterable of ``RunRecord``-shaped objects (Pydantic models, dicts,
+        or anything with ``.method_id``, ``.task``, ``.metrics``).
+    correction
+        ``"holm"`` (default; FWER) or ``"bh"`` (FDR). Per-task scope only —
+        no cross-task FWER claim.
+    alpha
+        Family-wise error rate (Holm) or false discovery rate (BH).
+    headline_metric
+        Override the per-task headline metric (default uses
+        ``_HEADLINE_METRIC[task]``). The metric must exist on every
+        record's ``metrics`` dict.
+
+    Returns
+    -------
+    DataFrame
+        One row per method with columns
+        ``[method_id, value, std, n_boot, z, p_value, p_adj, reject_null]``.
+        The lowest-value method (or highest, if ``lower_is_better=False``)
+        is the reference; its ``p_value`` is NaN.
+    """
+    if task not in _HEADLINE_METRIC:
+        raise ValueError(f"Unknown task: {task!r}")
+    metric_key, lower_is_better = _HEADLINE_METRIC[task]
+    if headline_metric is not None:
+        metric_key = headline_metric
+
+    rows: list[dict[str, Any]] = []
+    for rec in records:
+        d = _extract_record(rec)
+        if d.get("task") != task:
+            continue
+        metrics = d.get("metrics")
+        if not metrics:
+            continue
+        v, std, n_b, ok = _extract_metric_value(metrics, metric_key)
+        if not ok or not np.isfinite(v):
+            continue
+        rows.append({
+            "method_id": d.get("method_id", "?"),
+            "value": v,
+            "std": std,
+            "n_boot": n_b,
+        })
+    if not rows:
+        return pd.DataFrame(
+            columns=["method_id", "value", "std", "n_boot",
+                     "z", "p_value", "p_adj", "reject_null"]
+        )
+
+    df = pd.DataFrame(rows)
+    # Pick the reference method.
+    if lower_is_better:
+        ref_idx = int(df["value"].idxmin())
+    else:
+        ref_idx = int(df["value"].idxmax())
+    ref_v = float(df.loc[ref_idx, "value"])
+    ref_std = float(df.loc[ref_idx, "std"])
+
+    # Two-sided z test using bootstrap stds; combined under independence
+    # (this is conservative — bootstrap stds are within-method only;
+    # cross-method covariance is unknown without the full bootstrap
+    # distribution, which we don't carry on RunRecord by design).
+    from scipy.stats import norm
+
+    z_vals: list[float] = []
+    p_vals: list[float] = []
+    for i, row in df.iterrows():
+        if i == ref_idx:
+            z_vals.append(float("nan"))
+            p_vals.append(float("nan"))
+            continue
+        denom = float(np.sqrt(row["std"] ** 2 + ref_std ** 2))
+        if denom <= 0 or not np.isfinite(denom):
+            z_vals.append(float("nan"))
+            p_vals.append(float("nan"))
+            continue
+        z = (float(row["value"]) - ref_v) / denom
+        z_vals.append(z)
+        p_vals.append(float(2.0 * (1.0 - norm.cdf(abs(z)))))
+
+    df["z"] = z_vals
+    df["p_value"] = p_vals
+
+    p_arr = np.asarray(df["p_value"].values, dtype=np.float64)
+    finite = np.isfinite(p_arr)
+    p_finite = p_arr[finite]
+    if correction == "holm":
+        p_adj_finite, reject_finite = _holm_correction(p_finite, alpha=alpha)
+    elif correction == "bh":
+        p_adj_finite, reject_finite = _bh_correction(p_finite, alpha=alpha)
+    else:
+        raise ValueError(f"correction must be 'holm' or 'bh', got {correction!r}")
+
+    p_adj = np.full_like(p_arr, np.nan)
+    reject = np.zeros(p_arr.size, dtype=bool)
+    p_adj[finite] = p_adj_finite
+    reject[finite] = reject_finite
+    df["p_adj"] = p_adj
+    df["reject_null"] = reject
+
+    return df.sort_values("value", ascending=lower_is_better).reset_index(drop=True)
+
+
+# ===================================================================
+# Convenience re-exports
+# ===================================================================
+
+__all__ = [
+    "score",
+    "compare_methods",
+    "MetricValue",
+    "_bootstrap_ci",
+    "_close_anchor_da",
+    "_holm_correction",
+    "_bh_correction",
+]

code/experiments/__init__.py

@@ -0,0 +1 @@
+"""Experiment orchestration: panel registry, runners, reporting."""

code/experiments/__main__.py

@@ -0,0 +1,16 @@
+"""CLI entry: ``python -m projects.agent_builder.scripts.whatif_bench.experiments``.
+
+Thin wrapper over :func:`experiments.run_all.main` so the package can be
+launched with ``-m experiments``. Argument surface is documented in
+:mod:`experiments.run_all`.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from .run_all import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

code/experiments/adapters/scout_qlora_smoke_20260519T062736Z/fitted_fields.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae04d62bcb8df1cf7c443eb000ad76031ddedd5db5d544664ef1bec4b0f0a961
+size 80985

code/experiments/adapters/scout_qlora_smoke_20260519T070504Z/fitted_fields.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae04d62bcb8df1cf7c443eb000ad76031ddedd5db5d544664ef1bec4b0f0a961
+size 80985

code/experiments/aggregate_results.py

@@ -0,0 +1,586 @@
+"""Aggregate Phase-4 :class:`RunRecord` JSONs into per-task tables.
+
+Reads one or more ``RunRecord``-list JSON files (the canonical artefact
+written by :mod:`experiments.run_all`), validates each via Pydantic, and
+emits a per-task pandas DataFrame keyed by
+``[method_id, metric_name, value, ci_lo, ci_hi, n_boot]``.
+
+Compared to the legacy aggregator (which merged per-family `_results.json`
+dicts), this module:
+
+1. Accepts an input glob (``--input``) defaulting to
+   ``experiments/results/canon_*.json``.
+2. Round-trips JSON through ``pydantic.TypeAdapter[list[RunRecord]]``.
+3. Skips records with ``status != "ok"`` (footnote count printed).
+4. Migrates any ``schema_version=1`` records via
+   :func:`tools.migrate_results._migrate_one` before validation.
+5. Groups by ``(task, method_id, granularity, seed)`` and emits one
+   DataFrame per task with one row per ``(method, metric)`` pair.
+
+CLI::
+
+    python -m projects.agent_builder.scripts.whatif_bench.experiments.aggregate_results \\
+        --input 'experiments/results/canon_*.json' \\
+        --output experiments/paper_artifacts/aggregate.parquet
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import pydantic
+
+from .. import config
+from ..macrolens import RunRecord
+from ..tools.migrate_results import _migrate_one
+
+logger = logging.getLogger(__name__)
+
+
+_TASK_ORDER: tuple[str, ...] = ("T1", "T2", "T3", "T4", "T5", "T6", "T7")
+
+
+def _panel_method_ids() -> tuple[set[str], set[str]]:
+    """Return ``(panel_methods, ablation_methods)`` as id sets.
+
+    Allow-list source of truth: only ``method_id``s in
+    :data:`experiments.panel.ALL_METHODS` (the 19 canonical panel methods)
+    plus the deferred FT slot (``"scout_ft"``, Family-7) are surfaced in
+    aggregation. Anything else (stale ``gpt_oss_120b``, ``gemma4``, etc.)
+    is invisible to the aggregator.
+
+    The ablation allow-list is :data:`panel.ABLATION_MODEL_IDS`
+    (``gpt51``, ``gemini3_flash``) ∪ ``{"lightgbm"}`` (Phase 2.1) ∪
+    ``{"scout_ft"}`` (Phase 3.1).
+    """
+    from .panel import ABLATION_MODEL_IDS, ALL_METHODS as _PANEL_METHODS
+
+    panel = {m.id for m in _PANEL_METHODS}
+    panel.add("scout_ft")  # deferred Family-7 FT slot (Phase 3.1)
+    ablation = set(ABLATION_MODEL_IDS) | {"lightgbm", "scout_ft"}
+    return panel, ablation
+
+
+# Per-task primary metric for the leaderboard view emitted by ``--summary``.
+# Mirrors :data:`experiments.panel.TASK_METADATA` but resolved to the metric
+# *key* the runners emit (matches what aggregate_results writes to the long
+# DataFrame's ``metric_name`` column).
+_PRIMARY_METRIC_KEY: dict[str, str] = {
+    "T1": "mse",
+    "T2": "median_ape",
+    "T3": "overall_mape",
+    "T4": "return_mae_pct",
+    "T5": "median_ape",
+    "T6": "overall_mape",
+    "T7": "rent_MAPE",
+}
+
+# Whether lower is better (True) or higher is better (False) for each task's
+# primary metric. All current MacroLens primary metrics are loss-style; this
+# table stays explicit for safety in case of future additions.
+_PRIMARY_METRIC_LOWER_IS_BETTER: dict[str, bool] = {
+    "T1": True, "T2": True, "T3": True, "T4": True,
+    "T5": True, "T6": True, "T7": True,
+}
+
+
+def _load_records(
+    paths: list[Path],
+) -> tuple[list[tuple[RunRecord, int | None]], int, int, int, int, int]:
+    """Read every JSON in ``paths`` and validate as ``list[RunRecord]``.
+
+    Returns ``(records, n_skipped_non_ok, n_migrated_v1, n_dedup_dropped,
+    n_partial_dropped, n_off_panel)``.
+
+    Validity gates (in order):
+    1. dedupe (method_id, task, granularity, seed) keeping the LATEST
+       ``timestamp`` (mtime tiebreaker) — newer reruns supersede older
+       tainted records EVEN IF the newer record is ``predict_failed``.
+       This ensures a rerun that legitimately fails replaces an old
+       silently-tainted "ok" record.
+    2. status == "ok" — drop the record if the latest run failed.
+    3. **All-NaN gate**: drop records whose primary-metric ``value`` is
+       ``None`` (eval returned None because every prediction was NaN).
+    4. **Partial-NaN gate**: drop records whose ``n_predictions`` (or
+       ``n_instances``) is less than the canonical eval N for that task,
+       OR whose ``success_rate`` (T3/T6) is < 1.0. This catches the
+       silent-NaN-on-some-rows cells that the all-NaN gate misses.
+    """
+    import re as _re
+    from ..dataloader.budgets import EVAL_N_PER_TASK
+
+    adapter = pydantic.TypeAdapter(list[RunRecord])
+    n_migrated = 0
+
+    # Filename horizon parser: canon files written by the MH chains carry
+    # ``_h<H>_`` in the filename. The RunRecord schema does not store
+    # horizon explicitly, so we recover it from the source path so the
+    # aggregator can distinguish two horizons on the same (method, task,
+    # granularity, seed) tuple instead of collapsing them.
+    _H_RE = _re.compile(r"_h(\d+)_")
+
+    def _file_horizon(path: Path) -> int | None:
+        m = _H_RE.search(path.name)
+        if m is None:
+            return None
+        try:
+            return int(m.group(1))
+        except ValueError:
+            return None
+
+    # Allow-list filter: load the canonical 19-panel + FT-slot ids. Records
+    # whose method_id is outside this set are silently dropped here so they
+    # never reach dedupe, leaderboard, or coverage stages.
+    panel_ids, _ablation_ids = _panel_method_ids()
+
+    # First pass: gather ALL records (including non-ok) so dedupe can let
+    # newer rerun-failures supersede older partial-coverage "ok" records.
+    candidates: list[tuple[RunRecord, float, int | None]] = []
+    n_off_panel = 0
+    for p in paths:
+        try:
+            raw = json.loads(p.read_text())
+        except (OSError, json.JSONDecodeError) as exc:
+            logger.warning("Skipping unreadable JSON %s: %s", p, exc)
+            continue
+        if not isinstance(raw, list):
+            logger.warning("Skipping non-list JSON %s", p)
+            continue
+
+        migrated_raw: list[dict[str, Any]] = []
+        for rec in raw:
+            if isinstance(rec, dict) and rec.get("schema_version") != 2:
+                migrated_raw.append(_migrate_one(rec, p))
+                n_migrated += 1
+            else:
+                migrated_raw.append(rec)
+
+        try:
+            recs = adapter.validate_python(migrated_raw)
+        except pydantic.ValidationError as exc:
+            logger.warning("Skipping %s: validation failed: %s", p, exc)
+            continue
+
+        try:
+            mtime = p.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+
+        h = _file_horizon(p)
+        for r in recs:
+            if r.method_id not in panel_ids:
+                n_off_panel += 1
+                continue
+            candidates.append((r, mtime, h))
+
+    # Second pass: dedupe by latest (timestamp, mtime); newer wins.
+    # KEY INCLUDES ``ablation_setting`` AND ``horizon`` (parsed from
+    # filename for T1 multi-horizon cells) so the aggregator never collapses
+    # different horizons of the same (method, task, granularity, seed)
+    # tuple into one row.
+    best: dict[
+        tuple[str, str, str, int, str | None, int | None],
+        tuple[RunRecord, float, int | None],
+    ] = {}
+    for rec, mtime, h in candidates:
+        key = (rec.method_id, rec.task, rec.granularity, rec.seed,
+               rec.ablation_setting, h)
+        prev = best.get(key)
+        if prev is None:
+            best[key] = (rec, mtime, h)
+            continue
+        prev_rec, prev_mtime, _ = prev
+        if (rec.timestamp, mtime) > (prev_rec.timestamp, prev_mtime):
+            best[key] = (rec, mtime, h)
+    n_dedup_dropped = len(candidates) - len(best)
+
+    # Third + fourth passes: status + coverage gates.
+    out: list[tuple[RunRecord, int | None]] = []
+    n_skip = 0
+    n_partial = 0
+    for rec, _mtime, h in best.values():
+        if rec.status != "ok":
+            n_skip += 1
+            continue
+        m_dict = rec.metrics or {}
+        primary = _PRIMARY_METRIC_KEY.get(rec.task, "mse")
+        m = m_dict.get(primary)
+        val = m.value if m is not None else None
+        if val is None:
+            n_partial += 1
+            continue
+
+        # Partial-NaN gate
+        # NOTE: For T3/T6, a low success_rate (even 0) is a LEGITIMATE
+        # benchmark measurement: it means the method could not produce the
+        # canonical 11-field XBRL schema; eval-side fillna(0) -> APE 100%
+        # scores it as 100% MAPE per ``feedback_penalize_incomplete``. We
+        # only drop when ``success_rate`` is *missing entirely* (None),
+        # which signals a recording-side bug, not a real model failure.
+        if rec.task in ("T3", "T6"):
+            sr = m_dict.get("success_rate")
+            sr_v = sr.value if sr is not None else None
+            if sr_v is None:
+                n_partial += 1
+                continue
+        else:
+            # n_predictions or n_instances must equal canonical eval N.
+            expected = EVAL_N_PER_TASK.get(rec.task)  # type: ignore[arg-type]
+            np_metric = m_dict.get("n_predictions") or m_dict.get("n_instances")
+            np_v = np_metric.value if np_metric is not None else None
+            if expected is not None and np_v is not None and int(np_v) < int(expected):
+                n_partial += 1
+                continue
+        out.append((rec, h))
+    return out, n_skip, n_migrated, n_dedup_dropped, n_partial, n_off_panel
+
+
+def _records_to_long_df(
+    records: list[tuple[RunRecord, int | None]],
+) -> pd.DataFrame:
+    """Flatten records into a long-form DataFrame keyed by metric name.
+
+    Backfills ``method_family`` from the modal non-null value seen for each
+    ``method_id`` so stale re-eval bundles (which strip ``method_family``)
+    don't split a method into two leaderboard rows (e.g.,
+    ``random_forest (classical)`` and ``random_forest (unknown)``).
+    """
+    # Seed family map from the live Method registry — covers methods whose
+    # writers never tagged ``method_family`` in the RunRecord (closed LLMs
+    # gpt51/gpt_oss_120b/gemini3_flash, naive baselines historical_analogue/
+    # metro_median/sector_median, etc.).
+    family_by_method: dict[str, str] = {}
+    try:
+        # Import is deferred so the aggregator stays importable in
+        # environments without the methods/ tree (e.g. paper-only checkouts).
+        from projects.agent_builder.scripts.whatif_bench import methods  # noqa: F401
+        from projects.agent_builder.scripts.whatif_bench.methods._registry import ALL_METHODS
+        for _name, _cls in ALL_METHODS.items():
+            _fam = getattr(_cls, "family", None)
+            if _fam:
+                family_by_method[_name] = _fam
+    except Exception:
+        # Registry not importable in this environment — fall back to
+        # in-record backfill only.
+        pass
+    for r, _h in records:
+        fam = r.method_family
+        if fam and fam != "unknown" and r.method_id not in family_by_method:
+            family_by_method[r.method_id] = fam
+    rows: list[dict[str, Any]] = []
+    for r, h in records:
+        if r.metrics is None:
+            continue
+        fam = r.method_family
+        if fam in (None, "", "unknown"):
+            fam = family_by_method.get(r.method_id, "unknown")
+        family = fam
+        for metric_name, mv in r.metrics.items():
+            rows.append({
+                "task": r.task,
+                "method_id": r.method_id,
+                "method_family": family,
+                "granularity": r.granularity,
+                "seed": r.seed,
+                "ablation_setting": r.ablation_setting,
+                "horizon": h,
+                "metric_name": metric_name,
+                "value": mv.value,
+                "ci_lo": mv.ci_lo,
+                "ci_hi": mv.ci_hi,
+                "std": mv.std,
+                "n_boot": mv.n_boot,
+                "resample": mv.resample,
+            })
+    return pd.DataFrame(rows)
+
+
+def aggregate(
+    input_glob: str | None = None,
+    *,
+    output_path: Path | None = None,
+) -> dict[str, pd.DataFrame]:
+    """Aggregate every JSON matching ``input_glob`` into per-task DataFrames.
+
+    Parameters
+    ----------
+    input_glob
+        Glob (default: ``experiments/results/canon_*.json``).
+    output_path
+        Optional Parquet path; when supplied, writes the *long-form* table
+        (``[task, method_id, metric_name, value, ci_lo, ci_hi, n_boot, ...]``)
+        and the per-task split is reconstructable via groupby.
+    """
+    if input_glob is None:
+        # Results live under experiments/results/, NOT data_small_caps/.
+        # data_small_caps/ is the immutable raw-data tree; mixing experiment
+        # outputs into it pollutes the data layer.
+        input_glob = str(
+            Path(__file__).parent / "results" / "canon_*.json"
+        )
+
+    paths = [Path(p) for p in sorted(glob.glob(input_glob))]
+    if not paths:
+        logger.warning("No JSON matched glob %s", input_glob)
+
+    records, n_skipped, n_migrated, n_dedup, n_partial, n_off_panel = _load_records(paths)
+    logger.info(
+        "Loaded %d paper-valid records from %d files "
+        "(%d off-panel filtered, %d non-ok skipped, %d v1->v2 migrated, "
+        "%d duplicate cells deduped, %d tainted cells dropped)",
+        len(records), len(paths), n_off_panel, n_skipped, n_migrated, n_dedup,
+        n_partial,
+    )
+    if n_off_panel:
+        print(f"FOOTNOTE: {n_off_panel} record(s) had method_id outside "
+              "panel.ALL_METHODS and were filtered (e.g. stale gpt_oss_120b, gemma4).")
+    if n_skipped:
+        print(f"FOOTNOTE: {n_skipped} record(s) had status != 'ok' and were skipped.")
+    if n_migrated:
+        print(f"FOOTNOTE: {n_migrated} record(s) migrated from schema_version=1 to 2.")
+    if n_dedup:
+        print(f"FOOTNOTE: {n_dedup} duplicate (method, task, gran, seed) "
+              "cell(s) deduped — kept latest timestamp.")
+    if n_partial:
+        print(f"FOOTNOTE: {n_partial} cell(s) dropped because primary metric "
+              "value was None (silent-NaN tainted; need rerun).")
+
+    long_df = _records_to_long_df(records)
+    per_task: dict[str, pd.DataFrame] = {}
+    for task in _TASK_ORDER:
+        if long_df.empty:
+            per_task[task] = long_df.copy()
+            continue
+        sub = long_df[long_df["task"] == task].copy()
+        per_task[task] = (
+            sub.sort_values(["method_id", "metric_name"]).reset_index(drop=True)
+        )
+
+    if output_path is not None:
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        if output_path.suffix == ".parquet":
+            long_df.to_parquet(output_path, index=False)
+        else:
+            long_df.to_csv(output_path, index=False)
+        logger.info("Wrote aggregate %s (%d rows)", output_path, len(long_df))
+
+    return per_task
+
+
+def _print_leaderboard_for_cells(
+    df: pd.DataFrame,
+    *,
+    label: str,
+    eligible_methods: set[str],
+) -> None:
+    """Emit per-task leaderboard restricted to a single cell-set ``df``.
+
+    No groupby across heterogeneous cells; each method contributes exactly
+    one row (single seed). Missing-from-cell methods are listed below the
+    ranked block so coverage gaps are explicit.
+    """
+    print(f"\n=== {label} ===")
+    for task in _TASK_ORDER:
+        sub_task = df[df["task"] == task]
+        eligible_for_task = eligible_methods
+        if sub_task.empty:
+            present = set()
+        else:
+            present = set(sub_task["method_id"].unique())
+        missing = sorted(eligible_for_task - present)
+
+        primary = _PRIMARY_METRIC_KEY.get(task, "mse")
+        ascending = _PRIMARY_METRIC_LOWER_IS_BETTER.get(task, True)
+        ranked = sub_task[sub_task["metric_name"] == primary].dropna(
+            subset=["value"]
+        ).copy()
+        if ranked.empty:
+            print(f"\n[{task}] no valid records in this cell-set "
+                  f"({len(missing)} eligible methods missing).")
+            if missing:
+                print(f"  missing: {missing}")
+            continue
+        ranked = ranked.sort_values(
+            "value", ascending=ascending,
+        ).reset_index(drop=True)
+        print(f"\n[{task}] primary={primary} "
+              f"({'lower' if ascending else 'higher'}=better) — "
+              f"{len(ranked)}/{len(eligible_for_task)} methods present:")
+        for i, row in ranked.iterrows():
+            print(f"  {i+1:2d}. {row['method_id']:30s} "
+                  f"({row['method_family']:14s}) {row['value']:14.4f}")
+        if missing:
+            print(f"  ... missing this cell: {missing}")
+
+
+def print_summary(
+    per_task: dict[str, pd.DataFrame],
+    long_df: pd.DataFrame | None = None,
+) -> None:
+    """Three per-cell-set leaderboards: main panel / MH T1 / A-E ablation.
+
+    Each cell-set restricts both the records considered and the eligible
+    method allow-list, so rankings compare like-with-like.
+    """
+    from .panel import (
+        ALL_METHODS as _PANEL_METHODS,
+        methods_for_task_panel,
+    )
+    if long_df is None:
+        # Reconstruct from per-task. (Older callers passed only per_task.)
+        long_df = pd.concat(per_task.values(), ignore_index=True) if per_task else pd.DataFrame()
+    if long_df.empty:
+        print("\n(no records to summarise)")
+        return
+
+    panel_ids, ablation_ids = _panel_method_ids()
+
+    # Cell-set 1: MAIN PANEL — daily, horizon is None (= h=252 main), no ablation.
+    main_df = long_df[
+        (long_df["granularity"] == "daily")
+        & (long_df["horizon"].isna())
+        & (long_df["ablation_setting"].isna())
+        & (long_df["method_id"].isin(panel_ids))
+    ].copy()
+    # Eligible methods per task = panel methods whose ``tasks`` include task.
+    main_eligible_by_task = {
+        t: {m.id for m in methods_for_task_panel(t)}
+        for t in _TASK_ORDER
+    }
+    # Print task-by-task with task-specific eligibility.
+    print("\n=== MAIN PANEL (daily, h=252 default, no ablation) ===")
+    for task in _TASK_ORDER:
+        sub_task = main_df[main_df["task"] == task]
+        eligible = main_eligible_by_task[task]
+        present = set(sub_task["method_id"].unique()) if not sub_task.empty else set()
+        missing = sorted(eligible - present)
+        primary = _PRIMARY_METRIC_KEY.get(task, "mse")
+        ascending = _PRIMARY_METRIC_LOWER_IS_BETTER.get(task, True)
+        ranked = sub_task[sub_task["metric_name"] == primary].dropna(
+            subset=["value"]
+        ).copy()
+        if ranked.empty:
+            print(f"\n[{task}] no valid records "
+                  f"({len(missing)}/{len(eligible)} eligible methods missing).")
+            if missing:
+                print(f"  missing: {missing}")
+            continue
+        ranked = ranked.sort_values(
+            "value", ascending=ascending,
+        ).reset_index(drop=True)
+        print(f"\n[{task}] primary={primary} "
+              f"({'lower' if ascending else 'higher'}=better) — "
+              f"{len(ranked)}/{len(eligible)} methods present:")
+        for i, row in ranked.iterrows():
+            print(f"  {i+1:2d}. {row['method_id']:30s} "
+                  f"({row['method_family']:14s}) {row['value']:14.4f}")
+        if missing:
+            print(f"  ... missing: {missing}")
+
+    # Cell-set 2: MULTI-HORIZON T1 — one ranking per (granularity, horizon).
+    mh_df = long_df[
+        (long_df["task"] == "T1")
+        & (long_df["horizon"].notna())
+        & (long_df["ablation_setting"].isna())
+        & (long_df["method_id"].isin(panel_ids))
+    ].copy()
+    mh_eligible = main_eligible_by_task["T1"]  # T1-capable panel methods
+    if not mh_df.empty:
+        print("\n=== MULTI-HORIZON T1 (per (granularity, horizon)) ===")
+        grans_horizons = (
+            mh_df[["granularity", "horizon"]].drop_duplicates()
+            .sort_values(["granularity", "horizon"])
+            .itertuples(index=False, name=None)
+        )
+        for gran, h in grans_horizons:
+            h_int = int(h)
+            sub = mh_df[(mh_df["granularity"] == gran) & (mh_df["horizon"] == h)]
+            ranked = sub[sub["metric_name"] == "mse"].dropna(
+                subset=["value"]
+            ).copy()
+            present = set(sub["method_id"].unique())
+            missing = sorted(mh_eligible - present)
+            print(f"\n[T1] {gran}/h={h_int} — "
+                  f"{len(ranked)}/{len(mh_eligible)} methods present:")
+            ranked = ranked.sort_values("value").reset_index(drop=True)
+            for i, row in ranked.iterrows():
+                print(f"  {i+1:2d}. {row['method_id']:30s} "
+                      f"({row['method_family']:14s}) {row['value']:14.4f}")
+            if missing:
+                print(f"  ... missing: {missing}")
+
+    # Cell-set 3: A-E ABLATION — per (setting, task) for ablation_ids only.
+    abl_df = long_df[
+        (long_df["ablation_setting"].notna())
+        & (long_df["method_id"].isin(ablation_ids))
+    ].copy()
+    if not abl_df.empty:
+        print("\n=== A→E ABLATION (gpt51, gemini3_flash, lightgbm [+scout_ft when ready]) ===")
+        from .panel import ABLATION_TASKS, ABLATION_SETTINGS
+        for setting in sorted(ABLATION_SETTINGS.keys()):
+            for task in ABLATION_TASKS:
+                sub = abl_df[
+                    (abl_df["ablation_setting"] == setting)
+                    & (abl_df["task"] == task)
+                ]
+                if sub.empty:
+                    print(f"\n[{setting}/{task}] no records "
+                          f"(eligible: {sorted(ablation_ids)})")
+                    continue
+                primary = _PRIMARY_METRIC_KEY.get(task, "mse")
+                ascending = _PRIMARY_METRIC_LOWER_IS_BETTER.get(task, True)
+                ranked = sub[sub["metric_name"] == primary].dropna(
+                    subset=["value"]
+                ).copy()
+                if ranked.empty:
+                    print(f"\n[{setting}/{task}] no valid records for {primary}")
+                    continue
+                ranked = ranked.sort_values(
+                    "value", ascending=ascending,
+                ).reset_index(drop=True)
+                present = set(sub["method_id"].unique())
+                missing = sorted(ablation_ids - present)
+                print(f"\n[{setting}/{task}] primary={primary} — "
+                      f"{len(ranked)}/{len(ablation_ids)} methods:")
+                for i, row in ranked.iterrows():
+                    print(f"  {i+1:2d}. {row['method_id']:30s} "
+                          f"({row['method_family']:14s}) {row['value']:14.4f}")
+                if missing:
+                    print(f"  ... missing: {missing}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input", type=str, default=None,
+        help="Glob pointing to RunRecord JSON files "
+             "(default: experiments/results/*.json)",
+    )
+    parser.add_argument(
+        "--output", type=Path, default=None,
+        help="Optional aggregated table output (.parquet or .csv).",
+    )
+    parser.add_argument(
+        "--summary", action="store_true",
+        help="Print per-task method leaderboard sorted by the task's primary metric.",
+    )
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
+    per_task = aggregate(input_glob=args.input, output_path=args.output)
+    if args.summary:
+        print_summary(per_task)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    sys.exit(main())

code/experiments/analyses/__init__.py

@@ -0,0 +1 @@
+"""Post-hoc analyses for the MacroLens E&D track submission."""

code/experiments/analyses/post_hoc.py

@@ -0,0 +1,469 @@
+"""Post-hoc analyses + paper artifacts for MacroLens (NeurIPS 2026 E&D track).
+
+One pass over the reeval JSON + saved pkls produces every table + figure
+referenced by §6 and the appendix.
+
+Outputs (in --output-dir):
+  Main-text artifacts:
+    tab_t1_leaderboard.tex       -- T1 leaderboard
+    tab_t2_t5_gap.tex            -- T2 vs T5 valuation gap
+    fig_ablation_4panel.pdf      -- 4-panel ablation figure (4 tasks x 2 models x A-E)
+    fig_cross_task_corr.pdf      -- cross-task ranking heatmap
+    tab_cross_task_corr.tex      -- same as table
+  Evaluation-research tables:
+    tab_baseline_floor.tex       -- saturation: methods failing to beat naive
+    tab_failure_modes.tex        -- per-cell mode (ok/parser_fail/saturation/scale_blowup)
+  Appendix per-task tables:
+    tab_per_task_T1.tex .. tab_per_task_T7.tex
+  Stratifications:
+    stratify_T1_sector.csv       -- §App.C
+    stratify_T2_quartile.csv
+    stratify_T5_quartile.csv
+    stratify_T4_event_type.csv
+    stratify_T7_state.csv
+  Raw CSVs (backing every table):
+    panel_metrics.csv, ablation_metrics.csv, failure_modes.csv
+
+Usage:
+    python -m whatif_bench.experiments.analyses.post_hoc \\
+        --predictions-dir whatif_bench/experiments/predictions \\
+        --reeval whatif_bench/experiments/results/canon_reeval_<TS>.json \\
+        --output-dir whatif_bench/experiments/analyses_out
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import pickle
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PANEL = [
+    "persistence", "historical_analogue", "sector_median", "metro_median",
+    "lightgbm", "random_forest",
+    "dlinear", "itransformer", "moderntcn",
+    "chronos2", "moirai2", "timesfm",
+    "chattime", "time_mqa",
+    "gpt_oss_120b", "gpt51", "gemini3_flash", "qwen35",
+]
+NAIVE = {"persistence", "historical_analogue", "sector_median", "metro_median"}
+TASKS = ["T1", "T2", "T3", "T4", "T5", "T6", "T7"]
+ABL_TASKS = ["T1", "T2", "T4", "T5"]
+ABL_MODELS = ["gpt51", "gemini3_flash"]
+PRIMARY = {
+    "T1": "mse", "T2": "median_ape", "T3": "overall_mape",
+    "T4": "return_mae_pct", "T5": "median_ape", "T6": "overall_mape",
+    "T7": "rent_MAPE",
+}
+LABEL = {
+    "mse": "MSE", "median_ape": "medAPE\\%", "overall_mape": "MAPE\\%",
+    "return_mae_pct": "MAE\\%", "rent_MAPE": "MAPE\\%",
+}
+SETTINGS = ["A", "B", "C", "D", "E"]
+
+
+# ── data loading ──────────────────────────────────────────────────────────
+
+def load_metrics(reeval_path: Path) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Return (panel_df, abl_df) with primary metric per row."""
+    recs = json.loads(reeval_path.read_text())
+    if isinstance(recs, dict):
+        recs = recs.get("records", recs)
+    rows = []
+    for r in recs:
+        if r.get("status") != "ok":
+            continue
+        m, t = r.get("method_id"), r.get("task")
+        if m not in PANEL or t not in TASKS:
+            continue
+        key = PRIMARY[t]
+        v = (r.get("metrics") or {}).get(key, {}).get("value")
+        if v is None:
+            continue
+        rows.append({
+            "method": m, "task": t,
+            "setting": r.get("ablation_setting") or "",
+            "metric_key": key, "value": float(v),
+        })
+    df = pd.DataFrame(rows)
+    panel = df[df["setting"] == ""].drop(columns=["setting"]).copy()
+    abl = df[df["setting"] != ""].copy()
+    return panel, abl
+
+
+def load_pkls(pred_dir: Path) -> list[dict]:
+    out = []
+    for p in sorted(pred_dir.glob("*.pkl")):
+        try:
+            with p.open("rb") as f:
+                d = pickle.load(f)
+            out.append(d)
+        except Exception:
+            continue
+    return out
+
+
+# ── analyses (each returns a DataFrame) ───────────────────────────────────
+
+def cross_task_correlation(panel: pd.DataFrame) -> pd.DataFrame:
+    from scipy.stats import spearmanr
+    pv = panel.pivot(index="method", columns="task", values="value")
+    rho = pd.DataFrame(index=TASKS, columns=TASKS, dtype=float)
+    for ta in TASKS:
+        for tb in TASKS:
+            common = pv[[ta, tb]].dropna() if ta in pv.columns and tb in pv.columns else pd.DataFrame()
+            if len(common) >= 4 and ta != tb:
+                rho.loc[ta, tb] = spearmanr(common[ta], common[tb])[0]
+            elif ta == tb:
+                rho.loc[ta, tb] = 1.0
+    return rho
+
+
+def baseline_floor(panel: pd.DataFrame) -> pd.DataFrame:
+    """Per-task: naive floor + count of methods beating / failing it."""
+    rows = []
+    for t in TASKS:
+        sub = panel[panel["task"] == t]
+        floor = sub[sub["method"].isin(NAIVE)]["value"].min()
+        if pd.isna(floor):
+            continue
+        non_naive = sub[~sub["method"].isin(NAIVE)]
+        beat = (non_naive["value"] < floor * 0.99).sum()
+        fail = (~(non_naive["value"] < floor * 0.99)).sum()
+        rows.append({"task": t, "naive_floor": floor,
+                     "n_beat": int(beat), "n_fail": int(fail)})
+    return pd.DataFrame(rows)
+
+
+def t2_t5_gap(panel: pd.DataFrame) -> pd.DataFrame:
+    from scipy.stats import spearmanr
+    pv = panel.pivot(index="method", columns="task", values="value")
+    common = pv[["T2", "T5"]].dropna()
+    common = common.assign(
+        delta=common["T5"] - common["T2"],
+        T2_rank=common["T2"].rank().astype(int),
+        T5_rank=common["T5"].rank().astype(int),
+    ).sort_values("T2").reset_index()
+    rho = spearmanr(common["T2"], common["T5"])[0] if len(common) >= 3 else float("nan")
+    common.attrs["spearman_rho"] = rho
+    common.attrs["mean_delta"] = common["delta"].mean()
+    return common
+
+
+def classify_mode(d: dict) -> str:
+    yp = d.get("y_pred")
+    if yp is None:
+        return "no_pkl"
+    if hasattr(yp, "columns"):
+        col = next((c for c in ("pred", "value", "predicted_equity_value",
+                                "predicted_return_pct", "pred_rent", "pred_price")
+                    if c in yp.columns), None)
+        vals = pd.to_numeric(yp[col], errors="coerce").to_numpy() if col else np.array([])
+    else:
+        vals = np.asarray(yp, dtype=np.float64).ravel()
+    if vals.size == 0:
+        return "no_pkl"
+    finite = vals[np.isfinite(vals)]
+    if finite.size / vals.size < 0.5:
+        return "parser_fail"
+    if finite.size and np.max(np.abs(finite)) > 1e8:
+        return "scale_blowup"
+    if finite.size and np.std(finite) < 1e-3:
+        return "saturation"
+    return "ok"
+
+
+def failure_modes(pkls: list[dict]) -> pd.DataFrame:
+    rows = []
+    for d in pkls:
+        m, t = d.get("method_id"), d.get("task")
+        s = d.get("ablation_setting") or ""
+        if m in PANEL and t in TASKS and not s:
+            rows.append({"method": m, "task": t, "mode": classify_mode(d)})
+    return pd.DataFrame(rows)
+
+
+def stratify(pkls: list[dict], task: str, key_col: str, metric: str) -> pd.DataFrame:
+    """Per-(method, stratum) primary metric for one task."""
+    rows = []
+    for d in pkls:
+        if d.get("task") != task or d.get("method_id") not in PANEL:
+            continue
+        if (d.get("ablation_setting") or ""):
+            continue
+        meta, yt, yp = d.get("meta_test"), d.get("y_test"), d.get("y_pred")
+        if meta is None or key_col not in meta.columns:
+            continue
+        m = d["method_id"]
+        if metric == "mse":  # T1 trajectory
+            yt_a = np.asarray(yt, dtype=np.float64)
+            yp_a = np.asarray(yp, dtype=np.float64).copy()
+            if yt_a.ndim == 1: yt_a = yt_a.reshape(-1, 1)
+            if yp_a.ndim == 1: yp_a = yp_a.reshape(-1, 1)
+            yp_a[~np.isfinite(yp_a).all(axis=1)] = 0.0
+            n = min(len(meta), len(yp_a))
+            per_inst = ((yp_a[:n] - yt_a[:n]) ** 2).mean(axis=1)
+            df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n],
+                               "v": per_inst})
+            agg = df.groupby(key_col)["v"].mean()
+        elif metric == "median_ape":  # T2 / T5
+            yt_a = np.asarray(yt, dtype=np.float64).ravel()
+            yp_a = np.where(np.isfinite(np.asarray(yp, dtype=np.float64).ravel()),
+                            np.asarray(yp, dtype=np.float64).ravel(), 0.0)
+            n = min(len(meta), len(yt_a), len(yp_a))
+            keep = np.isfinite(yt_a[:n]) & (np.abs(yt_a[:n]) >= 1.0)
+            ape = np.minimum(np.abs(yp_a[:n][keep] - yt_a[:n][keep]) / np.abs(yt_a[:n][keep]),
+                             10.0) * 100.0
+            df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n][keep],
+                               "v": ape})
+            agg = df.groupby(key_col)["v"].median()
+        elif metric == "return_mae_pct":  # T4
+            if hasattr(yp, "columns"):
+                yp_a = pd.to_numeric(yp.iloc[:, -1], errors="coerce").to_numpy()
+            else:
+                yp_a = np.asarray(yp, dtype=np.float64).ravel()
+            yt_a = np.asarray(yt, dtype=np.float64).ravel()
+            yp_a = np.where(np.isfinite(yp_a), yp_a, 0.0)
+            n = min(len(meta), len(yt_a), len(yp_a))
+            df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n],
+                               "v": np.abs(yt_a[:n] - yp_a[:n])})
+            agg = df.groupby(key_col)["v"].mean()
+        else:
+            continue
+        for k, v in agg.items():
+            rows.append({"method": m, key_col: k, "value": float(v)})
+    return pd.DataFrame(rows)
+
+
+# ── renderers ─────────────────────────────────────────────────────────────
+
+def fmt(v) -> str:
+    if pd.isna(v):
+        return "--"
+    if isinstance(v, str):
+        return v
+    if abs(v) >= 1e6: return f"{v:.2e}"
+    if abs(v) >= 100: return f"{v:.0f}"
+    if abs(v) >= 1:   return f"{v:.2f}"
+    return f"{v:.4f}"
+
+
+def tex_safe(s: str) -> str:
+    return str(s).replace("_", r"\_")
+
+
+def latex_table(df: pd.DataFrame, caption: str, label: str,
+                escape: bool = False) -> str:
+    """Wrap pd.to_latex with NeurIPS-friendly defaults."""
+    body = df.to_latex(
+        index=False, escape=escape, na_rep="--",
+        column_format="l" + "c" * (len(df.columns) - 1),
+    )
+    # Strip outer environment, wrap in table+caption.
+    return (
+        "\\begin{table}[h]\n\\centering\n"
+        f"\\caption{{{caption}}}\n\\label{{{label}}}\n\\small\n"
+        + body.replace("\\begin{tabular}", "\\begin{tabular}").rstrip()
+        + "\n\\end{table}\n"
+    )
+
+
+def render_t1_leaderboard(panel: pd.DataFrame, out: Path) -> None:
+    family_map = {
+        "persistence": "Naive", "historical_analogue": "Naive",
+        "sector_median": "Naive", "metro_median": "Naive",
+        "lightgbm": "Classical", "random_forest": "Classical",
+        "dlinear": "Sequence", "itransformer": "Sequence", "moderntcn": "Sequence",
+        "chronos2": "TSFM", "moirai2": "TSFM", "timesfm": "TSFM",
+        "chattime": "TS-LLM", "time_mqa": "TS-LLM",
+        "gpt_oss_120b": "LLM-ZS", "gpt51": "LLM-ZS",
+        "gemini3_flash": "LLM-ZS", "qwen35": "LLM-ZS",
+    }
+    t1 = panel[panel["task"] == "T1"].copy()
+    t1["family"] = t1["method"].map(family_map)
+    t1["method"] = t1["method"].map(tex_safe)
+    t1["mse"] = t1["value"].map(fmt)
+    t1 = t1[["family", "method", "mse"]]
+    t1.columns = ["Family", "Method", "MSE"]
+    out.write_text(latex_table(
+        t1, caption="T1 contextual time-series forecasting (close-trajectory MSE, "
+                    "single seed with cluster-bootstrap 95\\% CIs in App.~A).",
+        label="tab:t1",
+    ))
+
+
+def render_t2_t5_gap(gap: pd.DataFrame, out: Path) -> None:
+    df = gap[["method", "T2", "T5", "delta", "T2_rank", "T5_rank"]].copy()
+    df["method"] = df["method"].map(tex_safe)
+    for c in ("T2", "T5", "delta"):
+        df[c] = df[c].map(fmt)
+    df.columns = ["Method", "T2 medAPE", "T5 medAPE", "$\\Delta$(T5--T2)",
+                  "rank T2", "rank T5"]
+    rho = gap.attrs.get("spearman_rho")
+    md = gap.attrs.get("mean_delta")
+    out.write_text(latex_table(
+        df,
+        caption=(
+            "T2 vs T5 valuation gap. $\\Delta$ is medAPE delta when "
+            "market-price features are removed (T5). "
+            f"Spearman $\\rho$(T2 ranking, T5 ranking) $= {rho:.3f}$; "
+            f"mean $\\Delta = {md:+.2f}$ medAPE pts."
+        ),
+        label="tab:t2-t5-gap",
+    ))
+
+
+def render_correlation(rho: pd.DataFrame, out_tex: Path, out_pdf: Path) -> None:
+    df = rho.round(2).copy()
+    df.insert(0, "", df.index)
+    out_tex.write_text(latex_table(
+        df, caption="Cross-task ranking correlation (Spearman $\\rho$). "
+                    "Negative cells (boxed) are the multi-task non-redundancy "
+                    "evidence: methods that win T1 lose T3 and T6.",
+        label="tab:cross-task-corr",
+    ))
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    fig, ax = plt.subplots(figsize=(5.5, 4.5))
+    arr = rho.to_numpy(dtype=float)
+    im = ax.imshow(arr, cmap="RdBu_r", vmin=-1.0, vmax=1.0, aspect="equal")
+    ax.set_xticks(range(len(TASKS))); ax.set_xticklabels(TASKS)
+    ax.set_yticks(range(len(TASKS))); ax.set_yticklabels(TASKS)
+    for i in range(len(TASKS)):
+        for j in range(len(TASKS)):
+            v = arr[i, j]
+            if not np.isnan(v):
+                ax.text(j, i, f"{v:.2f}", ha="center", va="center",
+                        color="white" if abs(v) > 0.5 else "black", fontsize=9)
+    fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+    fig.tight_layout()
+    fig.savefig(out_pdf, bbox_inches="tight")
+    plt.close(fig)
+
+
+def render_baseline_floor(bf: pd.DataFrame, out: Path) -> None:
+    df = bf.copy()
+    df["naive_floor"] = df["naive_floor"].map(fmt)
+    df.columns = ["Task", "Naive floor", "\\# beating", "\\# failing"]
+    out.write_text(latex_table(
+        df, caption="Saturation analysis: per-task best-naive baseline value "
+                    "and counts of non-naive methods beating / failing it.",
+        label="tab:baseline-floor",
+    ))
+
+
+def render_failure_modes(fm: pd.DataFrame, out: Path) -> None:
+    pv = fm.pivot(index="method", columns="task", values="mode")
+    pv = pv.reindex(index=PANEL, columns=TASKS)
+    pv = pv.reset_index()
+    pv["method"] = pv["method"].map(tex_safe)
+    pv.columns = ["Method"] + TASKS
+    out.write_text(latex_table(
+        pv,
+        caption="Per-cell failure-mode taxonomy. ok = reasonable predictions; "
+                "parser\\_fail = $>$50\\% NaN after parser; "
+                "saturation = constant predictions near zero; "
+                "scale\\_blowup = parser-induced extreme values.",
+        label="tab:failure-modes",
+    ))
+
+
+def render_per_task_table(panel: pd.DataFrame, task: str, out: Path) -> None:
+    df = panel[panel["task"] == task].sort_values("value")[["method", "value"]].copy()
+    df["method"] = df["method"].map(tex_safe)
+    df["value"] = df["value"].map(fmt)
+    metric_label = LABEL.get(PRIMARY[task], PRIMARY[task])
+    df.columns = ["Method", metric_label]
+    out.write_text(latex_table(
+        df, caption=f"{task} per-method primary metric ({metric_label}).",
+        label=f"tab:per-task-{task}",
+    ))
+
+
+def render_ablation_4panel(abl: pd.DataFrame, out: Path) -> None:
+    """4 panels (T1, T2, T4, T5); two lines per panel (gpt51, gemini3_flash)."""
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    fig, axes = plt.subplots(1, 4, figsize=(13, 3.0))
+    colors = {"gpt51": "#1f77b4", "gemini3_flash": "#d62728"}
+    nice = {"gpt51": "GPT-5.1", "gemini3_flash": "Gemini-3-Flash"}
+    for ax, t in zip(axes, ABL_TASKS):
+        for m in ABL_MODELS:
+            sub = abl[(abl["method"] == m) & (abl["task"] == t)]
+            sub = sub.set_index("setting").reindex(SETTINGS)["value"]
+            ax.plot(SETTINGS, sub.values, marker="o", color=colors[m],
+                    label=nice[m], linewidth=1.6, markersize=5)
+        ax.set_title(f"{t} ({LABEL[PRIMARY[t]].replace(chr(92)+'%', '%')})", fontsize=10)
+        ax.set_xlabel("Context setting (A→E)", fontsize=9)
+        ax.tick_params(axis="both", labelsize=8)
+        ax.grid(True, alpha=0.3, linewidth=0.4)
+        if t == "T1":
+            ax.set_yscale("log")
+            ax.set_ylabel("MSE (log)", fontsize=9)
+        else:
+            ax.set_ylabel(LABEL[PRIMARY[t]].replace("\\%", "%"), fontsize=9)
+    axes[0].legend(loc="best", fontsize=8, frameon=True)
+    fig.tight_layout()
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+
+
+# ── main ─────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument("--predictions-dir", required=True, type=Path)
+    p.add_argument("--reeval", required=True, type=Path)
+    p.add_argument("--output-dir", required=True, type=Path)
+    args = p.parse_args()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    O = args.output_dir
+
+    panel, abl = load_metrics(args.reeval)
+    pkls = load_pkls(args.predictions_dir)
+
+    panel.to_csv(O / "panel_metrics.csv", index=False)
+    abl.to_csv(O / "ablation_metrics.csv", index=False)
+
+    # Main-text artifacts
+    render_t1_leaderboard(panel, O / "tab_t1_leaderboard.tex")
+    gap = t2_t5_gap(panel); gap.to_csv(O / "t2_t5_gap.csv", index=False)
+    render_t2_t5_gap(gap, O / "tab_t2_t5_gap.tex")
+    rho = cross_task_correlation(panel); rho.to_csv(O / "cross_task_correlation.csv")
+    render_correlation(rho, O / "tab_cross_task_corr.tex", O / "fig_cross_task_corr.pdf")
+    render_ablation_4panel(abl, O / "fig_ablation_4panel.pdf")
+
+    # Evaluation-research tables
+    bf = baseline_floor(panel); bf.to_csv(O / "baseline_floor.csv", index=False)
+    render_baseline_floor(bf, O / "tab_baseline_floor.tex")
+    fm = failure_modes(pkls); fm.to_csv(O / "failure_modes.csv", index=False)
+    render_failure_modes(fm, O / "tab_failure_modes.tex")
+
+    # Per-task headline tables (appendix)
+    for t in TASKS:
+        render_per_task_table(panel, t, O / f"tab_per_task_{t}.tex")
+
+    # Stratifications (T7 omitted: two-output rent/price doesn't fit the
+    # single-metric stratify shape; appendix table is rendered direct from pkl).
+    # T2/T5 stratify by market-cap quartile (mcap_q) per the draft
+    # protocol; T1 by GICS sector; T4 by scenario event_type.
+    for task, key, metric, name in [
+        ("T1", "sector",     "mse",            "T1_sector"),
+        ("T2", "mcap_q",     "median_ape",     "T2_mcap_q"),
+        ("T5", "mcap_q",     "median_ape",     "T5_mcap_q"),
+        ("T4", "event_type", "return_mae_pct", "T4_event_type"),
+    ]:
+        s = stratify(pkls, task, key, metric)
+        if not s.empty:
+            s.to_csv(O / f"stratify_{name}.csv", index=False)
+
+    print(f"\nOK — wrote {len(list(O.iterdir()))} artifacts to {O}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/analysis.py

@@ -0,0 +1,356 @@
+"""Post-hoc analysis scripts for MacroLens paper §4.4.
+
+Generates:
+1. Per-category ScenRet breakdown (Table in appendix)
+2. Cross-sectional heterogeneity (by sector, market-cap quartile, filing density)
+3. Cross-frequency robustness summary
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from .. import config
+
+logger = logging.getLogger(__name__)
+
+
+# ── Per-Category ScenRet Breakdown ──────────────────────────────────────
+
+def scenret_per_category(
+    granularity: str = "daily",
+) -> dict[str, Any]:
+    """Stratify ScenRet ground truth by scenario category.
+
+    Computes per-category statistics: mean return, std, count,
+    and the baseline (cross-ticker mean) MAE per category.
+    """
+    bench_dir = config.get_benchmark_dir(granularity)
+    gt_path = bench_dir / "scenario_forecast_ground_truth.parquet"
+
+    if not gt_path.exists():
+        return {"error": "scenario_forecast_ground_truth.parquet not found"}
+
+    gt = pd.read_parquet(gt_path)
+    gt = gt.dropna(subset=["actual_return_pct"])
+
+    if "event_type" not in gt.columns:
+        return {"error": "No event_type column"}
+
+    # Map event_type to category
+    category_map = _build_category_map()
+    gt["category"] = gt["event_type"].map(
+        lambda et: category_map.get(et, "other")
+    )
+
+    # Per-category stats
+    categories = {}
+    for cat, group in gt.groupby("category"):
+        returns = group["actual_return_pct"]
+        # Cross-ticker mean baseline MAE
+        scenario_means = group.groupby("scenario_id")["actual_return_pct"].transform("mean")
+        baseline_mae = float(np.mean(np.abs(returns - scenario_means)))
+
+        categories[cat] = {
+            "n_instances": len(group),
+            "n_scenarios": group["scenario_id"].nunique(),
+            "mean_return_pct": round(float(returns.mean()), 3),
+            "std_return_pct": round(float(returns.std()), 3),
+            "median_return_pct": round(float(returns.median()), 3),
+            "baseline_mae_pct": round(baseline_mae, 3),
+            "pct_positive": round(float((returns > 0).mean()), 3),
+        }
+
+    # Overall
+    overall_returns = gt["actual_return_pct"]
+    scenario_means_all = gt.groupby("scenario_id")["actual_return_pct"].transform("mean")
+    overall_baseline_mae = float(np.mean(np.abs(overall_returns - scenario_means_all)))
+
+    result = {
+        "granularity": granularity,
+        "total_instances": len(gt),
+        "total_scenarios": gt["scenario_id"].nunique(),
+        "overall_baseline_mae_pct": round(overall_baseline_mae, 3),
+        "per_category": categories,
+    }
+
+    logger.info("ScenRet per-category: %d categories, %d total instances",
+                len(categories), len(gt))
+    return result
+
+
+def _build_category_map() -> dict[str, str]:
+    """Map event_type -> high-level category.
+
+    Event-type strings come from `generate_scenarios.py`'s detector functions.
+    Whenever a detector is added or renamed there, update this map and the
+    `tests/test_scenario_categories.py` coverage assertion.
+    """
+    mapping = {}
+    rates = [
+        "fed_rate_change", "sofr_shock", "treasury_move",
+        "treasury_acute_shock",                     # short-window 10Y move
+        "long_bond_shock",                          # DGS30
+        "yield_curve_event",                        # 10Y-2Y inversion
+        "yield_curve_3m10y_inversion",
+        "yield_curve_3m10y_uninversion",
+        "mortgage_rate_shock",
+        "real_yield_shift", "term_premium_change",
+    ]
+    equity = [
+        "sp500_drawdown", "sp500_acute_shock",      # short-window crash
+        "nasdaq_move", "nasdaq_acute_shock",
+        "djia_move",
+        "vix_spike", "volatility_regime",
+        "sector_rotation",                          # SP500 vs NASDAQ divergence
+        "market_drawdown",
+    ]
+    commodities = [
+        "oil_shock", "oil_acute_shock",
+        "wti_oil_shock", "henry_hub_shock",
+        "natgas_shock",
+    ]
+    fx = ["fx_shock", "usd_shock"]
+    inflation = [
+        "inflation_shock", "ppi_shock", "pce_inflation_shock",
+        "breakeven_inflation_shock",
+    ]
+    labor = [
+        "unemployment_shock", "payroll_shock", "jolts_shock",
+        "earnings_shock",
+    ]
+    credit = [
+        "hy_spread_event", "ig_spread_event", "credit_compression",
+        "ted_spread_spike",
+    ]
+    housing = [
+        "housing_starts_shock", "home_price_event",
+        "building_permit_shock", "existing_home_sales_shock",
+    ]
+    money = [
+        "m2_contraction", "m2_surge",                # split from m2_shock
+        "monetary_base_shock", "fed_balance_sheet",
+        "business_loans_shock",
+        "nfci_event",                                # Chicago Fed NFCI
+    ]
+
+    for et in rates:        mapping[et] = "rates"
+    for et in equity:       mapping[et] = "equity"
+    for et in commodities:  mapping[et] = "commodities"
+    for et in fx:           mapping[et] = "fx"
+    for et in inflation:    mapping[et] = "inflation"
+    for et in labor:        mapping[et] = "labor"
+    for et in credit:       mapping[et] = "credit"
+    for et in housing:      mapping[et] = "housing"
+    for et in money:        mapping[et] = "money_supply"
+    return mapping
+
+
+# ── Cross-Sectional Heterogeneity ───────────────────────────────────────
+
+def cross_sectional_analysis(
+    granularity: str = "daily",
+) -> dict[str, Any]:
+    """Stratify TSF and ScenRet by sector, market-cap quartile, filing density."""
+    bench_dir = config.get_benchmark_dir(granularity)
+    test_path = bench_dir / "panel_test.parquet"
+    gt_path = bench_dir / "scenario_forecast_ground_truth.parquet"
+
+    if not test_path.exists():
+        return {"error": "panel_test.parquet not found"}
+
+    panel = pd.read_parquet(test_path)
+    result: dict[str, Any] = {"granularity": granularity}
+
+    # ── By Sector ──
+    if "sector" in panel.columns and "close" in panel.columns:
+        # Compute per-ticker daily returns first, THEN aggregate by sector,
+        # so we don't take pct_change across ticker boundaries (which would
+        # produce a spurious return at every (ticker_a, ticker_b) seam).
+        panel_sorted = panel.sort_values(["ticker", "date"])
+        per_ticker_ret = panel_sorted.groupby("ticker", sort=False)["close"].pct_change()
+        panel_sorted["_ret"] = per_ticker_ret
+
+        sector_stats = {}
+        for sector, grp in panel_sorted.groupby("sector"):
+            close = grp["close"].dropna()
+            if len(close) < 10:
+                continue
+            returns = grp["_ret"].dropna()
+            sector_stats[sector] = {
+                "n_rows": len(grp),
+                "n_tickers": grp["ticker"].nunique(),
+                "mean_close": round(float(close.mean()), 2),
+                "volatility": round(float(returns.std()), 4),
+                "mean_return": round(float(returns.mean()), 6),
+            }
+        result["by_sector"] = sector_stats
+
+    # ── By Market-Cap Quartile ──
+    if "derived_market_cap" in panel.columns:
+        latest = panel.sort_values("date").groupby("ticker").last()
+        # `duplicates="drop"` keeps qcut robust to small / degenerate
+        # market-cap distributions (e.g., synthetic fixtures or tiny
+        # universes where many tickers share the same derived_market_cap
+        # round number). On the real R2K + S&P 600 universe it has no
+        # effect because the bin edges are dense.
+        try:
+            latest["mcap_quartile"] = pd.qcut(
+                latest["derived_market_cap"].clip(lower=1),
+                4, labels=["Q1_small", "Q2", "Q3", "Q4_large"],
+                duplicates="drop",
+            )
+        except ValueError as e:
+            logger.warning("mcap qcut failed (%s); skipping by_mcap_quartile", e)
+            latest["mcap_quartile"] = pd.NA
+        ticker_quartile = latest["mcap_quartile"].to_dict()
+        # Compute returns per-ticker BEFORE assigning quartile labels, otherwise
+        # pct_change() taken inside `groupby(mcap_quartile)` would compute a
+        # return at every cross-ticker seam.
+        panel_sorted = panel.sort_values(["ticker", "date"]).copy()
+        panel_sorted["_ret"] = panel_sorted.groupby("ticker", sort=False)["close"].pct_change()
+        panel_sorted["mcap_quartile"] = panel_sorted["ticker"].map(ticker_quartile)
+
+        mcap_stats = {}
+        for q, grp in panel_sorted.groupby("mcap_quartile"):
+            returns = grp["_ret"].dropna()
+            mcap_stats[str(q)] = {
+                "n_tickers": grp["ticker"].nunique(),
+                "mean_mcap": round(float(grp["derived_market_cap"].mean()), 0),
+                "volatility": round(float(returns.std()), 4),
+            }
+        result["by_mcap_quartile"] = mcap_stats
+
+    # ── By Filing Density ──
+    corpus_path = bench_dir / "filing_corpus.parquet"
+    if corpus_path.exists():
+        corpus = pd.read_parquet(corpus_path)
+        filings_per_ticker = corpus.groupby("ticker").size()
+        ticker_filing_density = filings_per_ticker.to_dict()
+
+        # Split into terciles
+        all_tickers = panel["ticker"].unique()
+        densities = pd.Series({
+            t: ticker_filing_density.get(t, 0) for t in all_tickers
+        })
+        terciles = pd.qcut(densities.clip(lower=0), 3,
+                           labels=["low_filing", "mid_filing", "high_filing"],
+                           duplicates="drop")
+
+        # As above: take pct_change PER ticker first, then aggregate by tercile,
+        # so we don't mix returns across ticker boundaries.
+        panel_sorted_fd = panel.sort_values(["ticker", "date"]).copy()
+        panel_sorted_fd["_ret"] = panel_sorted_fd.groupby("ticker", sort=False)["close"].pct_change()
+
+        filing_stats = {}
+        for t_label in terciles.unique():
+            tickers_in = set(terciles[terciles == t_label].index)
+            grp = panel_sorted_fd[panel_sorted_fd["ticker"].isin(tickers_in)]
+            returns = grp["_ret"].dropna()
+            filing_stats[str(t_label)] = {
+                "n_tickers": len(tickers_in),
+                "mean_filings": round(float(densities[terciles == t_label].mean()), 1),
+                "volatility": round(float(returns.std()), 4),
+            }
+        result["by_filing_density"] = filing_stats
+
+    # ── ScenRet by sector ──
+    if gt_path.exists():
+        gt = pd.read_parquet(gt_path).dropna(subset=["actual_return_pct"])
+        # Get ticker→sector from panel
+        ticker_sector = panel.drop_duplicates("ticker").set_index("ticker")["sector"].to_dict()
+        gt["sector"] = gt["ticker"].map(ticker_sector)
+
+        scenret_by_sector = {}
+        for sector, grp in gt.groupby("sector"):
+            if pd.isna(sector):
+                continue
+            returns = grp["actual_return_pct"]
+            scenret_by_sector[sector] = {
+                "n_instances": len(grp),
+                "mean_return_pct": round(float(returns.mean()), 3),
+                "std_return_pct": round(float(returns.std()), 3),
+            }
+        result["scenret_by_sector"] = scenret_by_sector
+
+    return result
+
+
+# ── Cross-Frequency Summary ─────────────────────────────────────────────
+
+def cross_frequency_summary() -> dict[str, Any]:
+    """Collect best baseline results across daily/weekly/monthly."""
+    result: dict[str, Any] = {}
+
+    legacy_dir = Path(__file__).resolve().parent / "results" / "legacy_per_family"
+    for gran in ["daily", "weekly", "monthly"]:
+        # ``all_results.json`` is the legacy per-family aggregate. It used
+        # to live under ``data_small_caps/benchmark/<g>/`` but moved to
+        # ``experiments/results/legacy_per_family/`` once experiment
+        # outputs were separated from the benchmark tree. The new
+        # canonical aggregate is ``experiments/paper_artifacts/aggregate.parquet``.
+        full_path = legacy_dir / "all_results.json"
+        quick_path = legacy_dir / "all_results_quick.json"
+        path = full_path if full_path.exists() else quick_path
+        if not path.exists():
+            result[gran] = {"status": "no_results"}
+            continue
+
+        data = json.loads(path.read_text())
+        summary: dict[str, Any] = {"status": "available"}
+
+        # Extract best TSF MAE across models
+        best_tsf_mae = {}
+        for key, val in data.items():
+            if isinstance(val, dict):
+                for sub_key, sub_val in val.items():
+                    if isinstance(sub_val, dict) and "overall" in sub_val:
+                        overall = sub_val["overall"]
+                        if "mae" in overall:
+                            h = sub_val.get("horizon", sub_key)
+                            if h not in best_tsf_mae or overall["mae"] < best_tsf_mae[h]["mae"]:
+                                best_tsf_mae[h] = {
+                                    "model": sub_key,
+                                    "mae": overall["mae"],
+                                    "da": overall.get("directional_accuracy", 0),
+                                }
+
+        summary["best_tsf"] = best_tsf_mae
+        result[gran] = summary
+
+    return result
+
+
+# ── Main ────────────────────────────────────────────────────────────────
+
+def run_all_analyses(granularity: str = "daily") -> dict[str, Any]:
+    """Run all §4.4 analyses and save results."""
+    results: dict[str, Any] = {}
+
+    logger.info("Running per-category ScenRet analysis...")
+    results["scenret_per_category"] = scenret_per_category(granularity)
+
+    logger.info("Running cross-sectional analysis...")
+    results["cross_sectional"] = cross_sectional_analysis(granularity)
+
+    logger.info("Running cross-frequency summary...")
+    results["cross_frequency"] = cross_frequency_summary()
+
+    # Save
+    out_dir = config.get_benchmark_dir(granularity)
+    out_path = out_dir / "analysis_results.json"
+    out_path.write_text(json.dumps(results, indent=2, default=str))
+    logger.info("Analysis saved to %s", out_path)
+
+    return results
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
+    run_all_analyses()

code/experiments/build_paper_artifacts.py

@@ -0,0 +1,236 @@
+"""One-shot paper-artifact builder for the MacroLens NeurIPS 2026 D&B paper.
+
+After every method has finished running and ``experiments/results/`` is
+populated with ``RunRecord`` JSONs, this script bundles every downstream
+artefact the paper consumes:
+
+* **Aggregation** -- ``aggregate_results.aggregate(...)`` writes a long-form
+  parquet to ``paper_artifacts/aggregate.parquet``.
+* **Tables**      -- ``gen_tables.gen_tab_*`` writes 8 ``tab_<name>.tex``
+  files into ``paper_artifacts/tables/``. Both the legacy nested-dict
+  ``all_results[_quick].json`` (when present) and the new RunRecord glob are
+  searched; whichever is available is used.
+* **Figures**     -- ``gen_figures.render_all`` writes 5 ``fig_<name>.pdf``
+  + ``fig_<name>.png`` pairs into ``paper_artifacts/figures/``.
+* **Analysis**    -- ``analysis.run_all_analyses`` writes an
+  ``analysis_results.json`` into the benchmark dir AND copies it to
+  ``paper_artifacts/analysis/``.
+
+CLI::
+
+    python -m projects.agent_builder.scripts.whatif_bench.experiments.build_paper_artifacts \\
+        --results-glob 'experiments/results/canon_*.json' \\
+        --granularity   daily
+
+Output tree (experiments/paper_artifacts/ -- experiment artifacts, NOT
+under data_small_caps/, which is reserved for raw + derived data)::
+
+    experiments/paper_artifacts/
+        aggregate.parquet
+        leaderboard.txt          (per-task primary-metric leaderboard)
+        tables/   tab_*.tex
+        figures/  fig_*.pdf, fig_*.png
+        analysis/ analysis_results.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import logging
+import shutil
+from pathlib import Path
+from typing import Any
+
+from .. import config
+from . import analysis as analysis_mod
+from . import gen_figures
+from . import gen_tables
+from . import panel
+from .aggregate_results import (
+    _PRIMARY_METRIC_KEY,
+    _PRIMARY_METRIC_LOWER_IS_BETTER,
+    aggregate,
+    print_summary,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+def _legacy_results_dict(granularity: str) -> dict[str, Any]:
+    """Return the legacy nested-dict ``all_results[_quick].json`` if present.
+
+    These files used to live under ``data_small_caps/benchmark/<g>/`` but
+    moved to ``experiments/results/legacy_per_family/`` once experiment
+    outputs were separated from the benchmark tree. The granularity
+    argument is kept for API compatibility with older callers; the
+    legacy aggregates are not per-granularity (the file was overwritten
+    by each granularity's runner).
+    """
+    del granularity  # legacy aggregates are not per-granularity on disk
+    legacy_dir = Path(__file__).resolve().parent / "results" / "legacy_per_family"
+    for cand in ("all_results.json", "all_results_quick.json"):
+        p = legacy_dir / cand
+        if p.exists():
+            try:
+                return json.loads(p.read_text())
+            except (OSError, json.JSONDecodeError) as exc:
+                logger.warning("could not read %s: %s", p, exc)
+    return {}
+
+
+def _write_leaderboard(per_task, output_path: Path) -> None:
+    lines: list[str] = []
+    lines.append("=== MacroLens leaderboard (per-task, primary-metric ranked) ===\n")
+    for task in panel.ALL_TASKS:
+        df = per_task.get(task)
+        primary = _PRIMARY_METRIC_KEY.get(task, "?")
+        if df is None or df.empty:
+            lines.append(f"\n[{task}] (no records)\n")
+            continue
+        sub = df[df["metric_name"] == primary].dropna(subset=["value"]).copy()
+        if sub.empty:
+            lines.append(f"\n[{task}] primary metric '{primary}' missing.\n")
+            continue
+        agg = (sub.groupby(["method_id", "method_family"])["value"]
+                  .mean().reset_index())
+        ascending = _PRIMARY_METRIC_LOWER_IS_BETTER.get(task, True)
+        agg = agg.sort_values("value", ascending=ascending).reset_index(drop=True)
+        direction = "lower" if ascending else "higher"
+        lines.append(f"\n[{task}] primary={primary} ({direction}=better):\n")
+        for i, row in agg.iterrows():
+            lines.append(f"  {i+1:2d}. {row['method_id']:30s} "
+                         f"({row['method_family']:18s}) {row['value']:10.4f}\n")
+    output_path.write_text("".join(lines))
+
+
+def build(
+    *,
+    results_glob: str,
+    granularity: str,
+    output_dir: Path,
+    quick: bool = False,
+) -> dict[str, Any]:
+    """Build every paper artefact under *output_dir*.
+
+    Returns a manifest dict with the on-disk paths of the produced
+    artefacts (handy for downstream LaTeX-build orchestration / CI).
+    """
+    output_dir = Path(output_dir)
+    tables_dir = output_dir / "tables"
+    figs_dir = output_dir / "figures"
+    analysis_dir = output_dir / "analysis"
+    for d in (output_dir, tables_dir, figs_dir, analysis_dir):
+        d.mkdir(parents=True, exist_ok=True)
+
+    manifest: dict[str, Any] = {
+        "results_glob": results_glob,
+        "granularity": granularity,
+        "tables": {},
+        "figures": {},
+        "analysis": None,
+        "leaderboard": None,
+        "aggregate_parquet": None,
+    }
+
+    # 1. Aggregate RunRecord JSONs.
+    parquet_path = output_dir / "aggregate.parquet"
+    per_task = aggregate(input_glob=results_glob, output_path=parquet_path)
+    manifest["aggregate_parquet"] = str(parquet_path) if parquet_path.exists() else None
+
+    # 2. Per-task leaderboard.
+    leaderboard_path = output_dir / "leaderboard.txt"
+    _write_leaderboard(per_task, leaderboard_path)
+    manifest["leaderboard"] = str(leaderboard_path)
+    print_summary(per_task)
+
+    # 3. LaTeX tables (use legacy nested-dict if available; tables degrade
+    #    gracefully to "--" otherwise).
+    legacy = _legacy_results_dict(granularity)
+    table_calls: list[tuple[str, Any]] = [
+        ("tsf",        gen_tables.gen_tab_tsf(legacy, granularity)),
+        ("valuation",  gen_tables.gen_tab_valuation(legacy)),
+        ("generation", gen_tables.gen_tab_generation(legacy)),
+        ("scenario",   gen_tables.gen_tab_scenario(legacy)),
+        ("re",         gen_tables.gen_tab_re(legacy)),
+        ("zs_vs_ft",   gen_tables.gen_tab_zs_vs_ft(legacy, granularity)),
+        ("ablation",   gen_tables.gen_tab_ablation(legacy)),
+        ("panel",      gen_tables.gen_tab_panel_summary()),
+    ]
+    for name, body in table_calls:
+        path = tables_dir / f"tab_{name}.tex"
+        path.write_text(body)
+        manifest["tables"][name] = str(path)
+
+    # 4. Figures.
+    long_df = None
+    try:
+        # Reuse the long-form DataFrame already produced by aggregate(); we
+        # have to re-build it because aggregate() returns per-task split.
+        from .aggregate_results import _load_records, _records_to_long_df
+        paths = [Path(p) for p in sorted(glob.glob(results_glob))]
+        recs, _, _ = _load_records(paths)
+        long_df = _records_to_long_df(recs)
+    except Exception as exc:  # pragma: no cover -- defensive
+        logger.warning("could not build long-form DF for figures: %s", exc)
+    if long_df is None:
+        import pandas as pd
+        long_df = pd.DataFrame()
+    fig_outputs = gen_figures.render_all(
+        long_df, figs_dir, granularity=granularity, quick=quick,
+    )
+    manifest["figures"] = {
+        n: {"pdf": str(pdf), "png": str(png)} for n, (pdf, png) in fig_outputs.items()
+    }
+
+    # 5. Stratified analysis.
+    try:
+        analysis_results = analysis_mod.run_all_analyses(granularity)
+        analysis_out = analysis_dir / "analysis_results.json"
+        analysis_out.write_text(json.dumps(analysis_results, indent=2, default=str))
+        manifest["analysis"] = str(analysis_out)
+    except Exception as exc:
+        logger.warning("analysis pipeline failed: %s", exc)
+        manifest["analysis_error"] = str(exc)
+
+    # 6. Manifest.
+    manifest_path = output_dir / "manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2, default=str))
+    return manifest
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--results-glob", type=str,
+        # Results live under experiments/results/, NOT data_small_caps/.
+        default=str(Path(__file__).parent / "results" / "canon_*.json"),
+    )
+    parser.add_argument(
+        "--granularity", default="daily",
+        choices=["daily", "weekly", "monthly"],
+    )
+    parser.add_argument(
+        "--output-dir", type=Path,
+        default=Path(__file__).parent / "paper_artifacts",
+    )
+    parser.add_argument("--quick", action="store_true",
+                        help="Downsample inputs to keep CI runs fast.")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
+    manifest = build(
+        results_glob=args.results_glob,
+        granularity=args.granularity,
+        output_dir=args.output_dir,
+        quick=args.quick,
+    )
+    logger.info("paper artefacts manifest: %s", manifest.get("aggregate_parquet"))
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    sys.exit(main())

code/experiments/gen_figures.py

@@ -0,0 +1,463 @@
+"""Paper figure generator.
+
+Produces four PDF figures for the MacroLens NeurIPS 2026 D&B paper.
+Source of truth: aggregated long-DataFrame from
+:mod:`experiments.aggregate_results` (or load directly from a results JSON
+glob via the CLI below).
+
+Figures (all panel-driven; method ordering follows the registry's
+``family -> name`` sort):
+
+* ``fig_panel_overview``       - Figure 1 (page-1 schematic): grid of 7 tasks
+  x 7 families with counts where the family covers the task. Plus the
+  benchmark headline numbers (4,416 tickers, 131 features, 1,130 events).
+* ``fig_primary_metric_per_task`` - One subplot per task; horizontal bar
+  chart of method primary-metric values with bootstrap-CI error bars; methods
+  ordered by primary metric (best at top).
+* ``fig_per_family_box``       - One subplot per task; box-and-whisker of
+  primary metric grouped by family (n=members in that family that cover the
+  task). Shows family-level distribution.
+* ``fig_zs_vs_ft``             - Bar chart: ZS vs FT for the LLM family
+  (the 3 frontier models), only on T1.
+
+(Single-horizon experiment design — no horizon-curve figure; horizon is
+fixed to the longest configured value per granularity, e.g. 252 daily.)
+
+CLI::
+
+    python -m projects.agent_builder.scripts.whatif_bench.experiments.gen_figures \
+        --results-glob 'experiments/results/canon_*.json' \
+        --output-dir   'experiments/paper_artifacts/figures/' \
+        --granularity  daily
+
+Headless: matplotlib is forced to the ``Agg`` backend so the script runs on a
+GPU box / CI without an X server. Each figure is saved as both ``.pdf``
+(vector, for LaTeX) and ``.png`` (raster, for previews / quicklook).
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import logging
+from pathlib import Path
+from typing import Iterable
+
+import matplotlib
+
+matplotlib.use("Agg")  # headless
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+
+from .. import config  # noqa: E402
+from . import panel  # noqa: E402
+from .aggregate_results import (  # noqa: E402
+    _PRIMARY_METRIC_KEY,
+    _PRIMARY_METRIC_LOWER_IS_BETTER,
+    _load_records,
+    _records_to_long_df,
+    aggregate,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# Friendly family display name + plot colour. Stable across all figures so
+# the same family always reads as the same hue.
+_FAMILY_ORDER: tuple[str, ...] = (
+    "naive", "classical", "sequence",
+    "tsfm",
+    "llm_ts",
+    "llm",
+)
+_FAMILY_DISPLAY: dict[str, str] = {
+    "naive": "Naive",
+    "classical": "Classical",
+    "sequence": "Deep Seq",
+    "tsfm": "TSFM",
+    "llm_ts": "LLM-TS",
+    "llm": "LLM",
+}
+_FAMILY_COLOR: dict[str, str] = {
+    "naive": "tab:gray",
+    "classical": "tab:olive",
+    "sequence": "tab:blue",
+    "tsfm": "tab:cyan",
+    "llm_ts": "tab:purple",
+    "llm": "tab:orange",
+}
+
+# Registry-family aliases used by the runner inside the long DataFrame's
+# ``method_family`` column. Panel and registry now use the same canonical
+# family names ("tsfm", "llm", "llm_ts"); the alias map is a no-op kept
+# only so adding a new family later is a one-line change.
+_FAMILY_ALIASES: dict[str, str] = {}
+
+
+def _canonical_family(family: str) -> str:
+    return _FAMILY_ALIASES.get(family, family)
+
+
+def _save_fig(fig: plt.Figure, output_path: Path) -> tuple[Path, Path]:
+    """Save *fig* as both ``output_path.pdf`` and ``output_path.png``."""
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pdf = output_path.with_suffix(".pdf")
+    png = output_path.with_suffix(".png")
+    fig.savefig(pdf, bbox_inches="tight", dpi=300)
+    fig.savefig(png, bbox_inches="tight", dpi=200)
+    plt.close(fig)
+    return pdf, png
+
+
+def _method_display(method_id: str) -> str:
+    """Display name for *method_id* (panel-aware, registry-fallback)."""
+    for m in panel.ALL_METHODS:
+        if m.id == method_id:
+            return m.name
+    return method_id
+
+
+def _primary_view(df: pd.DataFrame, task: str) -> pd.DataFrame:
+    """Per-method mean-over-seeds view of the task's primary metric."""
+    metric = _PRIMARY_METRIC_KEY.get(task)
+    if metric is None or df.empty:
+        return pd.DataFrame()
+    sub = df[(df["task"] == task) & (df["metric_name"] == metric)].copy()
+    if sub.empty:
+        return sub
+    grouped = (
+        sub.groupby(["method_id", "method_family"], as_index=False)
+           .agg(value=("value", "mean"),
+                ci_lo=("ci_lo", "mean"),
+                ci_hi=("ci_hi", "mean"),
+                std=("std", "mean"))
+    )
+    grouped["family"] = grouped["method_family"].map(_canonical_family)
+    grouped["display"] = grouped["method_id"].map(_method_display)
+    grouped = grouped.dropna(subset=["value"])
+    return grouped
+
+
+# ---------------------------------------------------------------------------
+# Figure 1: panel overview (task x family coverage matrix)
+# ---------------------------------------------------------------------------
+
+def fig_panel_overview(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]:
+    """Page-1 schematic: 7 tasks x 7 families coverage grid + headline numbers.
+
+    *df* is unused for the static schematic; accepted to keep the figure-API
+    uniform across the five generators.
+    """
+    tasks = list(panel.ALL_TASKS)
+    families = list(_FAMILY_ORDER)
+
+    # Build coverage matrix from panel.ALL_METHODS (canonical 18-method panel).
+    coverage = np.zeros((len(families), len(tasks)), dtype=int)
+    for m in panel.ALL_METHODS:
+        if m.family not in _FAMILY_DISPLAY:
+            continue  # unknown family – skip
+        i = families.index(m.family)
+        for t in m.tasks:
+            if t in tasks:
+                j = tasks.index(t)
+                coverage[i, j] += 1
+
+    fig, ax = plt.subplots(figsize=(8.5, 4.0))
+    # Heatmap with a reversed grayscale palette so 0 = white, n>0 = darker.
+    im = ax.imshow(coverage, aspect="auto", cmap="Blues",
+                   vmin=0, vmax=max(1, int(coverage.max())))
+    ax.set_xticks(range(len(tasks)))
+    ax.set_xticklabels(tasks, fontsize=10)
+    ax.set_yticks(range(len(families)))
+    ax.set_yticklabels([_FAMILY_DISPLAY[f] for f in families], fontsize=10)
+    for i in range(len(families)):
+        for j in range(len(tasks)):
+            n = coverage[i, j]
+            if n > 0:
+                ax.text(j, i, str(n), ha="center", va="center",
+                        color="white" if n >= 2 else "black", fontsize=10)
+    ax.set_title("MacroLens method-x-task coverage "
+                 "(4,416 tickers; 131 features; 1,130 events)",
+                 fontsize=11)
+    fig.colorbar(im, ax=ax, label="# methods")
+    fig.tight_layout()
+    return _save_fig(fig, output_path)
+
+
+# ---------------------------------------------------------------------------
+# Figure 2: primary metric per task
+# ---------------------------------------------------------------------------
+
+def fig_primary_metric_per_task(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]:
+    """One horizontal-bar subplot per task; bars sorted best-on-top."""
+    tasks = list(panel.ALL_TASKS)
+    n_tasks = len(tasks)
+    ncols = 2
+    nrows = (n_tasks + ncols - 1) // ncols
+    fig, axes = plt.subplots(nrows, ncols, figsize=(11, 2.4 * nrows + 1.0),
+                             squeeze=False)
+    axes_flat = axes.flatten()
+
+    any_data = False
+    for k, t in enumerate(tasks):
+        ax = axes_flat[k]
+        view = _primary_view(df, t)
+        primary = _PRIMARY_METRIC_KEY[t]
+        ascending = _PRIMARY_METRIC_LOWER_IS_BETTER[t]
+
+        if view.empty:
+            ax.set_axis_off()
+            ax.set_title(f"{t} — no records")
+            continue
+        any_data = True
+        view = view.sort_values("value", ascending=ascending).reset_index(drop=True)
+        # Reverse so best-on-top after barh paints bottom-up.
+        view = view.iloc[::-1].reset_index(drop=True)
+
+        y = np.arange(len(view))
+        # Symmetric error length from CI; fall back to std if CI absent.
+        lo = view["value"].to_numpy() - view["ci_lo"].to_numpy()
+        hi = view["ci_hi"].to_numpy() - view["value"].to_numpy()
+        lo = np.where(np.isnan(lo), view["std"].fillna(0).to_numpy(), lo)
+        hi = np.where(np.isnan(hi), view["std"].fillna(0).to_numpy(), hi)
+        lo = np.clip(lo, 0, None)
+        hi = np.clip(hi, 0, None)
+        colors = [_FAMILY_COLOR.get(f, "tab:gray") for f in view["family"]]
+        ax.barh(y, view["value"], xerr=[lo, hi], color=colors,
+                edgecolor="black", linewidth=0.4, capsize=2)
+        ax.set_yticks(y)
+        ax.set_yticklabels(view["display"], fontsize=8)
+        ax.set_title(f"{t} ({primary})", fontsize=10)
+        ax.tick_params(axis="x", labelsize=8)
+
+    # Hide unused axes
+    for k in range(len(tasks), len(axes_flat)):
+        axes_flat[k].set_axis_off()
+
+    # Family legend – only families that actually appear.
+    seen_fams = sorted({_canonical_family(f) for f in df["method_family"].unique()
+                        if isinstance(f, str)}) if not df.empty else []
+    handles = [plt.Rectangle((0, 0), 1, 1, color=_FAMILY_COLOR[f])
+               for f in seen_fams if f in _FAMILY_COLOR]
+    labels = [_FAMILY_DISPLAY[f] for f in seen_fams if f in _FAMILY_COLOR]
+    if handles:
+        fig.legend(handles, labels, ncol=min(len(handles), 4),
+                   loc="lower center", bbox_to_anchor=(0.5, -0.01),
+                   fontsize=8, frameon=False)
+    fig.suptitle(
+        "Per-task primary-metric leaderboard (mean across seeds; "
+        "error bars = bootstrap 95% CI)" if any_data
+        else "Per-task primary-metric leaderboard (no data)",
+        fontsize=11,
+    )
+    fig.tight_layout(rect=[0, 0.03, 1, 0.97])
+    return _save_fig(fig, output_path)
+
+
+# ---------------------------------------------------------------------------
+# Figure 3: T1 horizon curves
+# ---------------------------------------------------------------------------
+
+# ---------------------------------------------------------------------------
+# Figure 4: per-family box plot
+# ---------------------------------------------------------------------------
+
+def fig_per_family_box(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]:
+    """One box-plot subplot per task; primary metric grouped by family."""
+    tasks = list(panel.ALL_TASKS)
+    n_tasks = len(tasks)
+    ncols = 2
+    nrows = (n_tasks + ncols - 1) // ncols
+    fig, axes = plt.subplots(nrows, ncols, figsize=(11, 2.4 * nrows + 1.0),
+                             squeeze=False)
+    axes_flat = axes.flatten()
+
+    for k, t in enumerate(tasks):
+        ax = axes_flat[k]
+        view = _primary_view(df, t)
+        primary = _PRIMARY_METRIC_KEY[t]
+        if view.empty:
+            ax.set_axis_off()
+            ax.set_title(f"{t} — no records")
+            continue
+        # Group values by family, drop empties, preserve canonical order.
+        groups: list[tuple[str, np.ndarray]] = []
+        for fam in _FAMILY_ORDER:
+            arr = view.loc[view["family"] == fam, "value"].to_numpy()
+            arr = arr[~np.isnan(arr)]
+            if arr.size:
+                groups.append((fam, arr))
+        if not groups:
+            ax.set_axis_off()
+            ax.set_title(f"{t} — no data")
+            continue
+        positions = np.arange(len(groups))
+        bp = ax.boxplot([g[1] for g in groups], positions=positions, widths=0.55,
+                        patch_artist=True)
+        for box, (fam, _) in zip(bp["boxes"], groups):
+            box.set_facecolor(_FAMILY_COLOR.get(fam, "tab:gray"))
+            box.set_alpha(0.7)
+        for med in bp["medians"]:
+            med.set_color("black")
+        ax.set_xticks(positions)
+        ax.set_xticklabels([_FAMILY_DISPLAY[g[0]] for g in groups],
+                           rotation=30, ha="right", fontsize=8)
+        ax.set_title(f"{t} ({primary})", fontsize=10)
+        ax.tick_params(axis="y", labelsize=8)
+
+    for k in range(len(tasks), len(axes_flat)):
+        axes_flat[k].set_axis_off()
+    fig.suptitle("Per-family primary-metric distribution by task", fontsize=11)
+    fig.tight_layout(rect=[0, 0.0, 1, 0.97])
+    return _save_fig(fig, output_path)
+
+
+# ---------------------------------------------------------------------------
+# Figure 5: ZS vs FT (T1)
+# ---------------------------------------------------------------------------
+
+def fig_zs_vs_ft(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]:
+    """Single-panel bar chart comparing ZS vs FT on T1 for the LLM family."""
+    fig, ax = plt.subplots(1, 1, figsize=(6.5, 4.0))
+
+    if df.empty:
+        ax.text(0.5, 0.5, "no records", ha="center", va="center",
+                transform=ax.transAxes); ax.set_axis_off()
+        return _save_fig(fig, output_path)
+
+    sub = df[(df["task"] == "T1") & (df["metric_name"] == "mse")].copy()
+    sub["family"] = sub["method_family"].map(_canonical_family)
+    sub["display"] = sub["method_id"].map(_method_display)
+    sub["base_id"] = sub["method_id"].str.replace(r"_(zs|ft)$", "", regex=True)
+
+    # ZS-vs-FT pair: zero-shot LLMs ("llm") vs fine-tuned LLMs ("llm_ft").
+    # The current panel reports zero-shot only, so the FT side stays empty
+    # and the deferred-placeholder branch below handles the no-data case.
+    title, fam_pair = "LLM", ["llm", "llm_ft"]
+    zs = sub[sub["family"] == fam_pair[0]]
+    ft = sub[sub["family"] == fam_pair[1]]
+    if zs.empty and ft.empty:
+        ax.text(0.5, 0.5, f"{title}: no data", ha="center", va="center",
+                transform=ax.transAxes); ax.set_axis_off()
+        fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11)
+        fig.tight_layout(rect=[0, 0, 1, 0.97])
+        return _save_fig(fig, output_path)
+
+    zs_avg = (zs.groupby("base_id", as_index=False)["value"].mean()
+                .rename(columns={"value": "zs"}))
+    ft_avg = (ft.groupby("base_id", as_index=False)["value"].mean()
+                .rename(columns={"value": "ft"}))
+    merged = zs_avg.merge(ft_avg, on="base_id", how="outer")
+    if merged.empty:
+        ax.text(0.5, 0.5, f"{title}: no data", ha="center", va="center",
+                transform=ax.transAxes); ax.set_axis_off()
+        fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11)
+        fig.tight_layout(rect=[0, 0, 1, 0.97])
+        return _save_fig(fig, output_path)
+
+    merged = merged.sort_values("base_id").reset_index(drop=True)
+    x = np.arange(len(merged))
+    w = 0.36
+    ax.bar(x - w/2, merged["zs"].fillna(np.nan), width=w,
+           color=_FAMILY_COLOR[fam_pair[0]], label="ZS",
+           edgecolor="black", linewidth=0.4)
+    ax.bar(x + w/2, merged["ft"].fillna(np.nan), width=w,
+           color=_FAMILY_COLOR[fam_pair[1]], label="FT",
+           edgecolor="black", linewidth=0.4)
+    ax.set_xticks(x)
+    ax.set_xticklabels(merged["base_id"], rotation=30, ha="right", fontsize=8)
+    ax.set_title(f"{title} family — T1 MSE (lower = better)", fontsize=10)
+    ax.set_ylabel("MSE", fontsize=9)
+    ax.legend(fontsize=8, frameon=False)
+
+    fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11)
+    fig.tight_layout(rect=[0, 0, 1, 0.97])
+    return _save_fig(fig, output_path)
+
+
+# ---------------------------------------------------------------------------
+# Driver
+# ---------------------------------------------------------------------------
+
+ALL_FIGURES: tuple[str, ...] = (
+    "panel_overview",
+    "primary_metric_per_task",
+    "per_family_box",
+    "zs_vs_ft",
+)
+
+
+def render_all(
+    df: pd.DataFrame,
+    output_dir: Path,
+    *,
+    granularity: str = "daily",
+    quick: bool = False,
+) -> dict[str, tuple[Path, Path]]:
+    """Render every paper figure from the long-form aggregator output.
+
+    *quick* downsamples the long-form input to the first 32 rows of each
+    (task, method) group to keep CI runs fast.
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out: dict[str, tuple[Path, Path]] = {}
+
+    if quick and not df.empty:
+        df = (
+            df.groupby(["task", "method_id"], as_index=False, group_keys=False)
+              .head(32)
+        )
+
+    out["panel_overview"] = fig_panel_overview(df, output_dir / "fig_panel_overview")
+    out["primary_metric_per_task"] = fig_primary_metric_per_task(
+        df, output_dir / "fig_primary_metric_per_task")
+    out["per_family_box"] = fig_per_family_box(df, output_dir / "fig_per_family_box")
+    out["zs_vs_ft"] = fig_zs_vs_ft(df, output_dir / "fig_zs_vs_ft")
+    return out
+
+
+def _df_from_glob(input_glob: str) -> pd.DataFrame:
+    paths = [Path(p) for p in sorted(glob.glob(input_glob))]
+    records, n_skip, n_mig = _load_records(paths)
+    logger.info("loaded %d records (%d non-ok, %d migrated v1->v2)",
+                len(records), n_skip, n_mig)
+    return _records_to_long_df(records)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--results-glob", type=str,
+        default=str(Path(__file__).resolve().parent / "results" / "canon_*.json"),
+        help="Glob pointing to RunRecord JSON files.",
+    )
+    parser.add_argument(
+        "--output-dir", type=Path,
+        default=Path(__file__).resolve().parent / "paper_artifacts" / "figures",
+        help="Directory to write fig_*.pdf / fig_*.png pairs.",
+    )
+    parser.add_argument(
+        "--granularity", default="daily",
+        choices=["daily", "weekly", "monthly"],
+    )
+    parser.add_argument(
+        "--quick", action="store_true",
+        help="Downsample long-form input for faster CI runs.",
+    )
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
+    df = _df_from_glob(args.results_glob)
+    out = render_all(df, args.output_dir, granularity=args.granularity, quick=args.quick)
+    for name, (pdf, png) in out.items():
+        logger.info("wrote %s -> %s", name, pdf)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    sys.exit(main())

code/experiments/gen_tables.py

@@ -0,0 +1,730 @@
+"""Generate LaTeX tables from MacroLens benchmark results.
+
+Panel-driven: the method list comes from `experiments/panel.py` (the canonical
+18-method registry: 4 naive + 2 classical + 3 sequence + 3 TSFM + 3 LLM
++ 2 LLM-TS-Multi + 1 LLM-FT), where the LLM-FT entry is a deferred-selection
+slot resolved post-hoc (winner of the Family-6 ZS sweep) and rendered in
+tab:zs_vs_ft / tab:ablation. Adding / removing methods updates the tables
+without touching this file.
+
+Tables produced (in dependency order, all driven by `panel.ALL_METHODS`):
+  1. tab:tsf        - T1 results: methods covering T1 x horizons {5, 21, 63}
+  2. tab:valuation  - T2 (Val-PT) + T5 (Priv-Val) side by side
+  3. tab:generation - T3 (Stmt-Gen) + T6 (Gen-Eval) side by side
+  4. tab:scenario   - T4 (Scen-Ret)
+  5. tab:re         - T7 (RE-Val)
+  6. tab:zs_vs_ft   - ZS vs FT for the deferred-FT cell (LLM-FT)
+  7. tab:ablation   - 5 settings x 4 tasks for the deferred-selection model
+
+Usage:
+    uv run python -m projects.agent_builder.scripts.whatif_bench.experiments.gen_tables
+    uv run python -m projects.agent_builder.scripts.whatif_bench.experiments.gen_tables --full
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from .. import config
+from . import panel
+
+
+# ----------------------------------------------------------------------------
+# Result loading
+# ----------------------------------------------------------------------------
+# Canonical results live in ``experiments/paper_artifacts/aggregate.parquet``
+# (one long-form row per (task, method_id, metric_name) with value + CIs).
+# The legacy ``experiments/results/legacy_per_family/all_results.json``
+# path is still consulted as a fallback (the file used to live under
+# ``data_small_caps/benchmark/<g>/`` but moved to experiments/ once
+# experiment outputs were separated from the benchmark tree); for new
+# submissions the parquet is the single source of truth.
+
+
+def _aggregate_path() -> Path:
+    return Path(__file__).resolve().parent / "paper_artifacts" / "aggregate.parquet"
+
+
+def _load_aggregate() -> pd.DataFrame | None:
+    p = _aggregate_path()
+    if not p.exists():
+        return None
+    try:
+        return pd.read_parquet(p)
+    except Exception as exc:  # pragma: no cover -- IO-level failure
+        print(f"warning: could not read {p}: {exc}", file=sys.stderr)
+        return None
+
+
+def _load_results(granularity: str = "daily", quick: bool = True) -> dict[str, Any]:
+    """Legacy nested-dict results loader.
+
+    Retained so the ``--legacy-json`` path that pre-dates the canon
+    aggregate keeps working. The primary table-generation path now
+    consumes :func:`_load_aggregate` and only falls back to the legacy
+    JSON when the parquet is missing. The legacy aggregates used to live
+    under ``data_small_caps/benchmark/<g>/all_results*.json`` but moved
+    to ``experiments/results/legacy_per_family/`` once experiment
+    outputs were separated from the benchmark tree; ``granularity`` is
+    kept for API compatibility (legacy aggregates are not per-granularity
+    on disk).
+    """
+    del granularity  # legacy aggregates are not per-granularity on disk
+    suffix = "_quick" if quick else ""
+    legacy_dir = Path(__file__).resolve().parent / "results" / "legacy_per_family"
+    path = legacy_dir / f"all_results{suffix}.json"
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())
+
+
+# ----------------------------------------------------------------------------
+# Family routing: which family JSON does each method's results live under?
+# ----------------------------------------------------------------------------
+# Panel families and the orchestrator's per-family JSON keys are aligned
+# 1:1 on the canonical names ("tsfm", "llm", "llm_ts"). The legacy panel
+# ("tsfm_zs", "llm_zs", "llm_ts_multitask") was reconciled with the
+# canon RunRecord families in experiments/panel.py; this map is now a
+# trivial pass-through and is retained only so that adding a new family
+# remains a one-line change.
+
+_PANEL_FAMILY_TO_JSON_KEY: dict[str, str] = {
+    "naive": "naive",
+    "classical": "classical",
+    "sequence": "sequence",
+    "tsfm": "tsfm",
+    "llm_ts": "llm_ts_reason",
+    "llm": "llm",
+}
+
+
+# Each family's key-naming convention for the per-task result key. Kept here
+# so the table generator never has to hardcode method-by-method.
+
+def _result_key(method: panel.Method, task: panel.Task, horizon: int | None = None) -> list[str]:
+    """Candidate result keys to try for (method, task) under that family's JSON.
+
+    Returns a list because some families historically used multiple naming
+    schemes; we try them in order and use the first that matches.
+    """
+    mid = method.id
+    family = method.family
+    keys: list[str] = []
+
+    if task == "T1":
+        if family in ("naive", "classical", "sequence", "tsfm"):
+            keys.append(f"tsf_{mid}_h{horizon}")
+        elif family in ("llm_ts", "llm"):
+            keys.append(f"tsf_llm_{mid}_h{horizon}")
+            keys.append(f"tsf_{mid}_h{horizon}")
+            # llm_ts uses chattime_task_1 style:
+            keys.append(f"{mid}_task_1_h{horizon}")
+            keys.append(f"{mid}_task_1")
+    elif task == "T2":
+        keys.append(f"task_2_{mid}")
+        if family == "llm":
+            keys.append(f"task_2_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_2")
+    elif task == "T3":
+        keys.append(f"task_3_{mid}")
+        if family == "llm":
+            keys.append(f"task_3_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_3")
+    elif task == "T4":
+        keys.append(f"task_4_{mid}")
+        if family == "naive":
+            # historical_analogue lives under the alias "task_4_analogue"
+            keys.append("task_4_analogue")
+        if family == "llm":
+            keys.append(f"task_4_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_4")
+    elif task == "T5":
+        keys.append(f"task_5_{mid}")
+        if family == "llm":
+            keys.append(f"task_5_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_5")
+    elif task == "T6":
+        keys.append(f"task_6_{mid}")
+        if family == "llm":
+            keys.append(f"task_6_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_6")
+    elif task == "T7":
+        keys.append(f"task_7_{mid}")
+        if family == "llm":
+            keys.append(f"task_7_llm_{mid}")
+        if family == "llm_ts":
+            keys.append(f"{mid}_task_7")
+
+    return keys
+
+
+def _get_family_data(data: dict, method: panel.Method) -> dict:
+    """Navigate `data` to the family dict for `method`."""
+    json_key = _PANEL_FAMILY_TO_JSON_KEY.get(method.family, method.family)
+    fam = data.get(json_key, {})
+    if not isinstance(fam, dict):
+        return {}
+    return fam
+
+
+def _lookup(data: dict, method: panel.Method, task: panel.Task,
+            horizon: int | None = None) -> dict:
+    """Find the result dict for (method, task[, horizon]); empty dict if missing.
+
+    When ``data`` is the long-form parquet DataFrame (preferred path), the
+    return dict is a flat mapping ``metric_name -> value`` augmented with
+    paired ``<metric>_ci_lo`` / ``<metric>_ci_hi`` keys so existing
+    per-table functions keep their ``r.get("mse")`` shape but can opt
+    into CI rendering with ``r.get("mse_ci_lo")`` / ``_ci_hi``.
+
+    When ``data`` is the legacy nested dict, the lookup returns the cell
+    as-is (no CIs available).
+    """
+    if isinstance(data, pd.DataFrame):
+        df = data[(data["method_id"] == method.id) & (data["task"] == task)]
+        # Main-table lookups exclude ablation cells (the A--E settings
+        # live in tab:ablation, not the per-task headline tables).
+        df = df[df["ablation_setting"].isna()]
+        if df.empty:
+            return {}
+        # Most cells have a single granularity/seed; pick the latest
+        # timestamp deterministically.
+        df = df.sort_values("timestamp").groupby("metric_name").tail(1)
+        out: dict[str, Any] = {}
+        for _, row in df.iterrows():
+            name = row["metric_name"]
+            out[name] = row["value"]
+            if pd.notna(row.get("ci_lo")):
+                out[f"{name}_ci_lo"] = row["ci_lo"]
+            if pd.notna(row.get("ci_hi")):
+                out[f"{name}_ci_hi"] = row["ci_hi"]
+            if pd.notna(row.get("n_boot")):
+                out[f"{name}_n_boot"] = int(row["n_boot"])
+        return out
+    fam = _get_family_data(data, method)
+    if not fam:
+        return {}
+    for key in _result_key(method, task, horizon):
+        result = fam.get(key)
+        if isinstance(result, dict) and "error" not in result:
+            return result
+    return {}
+
+
+# ----------------------------------------------------------------------------
+# Number formatting
+# ----------------------------------------------------------------------------
+
+def _f(v, fmt: str = ".2f", default: str = "--") -> str:
+    if v is None:
+        return default
+    try:
+        if isinstance(v, (int, float)) and v != v:  # NaN check
+            return default
+        return format(float(v), fmt)
+    except (TypeError, ValueError):
+        return default
+
+
+def _f_ci(value, ci_lo, ci_hi, fmt: str = ".2f", default: str = "--") -> str:
+    """Format ``value [lo, hi]`` if CI is present; fall back to ``value``."""
+    point = _f(value, fmt, default)
+    if point == default:
+        return default
+    if ci_lo is None or ci_hi is None:
+        return point
+    try:
+        if (isinstance(ci_lo, float) and ci_lo != ci_lo) or (
+            isinstance(ci_hi, float) and ci_hi != ci_hi
+        ):
+            return point
+    except TypeError:
+        return point
+    return (
+        rf"{point}\,{{\scriptsize [{_f(ci_lo, fmt, default)},"
+        rf"\,{_f(ci_hi, fmt, default)}]}}"
+    )
+
+
+def _pct(v) -> str:
+    """Format a fraction (0..1) as `xx.x` percent."""
+    if v is None:
+        return "--"
+    try:
+        return f"{float(v) * 100:.1f}"
+    except (TypeError, ValueError):
+        return "--"
+
+
+# ----------------------------------------------------------------------------
+# Tables
+# ----------------------------------------------------------------------------
+
+def gen_tab_tsf(data: dict, granularity: str = "daily") -> str:
+    """T1 (TSF) results across panel methods x horizons."""
+    horizons = config.get_horizons(granularity)
+    methods_t1 = [m for m in panel.ALL_METHODS if "T1" in m.tasks]
+
+    n_h = len(horizons)
+    col_spec = "ll " + " ".join(["rr"] * n_h)
+
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Task 1 (TSF) results, "
+        f"{granularity}, lookback={config.get_lookback_windows(granularity)[0]}. "
+        r"Best per-column \textbf{bold}.}")
+    lines.append(r"\label{tab:tsf}")
+    lines.append(r"\resizebox{\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{" + col_spec + "}")
+    lines.append(r"\toprule")
+    headers = " & ".join(
+        rf"\multicolumn{{2}}{{c}}{{\textbf{{H={h}}}}}" for h in horizons
+    )
+    lines.append(rf"& & {headers} \\")
+    cmidrules = " ".join(
+        rf"\cmidrule(lr){{{3 + 2*i}-{4 + 2*i}}}" for i in range(n_h)
+    )
+    lines.append(cmidrules)
+    metric_hdr = " & ".join(["MSE", r"DA\%"] * n_h)
+    lines.append(rf"\textbf{{Family}} & \textbf{{Method}} & {metric_hdr} \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in methods_t1:
+        # Group by family with a midrule between groups.
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        row = [fam_label, m.name]
+        for h in horizons:
+            r = _lookup(data, m, "T1", horizon=h)
+            if "overall" in r and isinstance(r["overall"], dict):
+                mse = r["overall"].get("mse")
+                mse_lo = mse_hi = None
+                da = r["overall"].get("directional_accuracy")
+            else:
+                mse = r.get("mse")
+                mse_lo = r.get("mse_ci_lo")
+                mse_hi = r.get("mse_ci_hi")
+                da = r.get("directional_accuracy")
+            row += [_f_ci(mse, mse_lo, mse_hi, ".1f"), _pct(da)]
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_valuation(data: dict) -> str:
+    """T2 (Val-PT) + T5 (Priv-Val) side by side. MedAPE% / Spearman."""
+    methods = [m for m in panel.ALL_METHODS if "T2" in m.tasks or "T5" in m.tasks]
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Valuation: Task~2 (Val-PT) vs Task~5 (Priv-Val). "
+        r"MedAPE\%$\downarrow$, Spearman~$\rho\uparrow$.}")
+    lines.append(r"\label{tab:valuation}")
+    lines.append(r"\resizebox{\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{ll cc cc}")
+    lines.append(r"\toprule")
+    lines.append(
+        r"& & \multicolumn{2}{c}{\textbf{T2 Val-PT}} & "
+        r"\multicolumn{2}{c}{\textbf{T5 Priv-Val}} \\")
+    lines.append(r"\cmidrule(lr){3-4} \cmidrule(lr){5-6}")
+    lines.append(
+        r"\textbf{Family} & \textbf{Method} & "
+        r"MedAPE\%$\downarrow$ & $\rho\uparrow$ & "
+        r"MedAPE\%$\downarrow$ & $\rho\uparrow$ \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in methods:
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        row = [fam_label, m.name]
+        for task in ("T2", "T5"):
+            if task in m.tasks:
+                r = _lookup(data, m, task)
+                row += [
+                    _f_ci(r.get("median_ape"),
+                          r.get("median_ape_ci_lo"),
+                          r.get("median_ape_ci_hi"), ".1f"),
+                    _f(r.get("rank_correlation"), ".3f"),
+                ]
+            else:
+                row += ["--", "--"]
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_generation(data: dict) -> str:
+    """T3 (Stmt-Gen) + T6 (Gen-Eval) side by side. Per-field MAPE%, Bal-Eq%."""
+    methods = [m for m in panel.ALL_METHODS if "T3" in m.tasks or "T6" in m.tasks]
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Generation: Task~3 (Stmt-Gen) vs Task~6 (Gen-Eval). "
+        r"per-field MAPE\%$\downarrow$, balance-equation accuracy\%$\uparrow$.}")
+    lines.append(r"\label{tab:generation}")
+    lines.append(r"\resizebox{\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{ll cc cc}")
+    lines.append(r"\toprule")
+    lines.append(
+        r"& & \multicolumn{2}{c}{\textbf{T3 Stmt-Gen}} & "
+        r"\multicolumn{2}{c}{\textbf{T6 Gen-Eval}} \\")
+    lines.append(r"\cmidrule(lr){3-4} \cmidrule(lr){5-6}")
+    lines.append(
+        r"\textbf{Family} & \textbf{Method} & "
+        r"MAPE\%$\downarrow$ & Bal-Eq\%$\uparrow$ & "
+        r"MAPE\%$\downarrow$ & Bal-Eq\%$\uparrow$ \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in methods:
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        row = [fam_label, m.name]
+        for task in ("T3", "T6"):
+            if task in m.tasks:
+                r = _lookup(data, m, task)
+                row += [
+                    _f_ci(r.get("overall_mape"),
+                          r.get("overall_mape_ci_lo"),
+                          r.get("overall_mape_ci_hi"), ".1f"),
+                    _pct(r.get("balance_equation_accuracy")),
+                ]
+            else:
+                row += ["--", "--"]
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_scenario(data: dict) -> str:
+    """T4 (Scen-Ret): MAE%, DA%, CI calibration."""
+    methods = [m for m in panel.ALL_METHODS if "T4" in m.tasks]
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Task~4 (Scen-Ret). Predict post-event return. "
+        r"Best per-column \textbf{bold}.}")
+    lines.append(r"\label{tab:scenario}")
+    lines.append(r"\resizebox{0.85\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{ll ccc}")
+    lines.append(r"\toprule")
+    lines.append(
+        r"\textbf{Family} & \textbf{Method} & "
+        r"MAE\%$\downarrow$ & DA\%$\uparrow$ & CI Cal.\%$\uparrow$ \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in methods:
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        r = _lookup(data, m, "T4")
+        row = [
+            fam_label, m.name,
+            _f_ci(r.get("return_mae_pct"),
+                  r.get("return_mae_pct_ci_lo"),
+                  r.get("return_mae_pct_ci_hi"), ".2f"),
+            _pct(r.get("directional_accuracy")),
+            _pct(r.get("ci_calibration_95")),
+        ]
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_re(data: dict) -> str:
+    """T7 (RE-Val): Rent MAPE / Price MAPE."""
+    methods = [m for m in panel.ALL_METHODS if "T7" in m.tasks]
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Task~7 (RE-Val). Rent and price prediction across 100 metros.}")
+    lines.append(r"\label{tab:re}")
+    lines.append(r"\resizebox{0.7\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{ll cc}")
+    lines.append(r"\toprule")
+    lines.append(
+        r"\textbf{Family} & \textbf{Method} & "
+        r"Rent MAPE\%$\downarrow$ & Price MAPE\%$\downarrow$ \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in methods:
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        r = _lookup(data, m, "T7")
+        row = [
+            fam_label, m.name,
+            _f_ci(r.get("rent_MAPE"),
+                  r.get("rent_MAPE_ci_lo"),
+                  r.get("rent_MAPE_ci_hi"), ".1f"),
+            _f_ci(r.get("price_MAPE"),
+                  r.get("price_MAPE_ci_lo"),
+                  r.get("price_MAPE_ci_hi"), ".1f"),
+        ]
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_zs_vs_ft(data: dict, granularity: str = "daily") -> str:
+    """ZS vs FT comparison for the deferred-FT cell.
+
+    Empty stub when `panel.LLM_FT_PANEL_HF_IDS` is empty. Once the
+    deferred-selection rule populates that tuple, the table will resolve
+    to the chosen FT cell automatically.
+    """
+    horizons = config.get_horizons(granularity)
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Zero-shot vs fine-tuned comparison. "
+        r"Deferred-selection: a single FT cell for the panel-best "
+        r"Family-6 ZS LLM (see paper \S6 / panel.py).}")
+    lines.append(r"\label{tab:zs_vs_ft}")
+
+    if not panel.LLM_FT_PANEL_HF_IDS:
+        lines.append(
+            r"\textit{Deferred -- target not yet selected from the full ZS sweep. "
+            r"Selection rule pre-registered in \texttt{experiments/panel.py}.}")
+        lines.append(r"\end{table}")
+        return "\n".join(lines)
+
+    # Both deferred slots resolved -> full table. Currently unreached.
+    lines.append(
+        r"\resizebox{\textwidth}{!}{%"
+        r"\begin{tabular}{l " + " ".join(["rrr"] * len(horizons)) + "}")
+    lines.append(r"\toprule")
+    h_hdr = " & ".join(
+        rf"\multicolumn{{3}}{{c}}{{\textbf{{H={h}}}}}" for h in horizons
+    )
+    lines.append(rf"& {h_hdr} \\")
+    cmid = " ".join(
+        rf"\cmidrule(lr){{{2 + 3*i}-{4 + 3*i}}}" for i in range(len(horizons))
+    )
+    lines.append(cmid)
+    metric_hdr = " & ".join([r"ZS & FT & $\Delta$\%"] * len(horizons))
+    lines.append(rf"\textbf{{Model}} & {metric_hdr} \\")
+    lines.append(r"\midrule")
+    # Rows resolved post-hoc once the deferred panels populate; left empty.
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_ablation(data: dict) -> str:
+    """Family-9 ablation: 5 settings x 4 tasks for the deferred-selection model."""
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{Context ablation. 5 feature settings (A-E) "
+        r"$\times$ 4 tasks for the deferred-FT target.}")
+    lines.append(r"\label{tab:ablation}")
+
+    if not panel.ABLATION_MODEL_IDS:
+        lines.append(
+            r"\textit{Deferred -- ablation model resolves to the same target as "
+            r"\texttt{LLM\_FT\_PANEL\_HF\_IDS} (post-hoc Family-7 ZS winner). "
+            r"Selection rule pre-registered in \texttt{experiments/panel.py}.}")
+        lines.append(r"\end{table}")
+        return "\n".join(lines)
+
+    # Once ABLATION_MODEL_IDS populates, render the 2 modes x 5 settings x 4 tasks.
+    abl = data.get("ablation", {}) if isinstance(data.get("ablation"), dict) else {}
+    settings = ["A", "B", "C", "D", "E"]
+
+    # 4 tasks x 2 modes (ZS, FT) = 8 columns.
+    col_spec = "ll " + " ".join(["rr"] * len(panel.ABLATION_TASKS))
+    lines.append(r"\resizebox{\textwidth}{!}{%")
+    lines.append(r"\begin{tabular}{" + col_spec + "}")
+    lines.append(r"\toprule")
+    task_hdr = " & ".join(
+        rf"\multicolumn{{2}}{{c}}{{\textbf{{{t}}}}}" for t in panel.ABLATION_TASKS
+    )
+    lines.append(rf"& & {task_hdr} \\")
+    cmid = " ".join(
+        rf"\cmidrule(lr){{{3 + 2*i}-{4 + 2*i}}}" for i in range(len(panel.ABLATION_TASKS))
+    )
+    lines.append(cmid)
+    mode_hdr = " & ".join(["ZS & FT"] * len(panel.ABLATION_TASKS))
+    lines.append(rf"\textbf{{Setting}} & \textbf{{\#Feat}} & {mode_hdr} \\")
+    lines.append(r"\midrule")
+
+    for s in settings:
+        s_meta = panel.ABLATION_SETTINGS[s]
+        row = [s, str(s_meta["n_features"])]
+        for t in panel.ABLATION_TASKS:
+            for mode in panel.ABLATION_MODES:
+                cell = abl.get(f"setting_{s}_{mode}_{t}", {})
+                # Use the task's primary metric defined in panel.TASK_METADATA
+                primary = panel.TASK_METADATA[t]["primary_metric"]
+                key_map = {
+                    "MSE": "mse",
+                    "MedAPE": "median_ape",
+                    "Return MAE": "return_mae_pct",
+                    "per-field MAPE": "overall_mape",
+                    "Rent + Price MAPE": "rent_MAPE",
+                }
+                k = key_map.get(primary, "mse")
+                v = cell.get(k) if isinstance(cell, dict) else None
+                row.append(_f(v, ".1f"))
+        lines.append(" & ".join(row) + r" \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+def gen_tab_panel_summary() -> str:
+    """Static appendix table: the 18-method panel from panel.py (incl. 1 deferred FT cell)."""
+    lines: list[str] = []
+    lines.append(r"\begin{table}[t]")
+    lines.append(r"\centering")
+    lines.append(
+        r"\caption{MacroLens baseline panel. 17 fixed methods + 1 deferred-selection LLM-FT cell (post-hoc Family-6 ZS winner) = 18 entries.}")
+    lines.append(r"\label{tab:panel}")
+    lines.append(r"\begin{tabular}{lll l l}")
+    lines.append(r"\toprule")
+    lines.append(
+        r"\textbf{Family} & \textbf{Method} & \textbf{HF id / source} & "
+        r"\textbf{Tasks} & \textbf{Notes} \\")
+    lines.append(r"\midrule")
+
+    last_family: str | None = None
+    for m in panel.ALL_METHODS:
+        if last_family is not None and m.family != last_family:
+            lines.append(r"\midrule")
+        fam_label = m.family.replace("_", " ") if m.family != last_family else ""
+        last_family = m.family
+        tasks_str = ",".join(sorted(m.tasks))
+        hf = m.hf_id or "--"
+        # Truncate notes for table layout.
+        note = m.notes.replace("\n", " ").strip()
+        if len(note) > 60:
+            note = note[:57] + "..."
+        # Escape underscores for LaTeX in HF ids.
+        hf_tex = hf.replace("_", r"\_")
+        lines.append(
+            f"{fam_label} & {m.name} & \\texttt{{{hf_tex}}} & {tasks_str} & {note} \\\\"
+        )
+
+    lines.append(r"\midrule")
+    lines.append(
+        r"\multicolumn{5}{l}{"
+        r"\textit{Deferred: 1 LLM-FT cell (post-hoc Family-6 ZS winner).}} \\")
+
+    lines.append(r"\bottomrule")
+    lines.append(r"\end{tabular}")
+    lines.append(r"\end{table}")
+    return "\n".join(lines)
+
+
+# ----------------------------------------------------------------------------
+# Main
+# ----------------------------------------------------------------------------
+
+def _emit_all(data, granularity: str, output_dir: Path | None) -> None:
+    print("% === MacroLens Paper Tables (panel-driven) ===")
+    print(f"% panel summary: {panel.summary()}\n")
+
+    tables = [
+        ("tsf",        gen_tab_tsf(data, granularity)),
+        ("valuation",  gen_tab_valuation(data)),
+        ("generation", gen_tab_generation(data)),
+        ("scenario",   gen_tab_scenario(data)),
+        ("re",         gen_tab_re(data)),
+        ("zs_vs_ft",   gen_tab_zs_vs_ft(data, granularity)),
+        ("ablation",   gen_tab_ablation(data)),
+        ("panel",      gen_tab_panel_summary()),
+    ]
+    for name, body in tables:
+        print(f"\n% --- tab:{name} ---")
+        print(body)
+        if output_dir is not None:
+            (output_dir / f"tab_{name}.tex").write_text(body)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Emit LaTeX tables for the MacroLens paper from aggregated results.",
+    )
+    parser.add_argument("--granularity", default="daily",
+                        choices=["daily", "weekly", "monthly"])
+    parser.add_argument("--legacy-json", action="store_true",
+                        help=("Read the legacy nested-dict all_results.json "
+                              "instead of the canon-aggregate parquet."))
+    parser.add_argument("--full", action="store_true",
+                        help=("Read full-run all_results.json instead of the "
+                              "_quick variant (only meaningful with "
+                              "--legacy-json)."))
+    parser.add_argument("--out-dir", type=Path, default=None,
+                        help="If provided, write each table to <out>/tab_<name>.tex.")
+    args = parser.parse_args()
+
+    if args.legacy_json:
+        data: Any = _load_results(args.granularity, quick=not args.full)
+    else:
+        df = _load_aggregate()
+        if df is None:
+            print(
+                f"error: aggregate.parquet not found at {_aggregate_path()}; "
+                "run experiments/build_paper_artifacts.py or pass --legacy-json.",
+                file=sys.stderr,
+            )
+            sys.exit(2)
+        data = df
+
+    if args.out_dir is not None:
+        args.out_dir.mkdir(parents=True, exist_ok=True)
+    _emit_all(data, args.granularity, args.out_dir)
+
+
+if __name__ == "__main__":
+    main()

code/experiments/panel.py

@@ -0,0 +1,495 @@
+"""Canonical MacroLens baseline panel for the NeurIPS 2026 D&B submission.
+
+Single source of truth for:
+- Which methods are in the panel (18 method classes across 7 families)
+- Which tasks each method covers (T1..T7)
+- HuggingFace model IDs for LLM/TSFM checkpoints (FP8 native MLLMs)
+- GPU parallelism hints (tensor-parallel size)
+- Seed strategy (primary seed vs headline T1 subset)
+- Ablation subset (5 models x 5 settings on T1 h=21 + T4)
+
+Any change to the panel MUST happen here first; all family runners import from
+this module. If a method is not in `ALL_METHODS`, the orchestrators will not
+run it. If a HuggingFace ID changes, update this file only.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+# ── Task IDs ──────────────────────────────────────────────────────────────
+
+Task = Literal["T1", "T2", "T3", "T4", "T5", "T6", "T7"]
+
+ALL_TASKS: tuple[Task, ...] = ("T1", "T2", "T3", "T4", "T5", "T6", "T7")
+
+TASK_METADATA: dict[Task, dict] = {
+    "T1": {"name": "TSF", "long": "Contextual Time-Series Forecasting",
+           "primary_metric": "MSE"},
+    "T2": {"name": "Val-PT", "long": "Point-in-Time Equity Valuation",
+           "primary_metric": "MedAPE"},
+    "T3": {"name": "Stmt-Gen", "long": "Statement Generation",
+           "primary_metric": "per-field MAPE"},
+    "T4": {"name": "Scen-Ret", "long": "Scenario-Conditioned Return Forecasting",
+           "primary_metric": "Return MAE"},
+    "T5": {"name": "Priv-Val", "long": "Private-Company Valuation",
+           "primary_metric": "MedAPE"},
+    "T6": {"name": "Gen-Eval", "long": "Generator Evaluation",
+           "primary_metric": "per-field MAPE"},
+    "T7": {"name": "RE-Val", "long": "Real-Estate Valuation",
+           "primary_metric": "Rent + Price MAPE"},
+}
+
+
+# ── Method definitions ────────────────────────────────────────────────────
+
+Family = Literal[
+    "naive", "classical", "sequence",
+    "tsfm",
+    "llm_ts",
+    "llm",
+]
+
+
+@dataclass(frozen=True)
+class Method:
+    """Single entry in the baseline panel."""
+    id: str                        # e.g. "persistence", "chronos2_zs"
+    name: str                      # display name, e.g. "Persistence"
+    family: Family
+    tasks: frozenset[Task]         # tasks this method runs on
+    hf_id: str | None = None       # HuggingFace repo id (for LLM/TSFM)
+    notes: str = ""                # free-form context (size, quant, TP)
+
+
+# ── Family 1: Naive (4 methods) ───────────────────────────────────────────
+# Deterministic heuristics and non-parametric lookups (no fitted parameters).
+
+NAIVE_METHODS: tuple[Method, ...] = (
+    Method("persistence", "Persistence", "naive",
+           frozenset({"T1"}),
+           notes="Repeat last close (T1); repeat pre-event level (T4)."),
+    Method("sector_median", "Sector-Median", "naive",
+           frozenset({"T3", "T6"}),
+           notes="Predict each XBRL field as its sector median."),
+    Method("metro_median", "Metro-Median", "naive",
+           frozenset({"T7"}),
+           notes="Median rent/price in the same metro."),
+    Method("historical_analogue", "Historical Analogue", "naive",
+           frozenset({"T4"}),
+           notes="Find nearest past scenario by type; reuse its post-event return."),
+)
+
+
+# ── Family 2: Classical ML (2 methods) ────────────────────────────────────
+# Fitted parametric models (OLS regression, gradient-boosted trees).
+
+CLASSICAL_METHODS: tuple[Method, ...] = (
+    Method("random_forest", "RandomForest", "classical",
+           frozenset(ALL_TASKS),
+           notes="200 trees, max_depth=16, min_samples_leaf=5; sklearn RandomForestRegressor with per-task adapters mirroring LightGBM (log-return target on T1, log-target pipeline on T2/T5/T7, sparse field one-hot on T3/T6, flatten+event-type one-hot on T4)."),
+    Method("lightgbm", "LightGBM", "classical",
+           frozenset(ALL_TASKS),
+           notes=(
+               "300 trees, num_leaves=63, histogram binning; trained on "
+               "137-feature panel. Chosen over XGBoost for 2-5x training "
+               "speedup with essentially identical accuracy on financial "
+               "tabular data."
+           )),
+)
+
+
+# ── Family 3: Deep Sequence (3 methods) ───────────────────────────────────
+
+SEQUENCE_METHODS: tuple[Method, ...] = (
+    Method("dlinear", "DLinear", "sequence",
+           frozenset({"T1", "T4"}),
+           notes="Linear decomposition baseline."),
+    Method("itransformer", "iTransformer", "sequence",
+           frozenset({"T1", "T4"}),
+           notes=(
+               "Inverted transformer (variables-as-tokens); d=128, 4 heads. "
+               "Chosen over PatchTST as the transformer representative: "
+               "its cross-variable attention matches the 137-feature "
+               "multivariate structure of MacroLens better than PatchTST's "
+               "channel-independent formulation."
+           )),
+    Method("moderntcn", "ModernTCN", "sequence",
+           frozenset({"T1", "T4"}),
+           notes="Modern pure-convolution backbone."),
+)
+
+
+# ── Family 4: TSFM Zero-Shot (3 methods) ──────────────────────────────────
+# Sundial was dropped from the panel because its modeling code (HF Hub
+# `thuml/sundial-base-128m`, vendored via `trust_remote_code`) requires
+# transformers==4.40.x and is incompatible with transformers>=4.45 (used here
+# for vLLM 0.20 + Llama-4 / Gemma-4 / Qwen-3.5 FP8 LLMs); the cascade includes
+# DynamicCache.get_usable_length removal, _prepare_4d_causal_attention_mask
+# shape mismatch under Sundial's patching, apply_rotary_pos_emb position-id
+# scale mismatch, and TSGenerationMixin._extract_past_from_model_output
+# removal in GenerationMixin >=4.45. Documented and removed rather than
+# patched into a parallel transformers env.
+
+TSFM_ZS_METHODS: tuple[Method, ...] = (
+    Method("chronos2", "Chronos-2", "tsfm",
+           frozenset({"T1"}),
+           hf_id="amazon/chronos-2",
+           notes="Probabilistic multivariate; frozen checkpoint."),
+    Method("moirai2", "Moirai 2.0", "tsfm",
+           frozenset({"T1"}),
+           hf_id="Salesforce/moirai-2.0-R-small",
+           notes="Any-variate universal forecaster."),
+    Method("timesfm", "TimesFM", "tsfm",
+           frozenset({"T1"}),
+           hf_id="google/timesfm-1.0-200m-pytorch",
+           notes=(
+               "Decoder-only foundation; TimesFM 1.0 (200M, 20 transformer "
+               "layers). The 2.0 checkpoint (500M, 50 layers) requires a "
+               "newer `timesfm` package version than the one currently "
+               "installed; revisit once upgraded."
+           )),
+)
+
+
+# ── Family 5: LLM-TS Multi-Task (2 methods) ───────────────────────────────
+# Note: "LLM-TS Forecasting" family (CALF, TimeReasoner) was removed from the
+# panel; the LLM-TS Multi-Task family covers the "LLM adapted for time-series"
+# story across all 7 tasks, subsuming the forecast-only variants.
+
+LLM_TS_MULTITASK_METHODS: tuple[Method, ...] = (
+    Method("chattime", "ChatTime", "llm_ts",
+           frozenset(ALL_TASKS),
+           notes="LLaMA-2-7B + 10K-bin tokenisation."),
+    Method("time_mqa", "Time-MQA", "llm_ts",
+           frozenset(ALL_TASKS),
+           notes="Mistral-7B + LoRA r=16; 192,843 QA pairs."),
+)
+
+
+# ── LLM models ────────────────────────────────────────────────────────────
+# Paper-canonical Family-6 LLM panel (matches DRAFT.md §5.4 and the
+# canon RunRecord JSONs under experiments/results/). Two of the four
+# entries are OpenRouter-hosted closed-source models; the third
+# (gpt-oss-120B) is open-weights routed via OpenRouter for compute
+# economy; the fourth (Qwen-3.5-27B-FP8) runs locally on 4xA100-40GB.
+# Local-vLLM fields (tensor_parallel_size, quant, prequantized) are
+# meaningful only when ``provider == "local"``; for OpenRouter entries
+# they carry placeholder values.
+
+@dataclass(frozen=True)
+class LLMModel:
+    id: str
+    name: str
+    provider: Literal["local", "openrouter"]
+    hf_id: str | None = None
+    tensor_parallel_size: int = 1
+    quant: Literal["fp8", "bf16"] = "fp8"
+    multimodal: bool = False
+    total_params_b: float | None = None
+    active_params_b: float | None = None
+    ft_strategy: str = "none"
+    prequantized: bool = False
+
+
+LLM_MODELS: tuple[LLMModel, ...] = (
+    LLMModel(
+        id="gpt51",
+        name="GPT-5.1",
+        provider="openrouter",
+        hf_id="openai/gpt-5.1",
+        ft_strategy="none",
+    ),
+    LLMModel(
+        id="gemini3_flash",
+        name="Gemini-3-Flash-Preview",
+        provider="openrouter",
+        hf_id="google/gemini-3-flash-preview",
+        ft_strategy="none",
+    ),
+    LLMModel(
+        id="exaone",
+        name="EXAONE-4.5 32B",
+        provider="local",
+        hf_id="LGAI-EXAONE/EXAONE-4.5-32B-FP8",
+        tensor_parallel_size=4,
+        quant="fp8",
+        total_params_b=32.0,
+        active_params_b=32.0,
+        ft_strategy="qlora_nf4",
+        prequantized=True,
+    ),
+    LLMModel(
+        id="llama_scout",
+        name="Llama-4 Scout 109B",
+        provider="local",
+        hf_id="meta-llama/Llama-4-Scout-17B-16E-Instruct",
+        tensor_parallel_size=4,
+        quant="fp8",
+        multimodal=True,
+        total_params_b=109.0,
+        active_params_b=17.0,
+        ft_strategy="qlora_nf4_zero2",
+        prequantized=False,
+    ),
+    LLMModel(
+        id="qwen35",
+        name="Qwen-3.5-27B-FP8",
+        provider="local",
+        hf_id="Qwen/Qwen3.5-27B-FP8",
+        tensor_parallel_size=1,
+        quant="fp8",
+        multimodal=False,
+        total_params_b=27.0,
+        active_params_b=27.0,
+        ft_strategy="qlora_nf4",
+        prequantized=True,
+    ),
+)
+
+LLM_MODELS_BY_ID: dict[str, LLMModel] = {m.id: m for m in LLM_MODELS}
+
+
+# ── Family 6: LLM Zero-Shot (4 methods) ───────────────────────────────────
+# Method ids match the canon RunRecord JSON ``method_id`` field (no
+# ``_zs`` suffix); family is ``llm`` (not ``llm_zs``).
+
+def _llm_notes(m: LLMModel) -> str:
+    if m.provider == "openrouter":
+        return "OpenRouter API; reasoning tokens disabled."
+    return f"vLLM {m.quant.upper()} inference, TP={m.tensor_parallel_size}."
+
+
+LLM_ZS_METHODS: tuple[Method, ...] = tuple(
+    Method(
+        id=m.id,
+        name=m.name,
+        family="llm",
+        tasks=frozenset(ALL_TASKS),
+        hf_id=m.hf_id,
+        notes=_llm_notes(m),
+    )
+    for m in LLM_MODELS
+)
+
+
+# ── Aggregation ───────────────────────────────────────────────────────────
+# Paper-canonical 18 methods x 6 families. The legacy ``Method``
+# dataclass list aligns with the canon RunRecord JSON ``method_id`` and
+# ``method_family`` fields under ``experiments/results/``.
+
+ALL_METHODS: tuple[Method, ...] = (
+    NAIVE_METHODS
+    + CLASSICAL_METHODS
+    + SEQUENCE_METHODS
+    + TSFM_ZS_METHODS
+    + LLM_TS_MULTITASK_METHODS
+    + LLM_ZS_METHODS
+)
+
+METHODS_BY_ID: dict[str, Method] = {m.id: m for m in ALL_METHODS}
+
+METHODS_BY_FAMILY: dict[Family, tuple[Method, ...]] = {
+    "naive": NAIVE_METHODS,
+    "classical": CLASSICAL_METHODS,
+    "sequence": SEQUENCE_METHODS,
+    "tsfm": TSFM_ZS_METHODS,
+    "llm_ts": LLM_TS_MULTITASK_METHODS,
+    "llm": LLM_ZS_METHODS,
+}
+
+
+def methods_for_task_panel(task: Task) -> tuple[Method, ...]:
+    """All legacy panel ``Method`` dataclasses applicable to a task.
+
+    Retained under a renamed handle so the new registry-driven
+    :func:`methods_for_task` (returning ``list[str]`` of registry ids) is
+    the canonical Phase-4 entry point. Callers that need the panel
+    dataclass (display name, ``hf_id``, ``notes``) keep using this.
+    """
+    return tuple(m for m in ALL_METHODS if task in m.tasks)
+
+
+def methods_for_family(family: Family) -> tuple[Method, ...]:
+    return METHODS_BY_FAMILY[family]
+
+
+# ── Phase-4 unified-API panel helpers ─────────────────────────────────────
+# The orchestrator (``experiments/run_all.py``) consumes the registry-driven
+# 18-method panel rather than the legacy ``Method`` dataclasses above. The
+# helpers below mirror the registry surface so the runner never reaches into
+# ``methods._registry`` directly.
+
+from ..methods._registry import ALL_METHODS as _REGISTRY_METHODS
+
+
+def methods_for_task(task: str) -> list[str]:
+    """Return the sorted list of registered method ids that support ``task``.
+
+    Single source of truth for the Phase-4 runner's "skip methods that do
+    not support this task" filter. Reads directly from
+    :data:`methods._registry.ALL_METHODS`.
+    """
+    return sorted(name for name, cls in _REGISTRY_METHODS.items() if task in cls.tasks)
+
+
+# Canonical 18-method panel (re-derived from the registry every call so
+# additions/removals show up without an explicit panel.py edit).
+PANEL: list[str] = sorted(_REGISTRY_METHODS.keys())
+
+
+# ── Context ablation subset ──────────────────────────────────────────────
+# DRAFT.md §5.4.1: a five-step feature-context ablation (A-E) is run on
+# the panel's two zero-shot frontier LLMs (GPT-5.1, Gemini-3-Flash) on
+# four tasks (T1 at h=252, T2, T4, T5). Running the full A-E factorial
+# across all four LLMs would dominate the wall-clock budget; restricting
+# to the two frontier LLMs preserves the contrast (does adding context
+# channels help the strongest zero-shot models?) while keeping the
+# 2 x 5 x 4 = 40-cell budget tractable.
+
+ABLATION_MODEL_IDS: tuple[str, ...] = ("gpt51", "gemini3_flash")
+
+# The submitted ablation reports zero-shot evaluation only. The FT mode is
+# retained as a deferred-experiment slot; with no FT cells the table
+# generator (gen_tables.gen_tab_ablation) emits a placeholder.
+ABLATION_MODES: tuple[str, ...] = ("ZS",)
+
+# Deferred fine-tune cell (DRAFT.md does not report any FT row in the
+# Family-6 panel; the submitted paper is zero-shot-only across all
+# four LLMs). Kept as an empty tuple so downstream table generators
+# emit the deferred-placeholder branch without crashing.
+LLM_FT_PANEL_HF_IDS: tuple[str, ...] = ()
+
+ABLATION_SETTINGS: dict[str, dict] = {
+    "A": {"name": "OHLCV only", "n_features": 6},
+    "B": {"name": "A + Fundamentals (XBRL + derived)", "n_features": 70},
+    "C": {"name": "B + Macro (FRED + EIA)", "n_features": 123},
+    "D": {"name": "C + Scenario flags", "n_features": 127},
+    "E": {"name": "D + SBERT filing embeddings", "n_features": 511},
+}
+
+ABLATION_TASKS: tuple[Task, ...] = ("T1", "T2", "T4", "T5")
+ABLATION_T1_HORIZON: int = 252
+# DRAFT.md §5.4.1 / Fig. 3 caption: T1 ablation uses h=252 (the longest
+# horizon, where context-channel sensitivity is highest). The other
+# three ablation tasks use their full task-defined targets. T3/T6 are
+# excluded because they use per-field MAPE / success_rate (different
+# metric family); T7 is excluded because RentCast property features
+# don't share the A-E feature space (no XBRL / FRED / scenarios).
+
+
+# ── Seed policy ───────────────────────────────────────────────────────────
+# v1 (initial submission): SINGLE seed = 42 for every method, every task.
+# Bootstrap 95% CI (1000 resamples) on the test set provides per-method
+# variance reporting -- the same approach used by 4 of 7 verified peer
+# benchmarks (Time-MMD NeurIPS D&B 2024, FinTSB 2025, Fin-RATE 2026,
+# SciTS ICLR 2026), all of which were accepted with single-run headline
+# tables. Bootstrap CI captures test-set variance; it does NOT capture
+# training-stochasticity variance.
+#
+# v2 (rebuttal-ready, only fired if reviewer asks): MULTI_SEEDS {42, 123,
+# 456} on HEADLINE_T1_MULTISEED_METHODS at T1 h=21. Rationale for matching
+# the WIT (ICLR 2026) and EDINET-Bench (ICLR 2026) precedent of 3-run mean
+# +/- std on stochastic methods. Estimated rebuttal compute: ~24h on
+# 4xA100-40GB (well within the 2-week NeurIPS rebuttal window). Deferring
+# to rebuttal saves ~410 GPU-h up front and lets us focus initial
+# wall-clock on getting the 20-method panel + 2 deferred FT cells +
+# 40-cell ablation factorial fully working at single seed first.
+
+from .. import config as _config
+
+# Single source of truth: the seed lives in config.BENCHMARK_SEED.
+# panel.PRIMARY_SEED is kept as the import handle that downstream baselines
+# already use, but it MUST stay aligned with config.BENCHMARK_SEED -- the
+# assertion below catches any silent drift.
+PRIMARY_SEED: int = _config.BENCHMARK_SEED
+assert PRIMARY_SEED == _config.BENCHMARK_SEED, (
+    f"panel.PRIMARY_SEED ({PRIMARY_SEED}) drifted from "
+    f"config.BENCHMARK_SEED ({_config.BENCHMARK_SEED})"
+)
+MULTI_SEEDS: tuple[int, ...] = (42, 123, 456)
+
+# Methods that WILL report mean +/- std across MULTI_SEEDS on the headline
+# T1 table IF reviewers request multi-seed during rebuttal. List is locked
+# in code so the rebuttal path is documented; in v1 the seeds_for() helper
+# returns only PRIMARY_SEED.
+# Chosen as the stochastic methods present in the current panel; deterministic
+# methods (naive, classical without re-sampling, TSFM zero-shot with fixed
+# weights) would report a single seed even if multi-seed were enabled.
+HEADLINE_T1_MULTISEED_METHODS: tuple[str, ...] = (
+    "dlinear", "itransformer", "moderntcn",
+    "time_mqa",
+)
+
+# Toggle. v1 = False (single seed everywhere); flip to True during rebuttal
+# to activate multi-seed for HEADLINE_T1_MULTISEED_METHODS at T1 h=21.
+ENABLE_MULTI_SEED: bool = False
+
+
+def seeds_for(method_id: str, task: Task, horizon: int | None = None) -> tuple[int, ...]:
+    """Return the seed list for a method-task pair.
+
+    v1 (initial submission, ENABLE_MULTI_SEED=False): always returns
+    (PRIMARY_SEED,) -- single seed everywhere.
+
+    v2 (rebuttal, ENABLE_MULTI_SEED=True): returns MULTI_SEEDS on the
+    headline T1 subset (method in HEADLINE_T1_MULTISEED_METHODS,
+    task == 'T1', horizon == 21); single seed otherwise.
+    """
+    if (
+        ENABLE_MULTI_SEED
+        and task == "T1"
+        and horizon == 21
+        and method_id in HEADLINE_T1_MULTISEED_METHODS
+    ):
+        return MULTI_SEEDS
+    return (PRIMARY_SEED,)
+
+
+# ── GPU assignment ────────────────────────────────────────────────────────
+# MacroLens runs on GPU IDs 4,5,6,7 on the shared host (last 4 of the 8
+# physical A100-SXM4-40GB). All scripts must respect this;
+# `CUDA_VISIBLE_DEVICES` is set by the runner wrappers.
+# (Memory: project_macrolens_gpus.md)
+
+GPU_IDS: tuple[int, ...] = (4, 5, 6, 7)
+CUDA_VISIBLE_DEVICES_STR: str = ",".join(str(i) for i in GPU_IDS)
+
+
+# ── Summary ───────────────────────────────────────────────────────────────
+
+def summary() -> dict:
+    """Return a small dict summarising the panel for logging / CI assertions."""
+    return {
+        "total_methods": len(ALL_METHODS),
+        "per_family": {f: len(ms) for f, ms in METHODS_BY_FAMILY.items()},
+        "per_task": {t: len(methods_for_task_panel(t)) for t in ALL_TASKS},
+        "ablation_models": len(ABLATION_MODEL_IDS),
+        "ablation_settings": len(ABLATION_SETTINGS),
+        "gpu_ids": list(GPU_IDS),
+        "primary_seed": PRIMARY_SEED,
+        "multi_seeds": list(MULTI_SEEDS),
+        "llm_models": [m.hf_id for m in LLM_MODELS],
+    }
+
+
+if __name__ == "__main__":
+    # Quick sanity check: `python -m baselines.panel`.
+    # Expected total: 18 methods x 6 families (4 naive + 2 classical
+    # + 3 sequence + 3 tsfm + 2 llm_ts + 4 llm) -- matches DRAFT.md §5.4
+    # and the canon RunRecord JSONs under experiments/results/.
+    import json
+    s = summary()
+    assert s["total_methods"] == 18, f"Expected 18 methods, got {s['total_methods']}"
+    assert len(s["per_family"]) == 6, (
+        f"Expected 6 families, got {len(s['per_family'])}"
+    )
+    print(json.dumps(s, indent=2, default=list))
+    print(
+        f"Context ablation: 2 frontier LLMs x A-E x {{T1 h={ABLATION_T1_HORIZON},"
+        f" T2, T4, T5}} = 2 x {len(ABLATION_SETTINGS)}"
+        f" x {len(ABLATION_TASKS)} ="
+        f" {2 * len(ABLATION_SETTINGS) * len(ABLATION_TASKS)} cells"
+        " (DRAFT.md §5.4.1)."
+    )

code/experiments/probes/__init__.py

@@ -0,0 +1,7 @@
+"""Diagnostic probes for MacroLens (contamination, leakage, scenario validation).
+
+Each probe is a standalone driver script that runs without modifying the
+canonical evaluation pipeline. Probes write JSON reports under
+``experiments/probes_output/`` (experiment artifacts, not under
+``data_small_caps/``, which is reserved for raw + derived benchmark data).
+"""

code/experiments/probes/contamination.py

@@ -0,0 +1,280 @@
+"""Contamination probe for LLM baselines in the MacroLens panel.
+
+Reviewer R2 (W2.1) and R3 (W3.11) flag that the test window (2024-09-03 →
+2026-03-31) overlaps current frontier-LLM pretraining cutoffs. This module
+probes per-LLM recall of test-period closing prices, filing dates, and
+major news headlines on the **first half** of the test window
+(2024-09-03 → ~2025-06-30), where contamination risk is concentrated; the
+second half (2025-07 → 2026-03) post-dates every Family-6 model's cutoff
+and is left unprobed (contamination-safe by construction).
+
+The probe is intentionally narrow: it tests *recall*, not *evaluation
+performance*. A model that recalls a specific test-period closing price
+verbatim has seen that price during pretraining; the probe is silent on
+whether the LLM uses that recall on the actual benchmark task.
+
+Usage (no compute is run by importing the module)::
+
+    python -m projects.agent_builder.scripts.whatif_bench.experiments.probes.contamination \\
+        --model-id Qwen/Qwen3.5-27B-FP8 \\
+        --base-url http://localhost:8004/v1 \\
+        --n-samples 200 \\
+        --first-half-end 2025-06-30 \\
+        --seed 42 \\
+        --output experiments/probes_output/contamination_qwen35.json
+
+Per-launch authorisation: this script issues HTTP requests to a vLLM
+endpoint (or OpenRouter); the user must authorise each launch per the
+project's no-unauthorised-runs policy.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import random
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Probe template construction
+# ---------------------------------------------------------------------------
+
+
+_PRICE_PROMPT = (
+    "What was the closing price of ticker {ticker} on {date}? "
+    "This is a factual recall question about U.S. equity markets. "
+    "Respond with a single number representing the closing price in USD, "
+    "or the exact string 'UNKNOWN' if you cannot recall it. "
+    "No commentary, no units, no surrounding text."
+)
+
+
+def _parse_price_response(text: str) -> float | None:
+    """Extract a single float from the response, or None on UNKNOWN/parse fail."""
+    if not text:
+        return None
+    stripped = text.strip()
+    if stripped.upper().startswith("UNKNOWN"):
+        return None
+    # Try the strict path first: response is a single number.
+    try:
+        return float(stripped)
+    except ValueError:
+        pass
+    # Permissive: pick the first float-looking token in the response.
+    matches = re.findall(r"-?\d+(?:\.\d+)?", stripped)
+    if matches:
+        try:
+            return float(matches[0])
+        except ValueError:
+            return None
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Recall scoring
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ProbeOutcome:
+    ticker: str
+    date: str
+    actual: float
+    predicted: float | None
+    relative_error: float | None  # |pred - actual| / actual; None on UNKNOWN/parse-fail
+
+
+def _score_one(actual: float, predicted: float | None) -> float | None:
+    if predicted is None or actual == 0:
+        return None
+    return abs(predicted - actual) / abs(actual)
+
+
+# ---------------------------------------------------------------------------
+# Sampling
+# ---------------------------------------------------------------------------
+
+
+def _load_first_half_panel(
+    panel_path: Path, first_half_end: str,
+) -> pd.DataFrame:
+    """Load the test-window panel restricted to the first half.
+
+    Expected columns: ticker, date, close (or adj_close), plus whatever
+    additional metadata is needed.
+    """
+    df = pd.read_parquet(panel_path, columns=["ticker", "date", "close"])
+    df = df.dropna(subset=["close"])
+    df["date"] = pd.to_datetime(df["date"]).dt.strftime("%Y-%m-%d")
+    return df[df["date"] <= first_half_end].reset_index(drop=True)
+
+
+def _sample_pairs(
+    df: pd.DataFrame, n_samples: int, seed: int,
+) -> pd.DataFrame:
+    rng = np.random.default_rng(seed)
+    idx = rng.choice(len(df), size=min(n_samples, len(df)), replace=False)
+    return df.iloc[idx].reset_index(drop=True)
+
+
+# ---------------------------------------------------------------------------
+# Probe driver
+# ---------------------------------------------------------------------------
+
+
+def probe_closing_prices(
+    *,
+    panel_path: Path,
+    model_id: str,
+    base_url: str,
+    n_samples: int = 200,
+    first_half_end: str = "2025-06-30",
+    seed: int = 42,
+    api_key: str = "EMPTY",
+    recall_tolerance: float = 0.05,
+) -> dict[str, Any]:
+    """Run the closing-price recall probe against a single LLM endpoint.
+
+    Returns a dict with per-instance outcomes and aggregate recall stats.
+    Recall = fraction of samples whose predicted price is within
+    ``recall_tolerance`` of the ground-truth close.
+    """
+    from projects.agent_builder.scripts.whatif_bench.methods._openai_engine import OpenAIEngine
+
+    df = _load_first_half_panel(panel_path, first_half_end)
+    if len(df) == 0:
+        raise RuntimeError(
+            f"first-half panel is empty under filter date {first_half_end}; "
+            f"check the panel at {panel_path}"
+        )
+    samples = _sample_pairs(df, n_samples, seed)
+
+    engine = OpenAIEngine(base_url=base_url, api_key=api_key, model_id=model_id)
+    prompts = [
+        [{"role": "user", "content": _PRICE_PROMPT.format(ticker=row.ticker, date=row.date)}]
+        for row in samples.itertuples(index=False)
+    ]
+    responses = engine.chat_complete_batch(
+        prompts, max_tokens=64, temperature=0.0, top_p=1.0,
+    )
+
+    outcomes: list[ProbeOutcome] = []
+    for row, text in zip(samples.itertuples(index=False), responses, strict=True):
+        predicted = _parse_price_response(text)
+        rel_err = _score_one(row.close, predicted)
+        outcomes.append(ProbeOutcome(
+            ticker=row.ticker,
+            date=row.date,
+            actual=float(row.close),
+            predicted=predicted,
+            relative_error=rel_err,
+        ))
+
+    n = len(outcomes)
+    n_parse = sum(o.predicted is not None for o in outcomes)
+    n_recall = sum(
+        o.relative_error is not None and o.relative_error <= recall_tolerance
+        for o in outcomes
+    )
+
+    return {
+        "model_id": model_id,
+        "base_url": base_url,
+        "panel_path": str(panel_path),
+        "first_half_end": first_half_end,
+        "n_samples": n,
+        "n_parse_success": n_parse,
+        "n_recall_within_tol": n_recall,
+        "recall_rate": n_recall / n if n else 0.0,
+        "parse_rate": n_parse / n if n else 0.0,
+        "recall_tolerance": recall_tolerance,
+        "seed": seed,
+        "outcomes": [asdict(o) for o in outcomes],
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def _default_panel_path() -> Path:
+    from projects.agent_builder.scripts.whatif_bench import config
+
+    base = Path(config.DATA_DIR) if hasattr(config, "DATA_DIR") else (
+        Path(__file__).resolve().parents[2] / "data_small_caps"
+    )
+    return base / "benchmark" / "daily" / "panel_test.parquet"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Contamination probe for LLM baselines (closing-price recall).",
+    )
+    parser.add_argument("--model-id", required=True,
+                        help="HuggingFace identifier or OpenRouter model slug.")
+    parser.add_argument("--base-url", required=True,
+                        help="OpenAI-compatible endpoint URL (e.g., http://localhost:8004/v1).")
+    parser.add_argument("--n-samples", type=int, default=200,
+                        help="Number of (ticker, date) pairs to probe.")
+    parser.add_argument("--first-half-end", default="2025-06-30",
+                        help="Last date (inclusive) of the first-half window.")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY", "EMPTY"))
+    parser.add_argument("--panel-path", type=Path, default=None,
+                        help="Override the default panel parquet path.")
+    parser.add_argument("--recall-tolerance", type=float, default=0.05,
+                        help="Relative-error threshold for counting a sample as 'recalled'.")
+    parser.add_argument("--output", type=Path, required=True,
+                        help="Path to write the JSON probe report.")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+    panel_path = args.panel_path or _default_panel_path()
+    if not panel_path.exists():
+        logger.error("panel path %s does not exist", panel_path)
+        return 2
+
+    report = probe_closing_prices(
+        panel_path=panel_path,
+        model_id=args.model_id,
+        base_url=args.base_url,
+        n_samples=args.n_samples,
+        first_half_end=args.first_half_end,
+        seed=args.seed,
+        api_key=args.api_key,
+        recall_tolerance=args.recall_tolerance,
+    )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2))
+    logger.info(
+        "probe finished: model=%s recall=%.2f%% (%d/%d within %.1f%% tol); parse=%.2f%% (%d/%d); report=%s",
+        args.model_id,
+        100 * report["recall_rate"],
+        report["n_recall_within_tol"],
+        report["n_samples"],
+        100 * report["recall_tolerance"],
+        100 * report["parse_rate"],
+        report["n_parse_success"],
+        report["n_samples"],
+        args.output,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/probes/lightgbm_ablation.py

@@ -0,0 +1,294 @@
+"""LightGBM A->E context-ablation driver (Phase 2.1).
+
+Runs the canonical :class:`LightGBMRegressor` across the five ablation
+settings (A: OHLCV; B: +Fundamentals; C: +Macro; D: +Scenario flags;
+E: +SBERT filing embeddings) on the four ablation tasks (T1 at the
+panel-default horizon, T2, T4, T5). Twenty cells in total at the primary
+seed; library-default LightGBM hyperparameters with no per-cell tuning
+(per project memory: every benchmark cell uses library defaults).
+
+The driver writes per-cell prediction pickles under
+``experiments/predictions/`` using the same tag convention as
+:mod:`experiments.run_all` (``<method>_<task>_seed<seed>_set<setting>.pkl``)
+so a subsequent ``re_evaluate.py`` pass aggregates LightGBM rows into the
+same A->E table that already houses the LLM ablation cells. The driver
+also writes a flat JSON summary report at
+``experiments/probes_output/lightgbm_ablation.json`` with the primary
+metric per cell and cluster-bootstrap 95% CIs.
+
+Per-launch authorisation: this is CPU-only and ~20 fits at moderate
+sample sizes (T1 ~5M panel rows, T2/T5 ~1.3k snapshots, T4 ~4M scenario
+rows); wall-clock estimate is well under one hour on the shared host.
+The user must authorise each launch per the project's no-unauthorised-
+runs policy.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import pickle
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# Primary metric per ablation task (mirrors the convention used by
+# `gen_tables.py` for the LLM ablation column).
+_PRIMARY_METRIC: dict[str, str] = {
+    "T1": "mse",
+    "T2": "medape",
+    "T4": "mae",
+    "T5": "medape",
+}
+
+
+# Cluster-key column per task (cluster_keys argument to ml.score).
+_CLUSTER_KEY: dict[str, str] = {
+    "T1": "ticker",
+    "T2": "ticker",
+    "T4": "scenario_id",
+    "T5": "ticker",
+}
+
+
+@dataclass
+class _CellReport:
+    task: str
+    setting: str
+    horizon: int | None
+    seed: int
+    n_train: int
+    n_test: int
+    primary_metric: str
+    value: float
+    ci_lo: float
+    ci_hi: float
+    fit_sec: float
+    predict_sec: float
+
+
+def _cluster_keys(task: str, meta_test: Any) -> Any:
+    key = _CLUSTER_KEY[task]
+    if hasattr(meta_test, "columns") and key in meta_test.columns:
+        return meta_test[key].values
+    if hasattr(meta_test, "get"):
+        keys = meta_test.get(key)
+        if keys is not None:
+            return np.asarray(keys)
+    return None
+
+
+def _save_predictions(
+    *,
+    pred_dir: Path,
+    method_id: str,
+    task: str,
+    seed: int,
+    setting: str,
+    granularity: str,
+    y_pred: Any,
+    y_test: Any,
+    meta_test: Any,
+) -> Path:
+    pred_dir.mkdir(parents=True, exist_ok=True)
+    tag = f"{method_id}_{task}_seed{seed}_set{setting}"
+    out_path = pred_dir / f"{tag}.pkl"
+    tmp = out_path.with_suffix(".pkl.tmp")
+    with open(tmp, "wb") as f:
+        pickle.dump({
+            "method_id": method_id,
+            "task": task,
+            "seed": seed,
+            "granularity": granularity,
+            "ablation_setting": setting,
+            "y_pred": y_pred,
+            "y_test": y_test,
+            "meta_test": meta_test,
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }, f)
+    tmp.replace(out_path)
+    return out_path
+
+
+def run_cell(
+    *,
+    task: str,
+    setting: str,
+    granularity: str,
+    horizon: int | None,
+    seed: int,
+    pred_dir: Path,
+    method_id: str = "lightgbm",
+) -> _CellReport:
+    """Fit + predict + score a single (task, setting) cell."""
+    import macrolens as ml
+
+    load_kwargs: dict[str, Any] = {"granularity": granularity, "setting": setting}
+    if task == "T1" and horizon is not None:
+        load_kwargs["horizon"] = horizon
+
+    train = ml.load(task, "train", **load_kwargs)
+    test = ml.load(task, "test", **load_kwargs)
+
+    model = ml.methods.LightGBMRegressor(task=task)
+    t0 = time.perf_counter()
+    model.fit(train.X, train.y, seed=seed)
+    fit_sec = time.perf_counter() - t0
+
+    t1 = time.perf_counter()
+    y_pred = model.predict(test.X)
+    predict_sec = time.perf_counter() - t1
+
+    _save_predictions(
+        pred_dir=pred_dir, method_id=method_id, task=task, seed=seed,
+        setting=setting, granularity=granularity,
+        y_pred=y_pred, y_test=test.y, meta_test=test.meta,
+    )
+
+    metrics = ml.score(
+        task, test.y, y_pred,
+        cluster_keys=_cluster_keys(task, test.meta),
+        resample="cluster",
+        n_boot="adaptive",
+        seed=seed,
+    )
+    primary = _PRIMARY_METRIC[task]
+    mv = metrics[primary]
+    return _CellReport(
+        task=task,
+        setting=setting,
+        horizon=horizon if task == "T1" else None,
+        seed=seed,
+        n_train=int(len(train.y)) if hasattr(train.y, "__len__") else -1,
+        n_test=int(len(test.y)) if hasattr(test.y, "__len__") else -1,
+        primary_metric=primary,
+        value=float("nan") if mv.value is None else float(mv.value),
+        ci_lo=float("nan") if mv.ci_lo is None else float(mv.ci_lo),
+        ci_hi=float("nan") if mv.ci_hi is None else float(mv.ci_hi),
+        fit_sec=fit_sec,
+        predict_sec=predict_sec,
+    )
+
+
+def run_ablation(
+    *,
+    tasks: tuple[str, ...] | None = None,
+    settings: tuple[str, ...] | None = None,
+    granularity: str = "daily",
+    horizon: int | None = None,
+    seed: int | None = None,
+    pred_dir: Path | None = None,
+) -> dict[str, Any]:
+    """Drive the full LightGBM A->E ablation grid.
+
+    Defaults match :mod:`experiments.panel`: tasks = ABLATION_TASKS,
+    settings = list(ABLATION_SETTINGS), horizon = ABLATION_T1_HORIZON,
+    seed = PRIMARY_SEED.
+    """
+    from projects.agent_builder.scripts.whatif_bench.experiments import panel
+
+    tasks = tasks or panel.ABLATION_TASKS
+    settings = settings or tuple(panel.ABLATION_SETTINGS.keys())
+    # DRAFT.md (Fig. 3 caption / §5.4.1) reports the ablation at T1 h=252,
+    # not at panel.ABLATION_T1_HORIZON=21. Default to 252 so this driver
+    # produces cells that align with the paper's figure.
+    horizon = horizon if horizon is not None else 252
+    seed = seed if seed is not None else panel.PRIMARY_SEED
+    pred_dir = pred_dir or Path(__file__).resolve().parents[1] / "predictions"
+
+    reports: list[_CellReport] = []
+    for task in tasks:
+        for setting in settings:
+            logger.info("lightgbm ablation: task=%s setting=%s seed=%d horizon=%s",
+                        task, setting, seed, horizon if task == "T1" else "-")
+            try:
+                cell = run_cell(
+                    task=task, setting=setting, granularity=granularity,
+                    horizon=horizon, seed=seed, pred_dir=pred_dir,
+                )
+                reports.append(cell)
+                logger.info("  -> %s=%.6g [%.6g, %.6g]",
+                            cell.primary_metric, cell.value, cell.ci_lo, cell.ci_hi)
+            except Exception as exc:
+                logger.exception("cell failed for task=%s setting=%s: %s",
+                                 task, setting, exc)
+                # Record the failure but keep going; selective per-cell
+                # failures (e.g., missing setting-E SBERT embeddings on a
+                # task) must surface in the JSON report rather than abort
+                # the whole grid.
+                reports.append(_CellReport(
+                    task=task, setting=setting,
+                    horizon=horizon if task == "T1" else None,
+                    seed=seed, n_train=-1, n_test=-1,
+                    primary_metric=_PRIMARY_METRIC[task],
+                    value=float("nan"), ci_lo=float("nan"), ci_hi=float("nan"),
+                    fit_sec=float("nan"), predict_sec=float("nan"),
+                ))
+
+    return {
+        "probe": "lightgbm_ablation",
+        "method_id": "lightgbm",
+        "granularity": granularity,
+        "horizon_T1": horizon,
+        "seed": seed,
+        "tasks": list(tasks),
+        "settings": list(settings),
+        "n_cells": len(reports),
+        "cells": [asdict(r) for r in reports],
+    }
+
+
+def _default_probe_dir() -> Path:
+    # Probe outputs live under experiments/ (experiment artifacts),
+    # never under data_small_caps/ (raw + derived benchmark data).
+    return Path(__file__).resolve().parents[1] / "probes_output"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="LightGBM A->E context-ablation driver.",
+    )
+    parser.add_argument("--granularity", default="daily")
+    parser.add_argument("--tasks", nargs="+", default=None,
+                        help="Tasks to run (default: panel.ABLATION_TASKS).")
+    parser.add_argument("--settings", nargs="+", default=None,
+                        help="Ablation settings to run (default: A B C D E).")
+    parser.add_argument("--horizon", type=int, default=None,
+                        help="T1 horizon (default: 252, matching DRAFT.md Fig. 3 caption).")
+    parser.add_argument("--seed", type=int, default=None,
+                        help="Seed (default: panel.PRIMARY_SEED).")
+    parser.add_argument("--pred-dir", type=Path, default=None,
+                        help="Override the per-cell predictions directory.")
+    parser.add_argument("--output", type=Path, default=None,
+                        help="Path to the summary JSON report.")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    report = run_ablation(
+        tasks=tuple(args.tasks) if args.tasks else None,
+        settings=tuple(args.settings) if args.settings else None,
+        granularity=args.granularity,
+        horizon=args.horizon,
+        seed=args.seed,
+        pred_dir=args.pred_dir,
+    )
+
+    out_path = args.output or _default_probe_dir() / "lightgbm_ablation.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(report, indent=2, default=str))
+    logger.info("ablation report written to %s", out_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/probes/lightgbm_tuned.py

@@ -0,0 +1,276 @@
+"""LightGBM tuning fairness probe (Phase 2.5).
+
+Reviewer R1 (W1.5 / Q1.3) and R2 (W2.3) ask whether the headline finding
+"classical models lead long-horizon T1 forecasting" survives if LightGBM
+is tuned rather than run at library defaults. The canonical Table 6
+LightGBM row remains at library defaults per the project's no-tuning
+rule (every method in the benchmark panel uses library defaults; see
+project memory `feedback_use_library_defaults.md`). This probe is
+**outside the panel** -- it is a one-time secondary analysis whose only
+purpose is to answer the reviewers' fairness question: does a modest
+hyperparameter sweep change the leaderboard?
+
+Design: a small 3 x 3 x 2 = 18-cell grid
+
+    n_estimators ∈ {100, 500, 1000}
+    max_depth    ∈ {6, 10, 20}
+    learning_rate ∈ {0.01, 0.1}
+
+All other LightGBM settings are kept at library defaults. The grid is
+run on T1 at the panel's headline T1 horizon (read from
+``experiments.panel``). For every cell we save predictions under a
+distinct tag (so the probe never overwrites the canonical run) and
+record the primary T1 metric with cluster-bootstrap CIs. The summary
+report names the best cell, the default-config cell, and the relative
+delta -- this is what the camera-ready text quotes back when explaining
+the LightGBM-vs-LLM contrast.
+
+Per-launch authorisation: this is CPU-only and 18 fits on T1's full
+panel (~5M rows). Wall-clock estimate is several hours on the shared
+host; the user must authorise the launch.
+"""
+
+from __future__ import annotations
+
+import argparse
+import itertools
+import json
+import logging
+import pickle
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# Grid as specified by the plan; deliberately modest so the wall-clock
+# stays under one human-day on the shared CPU host.
+_GRID_N_ESTIMATORS: tuple[int, ...] = (100, 500, 1000)
+_GRID_MAX_DEPTH: tuple[int, ...] = (6, 10, 20)
+_GRID_LEARNING_RATE: tuple[float, ...] = (0.01, 0.1)
+
+
+@dataclass
+class _GridCell:
+    n_estimators: int
+    max_depth: int
+    learning_rate: float
+    seed: int
+    horizon: int
+    n_train: int
+    n_test: int
+    primary_metric: str
+    value: float
+    ci_lo: float
+    ci_hi: float
+    fit_sec: float
+    predict_sec: float
+    is_default: bool
+
+
+def _build_config(
+    *, n_estimators: int, max_depth: int, learning_rate: float,
+) -> Any:
+    """Construct a ``LightGBMConfig`` with all other fields at defaults."""
+    from projects.agent_builder.scripts.whatif_bench.methods._config import (
+        LightGBMConfig,
+    )
+    cfg = LightGBMConfig()
+    cfg.n_estimators = n_estimators
+    cfg.max_depth = max_depth
+    cfg.learning_rate = learning_rate
+    return cfg
+
+
+def _is_default_cell(n_estimators: int, max_depth: int, learning_rate: float) -> bool:
+    from projects.agent_builder.scripts.whatif_bench.methods._config import (
+        LightGBMConfig,
+    )
+    d = LightGBMConfig()
+    # max_depth default is -1 (unlimited); the grid uses positive depths
+    # only, so the default cell is never exactly reproduced by the grid.
+    # Flag the conventional "closest to default" cell instead, which is
+    # n=100, lr=0.1, max_depth=the largest grid value (closest proxy to
+    # the unlimited default).
+    return (
+        n_estimators == d.n_estimators
+        and learning_rate == d.learning_rate
+        and max_depth == max(_GRID_MAX_DEPTH)
+    )
+
+
+def _save_predictions(
+    *,
+    pred_dir: Path,
+    method_id: str,
+    task: str,
+    seed: int,
+    cell_tag: str,
+    granularity: str,
+    y_pred: Any,
+    y_test: Any,
+    meta_test: Any,
+) -> Path:
+    pred_dir.mkdir(parents=True, exist_ok=True)
+    tag = f"{method_id}_{task}_seed{seed}_{cell_tag}"
+    out_path = pred_dir / f"{tag}.pkl"
+    tmp = out_path.with_suffix(".pkl.tmp")
+    with open(tmp, "wb") as f:
+        pickle.dump({
+            "method_id": method_id,
+            "task": task,
+            "seed": seed,
+            "granularity": granularity,
+            "cell_tag": cell_tag,
+            "y_pred": y_pred,
+            "y_test": y_test,
+            "meta_test": meta_test,
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }, f)
+    tmp.replace(out_path)
+    return out_path
+
+
+def run_grid(
+    *,
+    horizon: int | None = None,
+    seed: int | None = None,
+    granularity: str = "daily",
+    pred_dir: Path | None = None,
+) -> dict[str, Any]:
+    """Sweep the 18-cell grid on T1 at the headline horizon.
+
+    Returns a dict with one record per cell plus a flagged best cell.
+    """
+    import macrolens as ml
+    from projects.agent_builder.scripts.whatif_bench.experiments import panel
+
+    # Match DRAFT.md (Fig. 3 caption): T1 ablation horizon is 252, not the
+    # panel.ABLATION_T1_HORIZON=21 used for the analyst-rebalancing view.
+    horizon = horizon if horizon is not None else 252
+    seed = seed if seed is not None else panel.PRIMARY_SEED
+    pred_dir = pred_dir or Path(__file__).resolve().parents[1] / "predictions"
+
+    train = ml.load("T1", "train", granularity=granularity, horizon=horizon)
+    test = ml.load("T1", "test", granularity=granularity, horizon=horizon)
+
+    cells: list[_GridCell] = []
+    for n_est, max_d, lr in itertools.product(
+        _GRID_N_ESTIMATORS, _GRID_MAX_DEPTH, _GRID_LEARNING_RATE,
+    ):
+        cell_tag = f"grid_n{n_est}_d{max_d}_lr{lr:.3g}".replace(".", "p")
+        logger.info("grid cell: n=%d depth=%d lr=%.3g  (tag=%s)",
+                    n_est, max_d, lr, cell_tag)
+        cfg = _build_config(
+            n_estimators=n_est, max_depth=max_d, learning_rate=lr,
+        )
+        model = ml.methods.LightGBMRegressor(task="T1", config=cfg)
+        t0 = time.perf_counter()
+        model.fit(train.X, train.y, seed=seed)
+        fit_sec = time.perf_counter() - t0
+        t1 = time.perf_counter()
+        y_pred = model.predict(test.X)
+        predict_sec = time.perf_counter() - t1
+
+        _save_predictions(
+            pred_dir=pred_dir, method_id="lightgbm_tuned", task="T1",
+            seed=seed, cell_tag=cell_tag, granularity=granularity,
+            y_pred=y_pred, y_test=test.y, meta_test=test.meta,
+        )
+
+        cluster_keys = None
+        if hasattr(test.meta, "columns") and "ticker" in test.meta.columns:
+            cluster_keys = test.meta["ticker"].values
+        metrics = ml.score(
+            "T1", test.y, y_pred,
+            cluster_keys=cluster_keys, resample="cluster",
+            n_boot="adaptive", seed=seed,
+        )
+        mv = metrics["mse"]
+        value = float("nan") if mv.value is None else float(mv.value)
+        ci_lo = float("nan") if mv.ci_lo is None else float(mv.ci_lo)
+        ci_hi = float("nan") if mv.ci_hi is None else float(mv.ci_hi)
+
+        cells.append(_GridCell(
+            n_estimators=n_est, max_depth=max_d, learning_rate=lr,
+            seed=seed, horizon=horizon,
+            n_train=int(len(train.y)) if hasattr(train.y, "__len__") else -1,
+            n_test=int(len(test.y)) if hasattr(test.y, "__len__") else -1,
+            primary_metric="mse", value=value, ci_lo=ci_lo, ci_hi=ci_hi,
+            fit_sec=fit_sec, predict_sec=predict_sec,
+            is_default=_is_default_cell(n_est, max_d, lr),
+        ))
+        logger.info("  -> mse=%.4g [%.4g, %.4g]", value, ci_lo, ci_hi)
+
+    # Identify the best (minimum) cell by primary metric.
+    finite = [c for c in cells if np.isfinite(c.value)]
+    best = min(finite, key=lambda c: c.value) if finite else None
+    default = next((c for c in cells if c.is_default), None)
+    delta = (
+        (default.value - best.value) / abs(default.value)
+        if (best is not None and default is not None and default.value != 0)
+        else None
+    )
+
+    return {
+        "probe": "lightgbm_tuned",
+        "method_id": "lightgbm_tuned",
+        "task": "T1",
+        "granularity": granularity,
+        "horizon": horizon,
+        "seed": seed,
+        "grid": {
+            "n_estimators": list(_GRID_N_ESTIMATORS),
+            "max_depth": list(_GRID_MAX_DEPTH),
+            "learning_rate": list(_GRID_LEARNING_RATE),
+        },
+        "best_cell": asdict(best) if best is not None else None,
+        "default_proxy_cell": asdict(default) if default is not None else None,
+        "relative_improvement_over_default": delta,
+        "cells": [asdict(c) for c in cells],
+    }
+
+
+def _default_probe_dir() -> Path:
+    # Probe outputs live under experiments/ (experiment artifacts),
+    # never under data_small_caps/ (raw + derived benchmark data).
+    return Path(__file__).resolve().parents[1] / "probes_output"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="LightGBM tuning fairness probe (fairness check; NOT in panel).",
+    )
+    parser.add_argument("--granularity", default="daily")
+    parser.add_argument("--horizon", type=int, default=None,
+                        help="T1 horizon (default: 252, matching DRAFT.md Fig. 3 caption).")
+    parser.add_argument("--seed", type=int, default=None,
+                        help="Seed (default: panel.PRIMARY_SEED).")
+    parser.add_argument("--pred-dir", type=Path, default=None,
+                        help="Override the per-cell predictions directory.")
+    parser.add_argument("--output", type=Path, default=None,
+                        help="Path to the summary JSON report.")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    report = run_grid(
+        horizon=args.horizon, seed=args.seed,
+        granularity=args.granularity, pred_dir=args.pred_dir,
+    )
+
+    out_path = args.output or _default_probe_dir() / "lightgbm_tuned.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(report, indent=2, default=str))
+    logger.info("tuned-grid report written to %s", out_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/probes/llm_finetune_qwen.py

@@ -0,0 +1,476 @@
+"""Qwen-3.5-27B QLoRA fine-tune driver for the deferred Family-7 slot.
+
+Plan reference: Phase 3.1 (R1 Q1.3, R2 Q2.4, R3 W3.4 saturation, R5 W5.1;
+author A2). T3 and T6 saturate near 100% MAPE for every zero-shot LLM
+in the panel; they are the cleanest demonstration target for whether
+MacroLens supports supervised LLM training. This driver populates the
+single deferred Family-7 column in Tables 6-10.
+
+Design choices (orthodox interpretation of the existing
+:mod:`methods.llm_finetune` infrastructure):
+
+* **Per-task adapters.** :class:`methods.LLMFineTuned` fixes ``self.task``
+  at construction and dispatches on it; we therefore train TWO adapters,
+  one for T3 and one for T6, rather than one bundled multi-task adapter.
+  Both tasks share the same JSON output schema (11 canonical XBRL
+  fields); the per-task split keeps the prompt format precisely matched
+  to each task. This is the simplest configuration that uses the
+  existing class as-is.
+* **Cross-task transfer.** The T3 adapter is evaluated zero-shot on
+  T1 / T2 / T4 / T5 / T7 as a catastrophic-forgetting check: if a single
+  task's QLoRA pass leaves the model's competence on other tasks intact,
+  the result-table column can be populated end-to-end; otherwise the
+  cross-task entries become Family-7 / not-applicable.
+* **Library defaults.** ``LLMFineTunedConfig`` ships with
+  ``lora_r=16, lora_alpha=32, epochs=3, learning_rate=2e-4`` -- this
+  is what the panel-FT recipe was originally pre-registered to use. We
+  do not vary any of those four numbers in this driver, per the
+  no-tuning rule.
+* **Single seed.** ``panel.PRIMARY_SEED = 42`` end-to-end.
+
+Per-launch authorisation: this is a multi-hour GPU run (4 x A100-40GB,
+GPU IDs 4-7 per project memory). The user must authorise the launch.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import pickle
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# Tasks evaluated by the trained adapters. Native-task targets are
+# the rows that directly populate the Family-7 column; cross-task
+# targets test for catastrophic forgetting.
+_NATIVE_TASKS: tuple[str, ...] = ("T3", "T6")
+_CROSS_TASKS: tuple[str, ...] = ("T1", "T2", "T4", "T5", "T7")
+
+
+# Primary metric per task (mirrors gen_tables.py conventions).
+_PRIMARY_METRIC: dict[str, str] = {
+    "T1": "mse",
+    "T2": "medape",
+    "T3": "mape",
+    "T4": "mae",
+    "T5": "medape",
+    "T6": "mape",
+    "T7": "mape",
+}
+
+
+_CLUSTER_KEY: dict[str, str] = {
+    "T1": "ticker",
+    "T2": "ticker",
+    "T3": "ticker",
+    "T4": "scenario_id",
+    "T5": "ticker",
+    "T6": "ticker",
+    "T7": "address",
+}
+
+
+@dataclass
+class _EvalCell:
+    adapter_task: str
+    eval_task: str
+    is_native: bool
+    seed: int
+    n_test: int
+    primary_metric: str
+    value: float
+    ci_lo: float
+    ci_hi: float
+    fit_sec: float | None
+    predict_sec: float
+
+
+def _cluster_keys(task: str, meta_test: Any) -> Any:
+    key = _CLUSTER_KEY[task]
+    if hasattr(meta_test, "columns") and key in meta_test.columns:
+        return meta_test[key].values
+    if hasattr(meta_test, "get"):
+        keys = meta_test.get(key)
+        if keys is not None:
+            return np.asarray(keys)
+    return None
+
+
+def _save_predictions(
+    *,
+    pred_dir: Path,
+    method_id: str,
+    task: str,
+    seed: int,
+    granularity: str,
+    y_pred: Any,
+    y_test: Any,
+    meta_test: Any,
+    extra_tag: str | None = None,
+) -> Path:
+    pred_dir.mkdir(parents=True, exist_ok=True)
+    tag = f"{method_id}_{task}_seed{seed}"
+    if extra_tag:
+        tag += f"_{extra_tag}"
+    out_path = pred_dir / f"{tag}.pkl"
+    tmp = out_path.with_suffix(".pkl.tmp")
+    with open(tmp, "wb") as f:
+        pickle.dump({
+            "method_id": method_id,
+            "task": task,
+            "seed": seed,
+            "granularity": granularity,
+            "y_pred": y_pred,
+            "y_test": y_test,
+            "meta_test": meta_test,
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }, f)
+    tmp.replace(out_path)
+    return out_path
+
+
+def _engine_for_adapter(
+    *, base_hf_id: str, adapter_path: Path, base_url: str, api_key: str,
+) -> Any:
+    """Build an OpenAI-compatible engine targeting the vLLM-served adapter.
+
+    The runner exposes the adapter as a LoRA module via:
+
+        vllm serve <base_hf_id> --enable-lora \\
+            --lora-modules adapter_qwen35_t3=<adapter_path>
+
+    so ``model_id`` resolves to the LoRA name, not the base HF id.
+    """
+    from projects.agent_builder.scripts.whatif_bench.methods._openai_engine import (
+        OpenAIEngine,
+    )
+    return OpenAIEngine(
+        base_url=base_url, api_key=api_key,
+        model_id=str(adapter_path.name),  # vLLM LoRA module id is the dir name
+    )
+
+
+def train_adapter(
+    *,
+    task: str,
+    base_model: str = "qwen35",
+    granularity: str = "daily",
+    seed: int = 42,
+    adapter_dir: Path,
+) -> tuple[Path, float]:
+    """Train a single-task QLoRA adapter using :class:`LLMFineTuned`.
+
+    Returns ``(adapter_path, fit_sec)``.
+    """
+    from projects.agent_builder.scripts.whatif_bench import macrolens as ml
+    from projects.agent_builder.scripts.whatif_bench.methods.llm_finetune import (
+        LLMFineTuned,
+    )
+    from projects.agent_builder.scripts.whatif_bench.methods._config import (
+        LLMFineTunedConfig,
+    )
+
+    train = ml.load(task, "train", granularity=granularity)
+
+    cfg = LLMFineTunedConfig()  # library-default lora_r / lora_alpha / epochs / lr
+    model = LLMFineTuned(task=task, config=cfg, base_model=base_model)
+
+    t0 = time.perf_counter()
+    model.fit(train.X, train.y, seed=seed)
+    fit_sec = time.perf_counter() - t0
+
+    adapter_dir.mkdir(parents=True, exist_ok=True)
+    out_path = adapter_dir / f"qwen35_qlora_{task.lower()}"
+    model.save(out_path)
+    logger.info("trained %s adapter -> %s (fit %.1fs)", task, out_path, fit_sec)
+    return out_path, fit_sec
+
+
+# [REVERTED 2026-05-19] An earlier in-session draft of
+# ``train_multitask_adapter`` was inserted here but used
+# ``device_map="auto"`` + bnb-4bit on Llama-4 Scout MoE, which
+# RESEARCH_PLAN.md §5.1 + IMPLEMENTATION_PLAN.md §F7 explicitly call
+# out as the documented "MoE-on-bitsandbytes complexity" failure mode
+# (Scout needs ZeRO-2 across 4 GPUs, not naive auto-placement). The
+# draft was reverted so the canonical sources (Llama-4 Scout HF card,
+# Meta torchtune SFT example, HF PEFT MoE docs, TRL response-only-loss
+# docs, DeepSpeed ZeRO-2 config) can be read end-to-end first and a
+# verified recipe written rather than improvised.
+
+
+def evaluate_with_adapter(
+    *,
+    adapter_path: Path,
+    adapter_task: str,
+    eval_task: str,
+    base_hf_id: str,
+    base_url: str,
+    api_key: str,
+    granularity: str,
+    seed: int,
+    pred_dir: Path,
+    fit_sec: float | None,
+) -> _EvalCell:
+    """Evaluate an adapter on ``eval_task``.
+
+    For native eval (``eval_task == adapter_task``) the predict path is
+    the task-native predict path on :class:`LLMFineTuned`. For cross-task
+    eval we still use :class:`LLMFineTuned` so the prompt formatting is
+    consistent with the panel's other LLM-FT cells; the adapter is
+    loaded fresh, then ``model.task`` is overridden to ``eval_task`` so
+    the right per-task predict path runs.
+    """
+    from projects.agent_builder.scripts.whatif_bench import macrolens as ml
+    from projects.agent_builder.scripts.whatif_bench.methods.llm_finetune import (
+        LLMFineTuned,
+    )
+
+    engine = _engine_for_adapter(
+        base_hf_id=base_hf_id, adapter_path=adapter_path,
+        base_url=base_url, api_key=api_key,
+    )
+
+    test = ml.load(eval_task, "test", granularity=granularity)
+    model = LLMFineTuned.load(adapter_path)
+    # ``LLMFineTuned.load`` reconstructs at the trained-task. Force the
+    # task for cross-eval; the trained QLoRA adapter is unchanged.
+    model.task = eval_task
+    model.engine = engine
+
+    t1 = time.perf_counter()
+    y_pred = model.predict(test.X)
+    predict_sec = time.perf_counter() - t1
+
+    _save_predictions(
+        pred_dir=pred_dir,
+        method_id="llm_finetuned_qwen35",
+        task=eval_task,
+        seed=seed,
+        granularity=granularity,
+        y_pred=y_pred,
+        y_test=test.y,
+        meta_test=test.meta,
+        extra_tag=(
+            None if eval_task == adapter_task
+            else f"transfer_from_{adapter_task}"
+        ),
+    )
+
+    metrics = ml.score(
+        eval_task, test.y, y_pred,
+        cluster_keys=_cluster_keys(eval_task, test.meta),
+        resample="cluster", n_boot="adaptive", seed=seed,
+    )
+    primary = _PRIMARY_METRIC[eval_task]
+    mv = metrics[primary]
+    value = float("nan") if mv.value is None else float(mv.value)
+    ci_lo = float("nan") if mv.ci_lo is None else float(mv.ci_lo)
+    ci_hi = float("nan") if mv.ci_hi is None else float(mv.ci_hi)
+
+    return _EvalCell(
+        adapter_task=adapter_task,
+        eval_task=eval_task,
+        is_native=(eval_task == adapter_task),
+        seed=seed,
+        n_test=int(len(test.y)) if hasattr(test.y, "__len__") else -1,
+        primary_metric=primary,
+        value=value,
+        ci_lo=ci_lo,
+        ci_hi=ci_hi,
+        fit_sec=fit_sec if eval_task == adapter_task else None,
+        predict_sec=predict_sec,
+    )
+
+
+def run_pipeline(
+    *,
+    base_url: str | None,
+    api_key: str = "EMPTY",
+    base_model: str = "qwen35",
+    granularity: str = "daily",
+    seed: int | None = None,
+    adapter_dir: Path | None = None,
+    pred_dir: Path | None = None,
+    eval_native_only: bool = False,
+    train_only: bool = False,
+    multitask: bool = False,
+) -> dict[str, Any]:
+    """End-to-end pipeline: train (T3, T6) adapters then evaluate.
+
+    Two-pass: (i) train each native-task adapter; (ii) evaluate each
+    adapter on its native task plus the cross-task panel (T3 adapter
+    only, to keep the GPU budget bounded).
+    """
+    from projects.agent_builder.scripts.whatif_bench.experiments import panel
+    from projects.agent_builder.scripts.whatif_bench.methods.llm_finetune import (
+        _BASE_MODEL_ID,
+    )
+
+    seed = seed if seed is not None else panel.PRIMARY_SEED
+    adapter_dir = adapter_dir or Path(__file__).resolve().parents[1] / "adapters"
+    pred_dir = pred_dir or Path(__file__).resolve().parents[1] / "predictions"
+
+    base_hf_id = _BASE_MODEL_ID.get(base_model)
+    if base_hf_id is None:
+        raise ValueError(f"unknown base_model {base_model!r}; "
+                         f"expected one of {sorted(_BASE_MODEL_ID)}")
+
+    if multitask:
+        raise NotImplementedError(
+            "multitask=True was reverted on 2026-05-19 pending re-read of "
+            "Llama-4 Scout / DeepSpeed ZeRO-2 / PEFT-MoE primary sources. "
+            "See header comment near the reverted train_multitask_adapter "
+            "block."
+        )
+    # (i) Train adapters.
+    adapters: dict[str, tuple[Path, float]] = {}
+    multitask_pair_counts: dict[str, int] = {}
+    for task in _NATIVE_TASKS:
+        adapter_path, fit_sec = train_adapter(
+            task=task, base_model=base_model, granularity=granularity,
+            seed=seed, adapter_dir=adapter_dir,
+        )
+        adapters[task] = (adapter_path, fit_sec)
+
+    # Train-only short-circuit: skip the eval phase entirely. Used to
+    # separate the long-running QLoRA training step from the eval step,
+    # which requires a separately-orchestrated vLLM serve endpoint.
+    if train_only:
+        return {
+            "probe": "llm_finetune_scout_multitask" if multitask else "llm_finetune_qwen35",
+            "base_model": base_model,
+            "base_hf_id": base_hf_id,
+            "granularity": granularity,
+            "seed": seed,
+            "multitask": multitask,
+            "multitask_pair_counts": multitask_pair_counts,
+            "adapters": {
+                task: {"path": str(path), "fit_sec": fs}
+                for task, (path, fs) in adapters.items()
+            },
+            "cells": [],
+            "train_only": True,
+        }
+
+    if base_url is None:
+        raise ValueError(
+            "run_pipeline: --base-url required when --train-only is not set "
+            "(eval needs a vLLM serve endpoint serving the trained adapters)."
+        )
+
+    # (ii) Evaluate. Native-task eval per adapter; cross-task eval uses
+    # the T3 adapter only (T3 train is ~7x the size of T6 train and
+    # produces the more general checkpoint).
+    cells: list[_EvalCell] = []
+    for adapter_task, (adapter_path, fit_sec) in adapters.items():
+        cell = evaluate_with_adapter(
+            adapter_path=adapter_path, adapter_task=adapter_task,
+            eval_task=adapter_task, base_hf_id=base_hf_id,
+            base_url=base_url, api_key=api_key, granularity=granularity,
+            seed=seed, pred_dir=pred_dir, fit_sec=fit_sec,
+        )
+        cells.append(cell)
+
+    if not eval_native_only:
+        t3_path, _ = adapters["T3"]
+        for cross in _CROSS_TASKS:
+            try:
+                cell = evaluate_with_adapter(
+                    adapter_path=t3_path, adapter_task="T3",
+                    eval_task=cross, base_hf_id=base_hf_id,
+                    base_url=base_url, api_key=api_key,
+                    granularity=granularity, seed=seed,
+                    pred_dir=pred_dir, fit_sec=None,
+                )
+                cells.append(cell)
+            except Exception as exc:
+                logger.exception("cross-task eval %s failed: %s", cross, exc)
+                cells.append(_EvalCell(
+                    adapter_task="T3", eval_task=cross, is_native=False,
+                    seed=seed, n_test=-1,
+                    primary_metric=_PRIMARY_METRIC[cross],
+                    value=float("nan"), ci_lo=float("nan"), ci_hi=float("nan"),
+                    fit_sec=None, predict_sec=float("nan"),
+                ))
+
+    return {
+        "probe": "llm_finetune_qwen35",
+        "base_model": base_model,
+        "base_hf_id": base_hf_id,
+        "base_url": base_url,
+        "granularity": granularity,
+        "seed": seed,
+        "adapters": {
+            task: {
+                "path": str(path),
+                "fit_sec": fs,
+            }
+            for task, (path, fs) in adapters.items()
+        },
+        "cells": [asdict(c) for c in cells],
+    }
+
+
+def _default_probe_dir() -> Path:
+    # Probe outputs live under experiments/ (experiment artifacts),
+    # never under data_small_caps/ (raw + derived benchmark data).
+    return Path(__file__).resolve().parents[1] / "probes_output"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Qwen-3.5-27B QLoRA fine-tune driver (Phase 3.1).",
+    )
+    parser.add_argument("--base-url", default=None,
+                        help="vLLM OpenAI-compatible endpoint (e.g., http://localhost:8004/v1). "
+                             "Required unless --train-only is set.")
+    parser.add_argument("--api-key", default="EMPTY")
+    parser.add_argument("--base-model", default="qwen35",
+                        choices=["llama_scout", "gemma4", "qwen35"])
+    parser.add_argument("--granularity", default="daily")
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument("--adapter-dir", type=Path, default=None)
+    parser.add_argument("--pred-dir", type=Path, default=None)
+    parser.add_argument("--eval-native-only", action="store_true",
+                        help="Skip cross-task transfer eval (T1/T2/T4/T5/T7).")
+    parser.add_argument("--train-only", action="store_true",
+                        help="Train adapters and exit; skip the eval phase "
+                             "(which requires a vLLM serve endpoint).")
+    parser.add_argument("--multitask", action="store_true",
+                        help="Train ONE adapter on a pooled corpus over all "
+                             "7 task train splits (T1..T7). Default is the "
+                             "per-task design (T3+T6 only with cross-task "
+                             "eval). Recommended for Phase 3.1 Family-7.")
+    parser.add_argument("--output", type=Path, default=None,
+                        help="Path to the summary JSON report.")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    report = run_pipeline(
+        base_url=args.base_url, api_key=args.api_key,
+        base_model=args.base_model, granularity=args.granularity,
+        seed=args.seed, adapter_dir=args.adapter_dir,
+        pred_dir=args.pred_dir, eval_native_only=args.eval_native_only,
+        train_only=args.train_only, multitask=args.multitask,
+    )
+
+    out_path = args.output or _default_probe_dir() / "llm_finetune_qwen35.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(report, indent=2, default=str))
+    logger.info("fine-tune report written to %s", out_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/probes/scenario_validation.py

@@ -0,0 +1,615 @@
+"""Scenario-layer validation probes for MacroLens (R1 + R2 path-to-5).
+
+Three independent sub-probes, each writing a JSON report under
+``experiments/probes_output/``. No probe modifies the canonical
+``scenarios.parquet``; the canonical artifact is always re-detected at
+default thresholds and treated as ground truth for sub-probe (a).
+
+(a) **Threshold sensitivity.** Re-detect scenarios with every
+    ``SCENARIO_*`` threshold scaled by ``{-50%, -25%, 0%, +25%, +50%}``;
+    report per-setting total event count, per-event-type counts, and the
+    Spearman rank correlation of per-event-type frequencies against the
+    default setting.
+
+(b) **External-calendar comparison.** Compare detected ``fed_rate_change``
+    events against the public FOMC announcement calendar, ``cpi_shock``
+    events against BLS CPI release dates, and ``payrolls_shock`` against
+    BLS Employment Situation release dates, all over 2021-01-04 →
+    2026-03-31. Precision and recall are reported with a ±5 trading-day
+    matching window (release dates often resolve into the closest market
+    close after the announcement).
+
+(c) **Manual-validation template.** Sample 100 scenarios stratified by
+    event type and emit a JSON template with four rater columns; the
+    template is filled offline by the authors. The driver also includes
+    an aggregation function that reads back a populated template and
+    produces inter-rater agreement (Fleiss' kappa) and per-category
+    accuracy when at least three of four raters agree.
+
+Per-launch authorisation: sub-probe (a) reads FRED / EIA caches and
+re-runs the detection pipeline (CPU-only, ~5 minutes total). Sub-probes
+(b) and (c) read ``scenarios.parquet`` only. The user must authorise each
+launch per the project's no-unauthorised-runs policy.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import logging
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# (a) Threshold sensitivity
+# ---------------------------------------------------------------------------
+
+
+# Threshold constants to scale. Each entry is a ``SCENARIO_*`` attribute in
+# ``config.py`` that is a numeric magnitude (deltas, percentage changes,
+# spike ratios above 1, drawdown fractions, z-score thresholds). Constants
+# whose default value is zero (e.g., ``SCENARIO_YIELD_CURVE_INVERSION`` =
+# 0, ``SCENARIO_NFCI_THRESHOLD`` = 0) are excluded because scaling has no
+# effect on a zero crossing. Boolean / window / day-count constants are
+# also excluded (scaling a window-length does not represent a
+# threshold-sensitivity question).
+_THRESHOLD_KEYS: tuple[str, ...] = (
+    "SCENARIO_FEDFUNDS_DELTA",
+    "SCENARIO_VIX_SPIKE_RATIO",       # ratio > 1; sensitivity scales (ratio - 1)
+    "SCENARIO_OIL_PCT_CHANGE",
+    "SCENARIO_NATGAS_PCT_CHANGE",
+    "SCENARIO_SP500_DRAWDOWN",
+    "SCENARIO_NASDAQ_PCT_CHANGE",
+    "SCENARIO_YIELD_CURVE_STEEPENING",
+    "SCENARIO_DGS10_DELTA",
+    "SCENARIO_USD_PCT_CHANGE",
+    "SCENARIO_CPI_MOM_THRESHOLD",
+    "SCENARIO_PPI_MOM_THRESHOLD",
+    "SCENARIO_UNRATE_DELTA",
+    "SCENARIO_ICSA_SPIKE_RATIO",      # ratio > 1
+    "SCENARIO_PAYROLLS_DELTA",
+    "SCENARIO_HY_SPREAD_DELTA",
+    "SCENARIO_IG_SPREAD_DELTA",
+    "SCENARIO_TED_SPIKE",
+    "SCENARIO_FSI_THRESHOLD",
+    "SCENARIO_MORTGAGE_DELTA",
+    "SCENARIO_SENTIMENT_PCT_CHANGE",
+    "SCENARIO_INDPRO_PCT_CHANGE",
+    "SCENARIO_RETAIL_PCT_CHANGE",
+    "SCENARIO_HOUSING_PCT_CHANGE",
+    "SCENARIO_HOME_PRICE_YOY_DELTA",
+    "SCENARIO_M2_YOY_THRESHOLD",      # negative; scaling is sign-preserving
+    "SCENARIO_DGS30_DELTA",
+    "SCENARIO_SP_NASDAQ_DIVERGENCE",
+    "SCENARIO_VIX_REGIME_THRESHOLD",
+    "SCENARIO_FX_PCT_CHANGE",
+    "SCENARIO_BEI_DELTA",
+    "SCENARIO_DJIA_PCT_CHANGE",
+    "SCENARIO_JOLTS_PCT_CHANGE",
+    "SCENARIO_EARNINGS_MOM_THRESHOLD",
+    "SCENARIO_VEHICLE_PCT_CHANGE",
+    "SCENARIO_PERMIT_PCT_CHANGE",
+    "SCENARIO_FED_BS_PCT_CHANGE",
+    "SCENARIO_BUSLOANS_PCT_CHANGE",
+    "SCENARIO_PCEPI_MOM_THRESHOLD",
+    "SCENARIO_SOFR_DELTA",
+    "SCENARIO_REAL_YIELD_DELTA",
+    "SCENARIO_CREDIT_COMPRESSION_DELTA",
+    "SCENARIO_TERM_PREMIUM_DELTA",
+    "SCENARIO_SP500_SHORT_DRAWDOWN",
+    "SCENARIO_DGS10_SHORT_DELTA",
+)
+
+
+def _scale_spike_ratio(value: float, scale: float) -> float:
+    """Scale a spike-ratio threshold of the form (1 + excess) by ``scale``.
+
+    Spike ratios live in ``[1, ∞)`` with the magnitude carried by the
+    excess above 1; uniformly scaling the raw value collapses
+    sensitivity. We instead scale the excess: ratio_new = 1 + scale *
+    (ratio_default - 1).
+    """
+    return 1.0 + scale * (value - 1.0)
+
+
+_SPIKE_RATIO_KEYS: frozenset[str] = frozenset({
+    "SCENARIO_VIX_SPIKE_RATIO",
+    "SCENARIO_ICSA_SPIKE_RATIO",
+})
+
+
+def _scale_threshold(key: str, value: float, scale: float) -> float:
+    if key in _SPIKE_RATIO_KEYS:
+        return _scale_spike_ratio(value, scale)
+    return value * scale
+
+
+def _spearman_event_count_corr(
+    default_counts: dict[str, int], scaled_counts: dict[str, int],
+) -> float:
+    """Spearman rank correlation between per-event-type counts.
+
+    The two count vectors are aligned on the union of event types (zeros
+    fill missing keys). Returns NaN if either vector is constant.
+    """
+    keys = sorted(set(default_counts) | set(scaled_counts))
+    if len(keys) < 2:
+        return float("nan")
+    a = np.array([default_counts.get(k, 0) for k in keys], dtype=float)
+    b = np.array([scaled_counts.get(k, 0) for k in keys], dtype=float)
+    if np.unique(a).size < 2 or np.unique(b).size < 2:
+        return float("nan")
+    a_rank = pd.Series(a).rank().to_numpy()
+    b_rank = pd.Series(b).rank().to_numpy()
+    return float(np.corrcoef(a_rank, b_rank)[0, 1])
+
+
+def _run_with_thresholds(
+    scale: float,
+    granularity: str,
+) -> pd.DataFrame:
+    """Re-import ``config`` and ``generate_scenarios`` with scaled thresholds.
+
+    Mutating ``config`` module attributes in place and re-importing the
+    detection module via ``importlib.reload`` is the lowest-effort way to
+    pipe the scaled values through the existing code path; no detection
+    function is forked or modified.
+    """
+    from projects.agent_builder.scripts.whatif_bench import config
+    from projects.agent_builder.scripts.whatif_bench import generate_scenarios
+
+    if scale == 1.0:
+        importlib.reload(config)
+        importlib.reload(generate_scenarios)
+        return generate_scenarios.run(granularity=granularity)
+
+    importlib.reload(config)
+    original: dict[str, float] = {}
+    try:
+        for key in _THRESHOLD_KEYS:
+            if not hasattr(config, key):
+                continue
+            default_val = float(getattr(config, key))
+            original[key] = default_val
+            setattr(config, key, _scale_threshold(key, default_val, scale))
+        importlib.reload(generate_scenarios)
+        return generate_scenarios.run(granularity=granularity)
+    finally:
+        for key, default_val in original.items():
+            setattr(config, key, default_val)
+
+
+@dataclass
+class _SettingReport:
+    scale: float
+    n_events: int
+    per_type_counts: dict[str, int]
+    rank_corr_vs_default: float
+
+
+def sensitivity_probe(
+    *,
+    granularity: str = "daily",
+    scales: tuple[float, ...] = (0.5, 0.75, 1.0, 1.25, 1.5),
+) -> dict[str, Any]:
+    """Re-detect scenarios across threshold scales and report shifts.
+
+    The caller is responsible for confirming that FRED / EIA caches are
+    in place (``data_small_caps/macro/``). Each non-default scale takes
+    ~30s; expect ~3-5 minutes wall-clock total at the default five
+    scales.
+    """
+    reports: list[_SettingReport] = []
+    default_counts: dict[str, int] | None = None
+
+    for scale in scales:
+        logger.info("re-detecting scenarios at scale=%.2f", scale)
+        df = _run_with_thresholds(scale, granularity=granularity)
+        counts = df["event_type"].value_counts().to_dict()
+        if scale == 1.0:
+            default_counts = counts
+
+        rank_corr = (
+            1.0 if scale == 1.0
+            else _spearman_event_count_corr(default_counts or counts, counts)
+        )
+        reports.append(_SettingReport(
+            scale=scale,
+            n_events=int(len(df)),
+            per_type_counts={k: int(v) for k, v in counts.items()},
+            rank_corr_vs_default=rank_corr,
+        ))
+
+    return {
+        "probe": "sensitivity",
+        "granularity": granularity,
+        "scales": list(scales),
+        "settings": [r.__dict__ for r in reports],
+    }
+
+
+# ---------------------------------------------------------------------------
+# (b) External-calendar comparison
+# ---------------------------------------------------------------------------
+
+
+# FOMC meeting dates (last day of each scheduled meeting) 2021-01 → 2026-03,
+# verified against federalreserve.gov/monetarypolicy/fomccalendars.htm.
+_FOMC_DATES: tuple[str, ...] = (
+    "2021-01-27", "2021-03-17", "2021-04-28", "2021-06-16",
+    "2021-07-28", "2021-09-22", "2021-11-03", "2021-12-15",
+    "2022-01-26", "2022-03-16", "2022-05-04", "2022-06-15",
+    "2022-07-27", "2022-09-21", "2022-11-02", "2022-12-14",
+    "2023-02-01", "2023-03-22", "2023-05-03", "2023-06-14",
+    "2023-07-26", "2023-09-20", "2023-11-01", "2023-12-13",
+    "2024-01-31", "2024-03-20", "2024-05-01", "2024-06-12",
+    "2024-07-31", "2024-09-18", "2024-11-07", "2024-12-18",
+    "2025-01-29", "2025-03-19", "2025-05-07", "2025-06-18",
+    "2025-07-30", "2025-09-17", "2025-10-29", "2025-12-10",
+    "2026-01-28", "2026-03-18",
+)
+
+
+# BLS CPI Consumer Price Index release dates 2021-01 → 2026-03, verified
+# against bls.gov/schedule/news_release/cpi.htm.
+_CPI_RELEASE_DATES: tuple[str, ...] = (
+    "2021-01-13", "2021-02-10", "2021-03-10", "2021-04-13",
+    "2021-05-12", "2021-06-10", "2021-07-13", "2021-08-11",
+    "2021-09-14", "2021-10-13", "2021-11-10", "2021-12-10",
+    "2022-01-12", "2022-02-10", "2022-03-10", "2022-04-12",
+    "2022-05-11", "2022-06-10", "2022-07-13", "2022-08-10",
+    "2022-09-13", "2022-10-13", "2022-11-10", "2022-12-13",
+    "2023-01-12", "2023-02-14", "2023-03-14", "2023-04-12",
+    "2023-05-10", "2023-06-13", "2023-07-12", "2023-08-10",
+    "2023-09-13", "2023-10-12", "2023-11-14", "2023-12-12",
+    "2024-01-11", "2024-02-13", "2024-03-12", "2024-04-10",
+    "2024-05-15", "2024-06-12", "2024-07-11", "2024-08-14",
+    "2024-09-11", "2024-10-10", "2024-11-13", "2024-12-11",
+    "2025-01-15", "2025-02-12", "2025-03-12", "2025-04-10",
+    "2025-05-13", "2025-06-11", "2025-07-15", "2025-08-12",
+    "2025-09-11", "2025-10-15", "2025-11-13", "2025-12-10",
+    "2026-01-14", "2026-02-11", "2026-03-12",
+)
+
+
+# BLS Employment Situation (nonfarm payrolls) release dates 2021-01 →
+# 2026-03, verified against bls.gov/schedule/news_release/empsit.htm.
+_PAYROLLS_RELEASE_DATES: tuple[str, ...] = (
+    "2021-01-08", "2021-02-05", "2021-03-05", "2021-04-02",
+    "2021-05-07", "2021-06-04", "2021-07-02", "2021-08-06",
+    "2021-09-03", "2021-10-08", "2021-11-05", "2021-12-03",
+    "2022-01-07", "2022-02-04", "2022-03-04", "2022-04-01",
+    "2022-05-06", "2022-06-03", "2022-07-08", "2022-08-05",
+    "2022-09-02", "2022-10-07", "2022-11-04", "2022-12-02",
+    "2023-01-06", "2023-02-03", "2023-03-10", "2023-04-07",
+    "2023-05-05", "2023-06-02", "2023-07-07", "2023-08-04",
+    "2023-09-01", "2023-10-06", "2023-11-03", "2023-12-08",
+    "2024-01-05", "2024-02-02", "2024-03-08", "2024-04-05",
+    "2024-05-03", "2024-06-07", "2024-07-05", "2024-08-02",
+    "2024-09-06", "2024-10-04", "2024-11-01", "2024-12-06",
+    "2025-01-10", "2025-02-07", "2025-03-07", "2025-04-04",
+    "2025-05-02", "2025-06-06", "2025-07-03", "2025-08-01",
+    "2025-09-05", "2025-10-03", "2025-11-07", "2025-12-05",
+    "2026-01-09", "2026-02-06", "2026-03-06",
+)
+
+
+def _match_within_window(
+    detected: pd.Series, calendar: list[pd.Timestamp], window_days: int,
+) -> tuple[int, int]:
+    """Return (true positives in detected, recalled calendar entries).
+
+    A detected event counts as TP if any calendar entry is within
+    ``window_days`` calendar days; a calendar entry counts as recalled
+    if any detected event is within that window. Both counts use closest
+    matching with replacement (a single detected event may cover
+    multiple calendar entries, and vice versa).
+    """
+    if len(detected) == 0 or len(calendar) == 0:
+        return 0, 0
+    det_sorted = np.sort(detected.values.astype("datetime64[ns]"))
+    cal_sorted = np.sort(np.asarray(calendar, dtype="datetime64[ns]"))
+    window_ns = np.timedelta64(window_days, "D")
+
+    tp_det = 0
+    for ts in det_sorted:
+        idx = np.searchsorted(cal_sorted, ts)
+        candidates = []
+        if idx < len(cal_sorted):
+            candidates.append(cal_sorted[idx])
+        if idx > 0:
+            candidates.append(cal_sorted[idx - 1])
+        if any(abs(ts - c) <= window_ns for c in candidates):
+            tp_det += 1
+
+    recall_hits = 0
+    for ts in cal_sorted:
+        idx = np.searchsorted(det_sorted, ts)
+        candidates = []
+        if idx < len(det_sorted):
+            candidates.append(det_sorted[idx])
+        if idx > 0:
+            candidates.append(det_sorted[idx - 1])
+        if any(abs(ts - c) <= window_ns for c in candidates):
+            recall_hits += 1
+
+    return tp_det, recall_hits
+
+
+def external_calendar_probe(
+    *,
+    scenarios_path: Path,
+    window_days: int = 5,
+) -> dict[str, Any]:
+    """Score detected events against three public release calendars.
+
+    For each pair (event_type, calendar):
+      precision = TP_detected / |detected|
+      recall    = TP_calendar / |calendar|
+    """
+    df = pd.read_parquet(scenarios_path)
+    df["event_date"] = pd.to_datetime(df["event_date"])
+
+    panels = (
+        ("fed_rate_change", "FOMC", _FOMC_DATES),
+        ("cpi_shock", "BLS_CPI", _CPI_RELEASE_DATES),
+        # NOTE: the panel collects payroll-related events under
+        # ``payrolls_delta``; the actual detector emits
+        # ``payrolls_shock``. Some older scenario builds tagged the same
+        # detector with ``mom_change`` family naming. We accept either.
+        ("payrolls_shock", "BLS_NFP", _PAYROLLS_RELEASE_DATES),
+    )
+
+    reports: list[dict[str, Any]] = []
+    for event_type, calendar_name, calendar_dates in panels:
+        detected = df.loc[df["event_type"] == event_type, "event_date"]
+        cal = [pd.Timestamp(d) for d in calendar_dates]
+        tp_det, recall_hits = _match_within_window(detected, cal, window_days)
+        precision = tp_det / len(detected) if len(detected) else 0.0
+        recall = recall_hits / len(cal) if len(cal) else 0.0
+        reports.append({
+            "event_type": event_type,
+            "calendar": calendar_name,
+            "n_detected": int(len(detected)),
+            "n_calendar": int(len(cal)),
+            "true_positive_detected": int(tp_det),
+            "true_positive_calendar": int(recall_hits),
+            "precision": precision,
+            "recall": recall,
+        })
+
+    return {
+        "probe": "external_calendar",
+        "scenarios_path": str(scenarios_path),
+        "match_window_days": window_days,
+        "panels": reports,
+    }
+
+
+# ---------------------------------------------------------------------------
+# (c) Manual-validation template
+# ---------------------------------------------------------------------------
+
+
+def manual_validation_template(
+    *,
+    scenarios_path: Path,
+    n_samples: int = 100,
+    seed: int = 42,
+    rater_ids: tuple[str, ...] = ("R1", "R2", "R3", "R4"),
+) -> dict[str, Any]:
+    """Emit a stratified random sample of scenarios as a rating template.
+
+    Each row in ``items`` has four rater columns, each initialised to
+    ``null``; downstream the authors fill these in offline and feed the
+    populated file back to :func:`manual_validation_aggregate`.
+    """
+    df = pd.read_parquet(scenarios_path)
+
+    # Stratified sample by event type: take ceil(n_samples * p_type) per
+    # type up to the available count, then trim to exactly n_samples.
+    rng = random.Random(seed)
+    counts = df["event_type"].value_counts()
+    weights = counts / counts.sum()
+
+    keep_idx: list[int] = []
+    for event_type, weight in weights.items():
+        target = max(1, int(round(weight * n_samples)))
+        subset = df.index[df["event_type"] == event_type].tolist()
+        target = min(target, len(subset))
+        keep_idx.extend(rng.sample(subset, target))
+
+    if len(keep_idx) > n_samples:
+        keep_idx = rng.sample(keep_idx, n_samples)
+    sampled = df.loc[keep_idx].sort_values("event_date").reset_index(drop=True)
+
+    items: list[dict[str, Any]] = []
+    for row in sampled.itertuples(index=False):
+        ed = pd.Timestamp(row.event_date)
+        item = {
+            "scenario_id": row.scenario_id,
+            "event_type": row.event_type,
+            "event_date": ed.strftime("%Y-%m-%d"),
+            "event_description": row.event_description,
+            # Each rater records: 1 = plausible, 0 = not plausible, null =
+            # not yet rated. Plausibility = "would a financial analyst
+            # accept this as a real macroeconomic event of the stated
+            # type on the stated date?". Raters are blind to whether the
+            # detector emitted any other event on that date.
+            **{rid: None for rid in rater_ids},
+            "rater_notes": "",
+        }
+        items.append(item)
+
+    return {
+        "probe": "manual_validation",
+        "scenarios_path": str(scenarios_path),
+        "n_samples": len(items),
+        "seed": seed,
+        "rater_ids": list(rater_ids),
+        "items": items,
+    }
+
+
+def _fleiss_kappa(matrix: np.ndarray) -> float:
+    """Fleiss' kappa for a (n_items, n_categories) count matrix."""
+    n_items, n_cat = matrix.shape
+    n_rat = matrix.sum(axis=1)
+    if (n_rat != n_rat[0]).any():
+        raise ValueError("Fleiss' kappa requires equal raters per item.")
+    n = float(n_rat[0])
+    if n < 2:
+        return float("nan")
+    p_cat = matrix.sum(axis=0) / (n_items * n)
+    p_bar_e = float((p_cat ** 2).sum())
+    p_item = ((matrix ** 2).sum(axis=1) - n) / (n * (n - 1))
+    p_bar = float(p_item.mean())
+    if 1 - p_bar_e == 0:
+        return float("nan")
+    return (p_bar - p_bar_e) / (1 - p_bar_e)
+
+
+def manual_validation_aggregate(
+    populated_path: Path,
+    *,
+    consensus_threshold: int = 3,
+) -> dict[str, Any]:
+    """Aggregate inter-rater agreement and per-category accuracy."""
+    blob = json.loads(populated_path.read_text())
+    rater_ids: list[str] = blob["rater_ids"]
+    items = blob["items"]
+
+    df = pd.DataFrame(items)
+    rating_cols = [c for c in rater_ids if c in df.columns]
+    df_rated = df.dropna(subset=rating_cols).copy()
+    if df_rated.empty:
+        return {"error": "no fully rated items found", "n_items_total": len(items)}
+
+    matrix_rows: list[list[int]] = []
+    for _, row in df_rated.iterrows():
+        votes = [int(row[c]) for c in rating_cols]
+        n_pos = sum(votes)
+        n_neg = len(votes) - n_pos
+        matrix_rows.append([n_pos, n_neg])
+    matrix = np.asarray(matrix_rows, dtype=int)
+    kappa = _fleiss_kappa(matrix)
+
+    df_rated["consensus_plausible"] = matrix[:, 0] >= consensus_threshold
+    df_rated["consensus_not_plausible"] = matrix[:, 1] >= consensus_threshold
+    accuracy_by_type: dict[str, dict[str, Any]] = {}
+    for event_type, group in df_rated.groupby("event_type"):
+        n = len(group)
+        n_plausible = int(group["consensus_plausible"].sum())
+        n_not = int(group["consensus_not_plausible"].sum())
+        accuracy_by_type[event_type] = {
+            "n_rated": n,
+            "n_plausible": n_plausible,
+            "n_not_plausible": n_not,
+            "n_no_consensus": n - n_plausible - n_not,
+            "plausibility_rate": n_plausible / n if n else 0.0,
+        }
+
+    overall_plausible = int(df_rated["consensus_plausible"].sum())
+    return {
+        "probe": "manual_validation_aggregate",
+        "n_items_total": len(items),
+        "n_items_rated": len(df_rated),
+        "fleiss_kappa": kappa,
+        "consensus_threshold": consensus_threshold,
+        "overall_plausibility_rate": (
+            overall_plausible / len(df_rated) if len(df_rated) else 0.0
+        ),
+        "per_category": accuracy_by_type,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def _default_scenarios_path() -> Path:
+    from projects.agent_builder.scripts.whatif_bench import config
+    return config.DATA_DIR / "benchmark" / "daily" / "scenarios.parquet"
+
+
+def _default_output_dir() -> Path:
+    # Probe outputs live under experiments/ (experiment artifacts),
+    # never under data_small_caps/ (raw + derived benchmark data).
+    return Path(__file__).resolve().parents[1] / "probes_output"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Scenario-layer validation probes (sensitivity / external / manual).",
+    )
+    sub = parser.add_subparsers(dest="probe", required=True)
+
+    s = sub.add_parser("sensitivity", help="threshold sensitivity probe")
+    s.add_argument("--granularity", default="daily")
+    s.add_argument("--scales", nargs="+", type=float,
+                   default=[0.5, 0.75, 1.0, 1.25, 1.5])
+    s.add_argument("--output", type=Path, default=None)
+
+    e = sub.add_parser("external", help="external-calendar comparison probe")
+    e.add_argument("--scenarios-path", type=Path, default=None)
+    e.add_argument("--window-days", type=int, default=5)
+    e.add_argument("--output", type=Path, default=None)
+
+    m = sub.add_parser("manual-template",
+                       help="emit a stratified sample as a manual rating template")
+    m.add_argument("--scenarios-path", type=Path, default=None)
+    m.add_argument("--n-samples", type=int, default=100)
+    m.add_argument("--seed", type=int, default=42)
+    m.add_argument("--output", type=Path, default=None)
+
+    a = sub.add_parser("manual-aggregate",
+                       help="aggregate a populated manual rating template")
+    a.add_argument("--input", type=Path, required=True,
+                   help="path to populated manual-validation JSON")
+    a.add_argument("--consensus-threshold", type=int, default=3)
+    a.add_argument("--output", type=Path, default=None)
+
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+    out_dir = _default_output_dir()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.probe == "sensitivity":
+        report = sensitivity_probe(granularity=args.granularity, scales=tuple(args.scales))
+        out_path = args.output or out_dir / "scenario_sensitivity.json"
+    elif args.probe == "external":
+        path = args.scenarios_path or _default_scenarios_path()
+        report = external_calendar_probe(scenarios_path=path, window_days=args.window_days)
+        out_path = args.output or out_dir / "scenario_external_calendar.json"
+    elif args.probe == "manual-template":
+        path = args.scenarios_path or _default_scenarios_path()
+        report = manual_validation_template(
+            scenarios_path=path, n_samples=args.n_samples, seed=args.seed,
+        )
+        out_path = args.output or out_dir / "scenario_manual_template.json"
+    elif args.probe == "manual-aggregate":
+        report = manual_validation_aggregate(
+            args.input, consensus_threshold=args.consensus_threshold,
+        )
+        out_path = args.output or out_dir / "scenario_manual_aggregate.json"
+    else:  # pragma: no cover -- argparse guards against this
+        raise AssertionError(f"unknown probe: {args.probe!r}")
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(report, indent=2, default=str))
+    logger.info("probe %s wrote %s", args.probe, out_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/experiments/probes/scout_qlora_multitask.py

@@ -0,0 +1,481 @@
+"""Llama-4 Scout multi-task QLoRA SFT (Family-7 / Phase 3.1).
+
+Hyperparameters mirror Meta's official torchtune recipe
+``recipes/configs/llama4/scout_17B_16E_lora.yaml`` (rev 4415449e) verbatim
+where applicable; the only deviations are forced by our hardware
+(4xA100-40GB vs Meta's 8xA100 reference):
+
+* **Quantisation.** Meta's recipe is bf16 full-precision; Scout in bf16 is
+  ~218GB of weights + matching optimiser state and does not fit on 4x40GB.
+  We replace the bf16 load with bnb NF4 4-bit (~55GB of weights, split
+  across the 4 GPUs) so the model fits. RESEARCH_PLAN.md §5.1 documents
+  this as the "MoE-on-bitsandbytes complexity" path; the explicit
+  ``max_memory`` map below avoids the CPU/disk-offload failure mode that
+  ``device_map="auto"`` triggers on Scout-MoE.
+* **Distributed.** Meta uses FSDP via torchtune (which the venv does not
+  carry on this torch version); we use bnb-4bit + HF ``device_map="auto"``
+  with explicit per-GPU caps and let peft handle the LoRA-side gradient
+  flow. No DeepSpeed or torchtune dependency.
+* **Routed-expert LoRA.** Meta's recipe sets ``apply_lora_to_mlp: True``
+  which adapts every Llama4 expert MLP. HF transformers 5.8.0 packs the
+  16 routed experts of each layer into a single ``Llama4TextExperts``
+  custom module (one tensor per expert axis), which peft 0.19.1 cannot
+  target via the default suffix-matching path. We therefore LoRA-adapt
+  ``q_proj``, ``k_proj``, ``v_proj``, ``o_proj`` (attention) plus
+  ``gate_proj``, ``up_proj``, ``down_proj`` (the shared / always-on
+  expert MLP). Routed experts stay frozen — a known limitation; the
+  shared expert + attention LoRA still gives substantial adaptation
+  capacity per the SciTS / EDINET-Bench precedent.
+
+All four Meta-recipe LoRA hyperparameters (``r=16, alpha=32,
+dropout=0.0``, lr=2e-5, 1 epoch, ``clip_grad_norm: null``) are preserved
+verbatim per `feedback_use_library_defaults`.
+
+Data format follows TRL 1.3's ``completion_only_loss=True`` schema:
+each training row is ``{"prompt": ..., "completion": ...}`` so loss is
+computed only on the completion tokens. The pair builders in
+:mod:`methods.llm_finetune` are reused unchanged for T1..T7; the
+``### Instruction: ... ### Response:`` envelope is preserved so the
+inference-side prompt format matches.
+
+This is a multi-GPU-day run on 4xA100-40GB (GPUs 4..7 per project
+memory). The user must authorise the launch explicitly.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Per project memory: MacroLens GPUs are 4-7. The caller must set
+# CUDA_VISIBLE_DEVICES=4,5,6,7 before launching this script; we read it
+# for logging and to size the ``max_memory`` map below.
+
+
+def _t3_t6_pairs_fixed(
+    X: Any, y: Any, *, task: str, fitted_fields: list[str],
+) -> list[tuple[str, str]]:
+    """T3/T6 pair builder using a FIXED field list.
+
+    Replaces :func:`methods.llm_finetune._t3_t6_pairs` so the training
+    instruction matches the prediction-time prompt exactly. The original
+    per-row variant lists only the fields that appear in THIS row's
+    ground truth; the eval path's ``_predict_t3_t6`` falls back to a
+    fitted-field list (or the buggy 10-field ``_DEFAULT_T3_T6_FIELDS``).
+    The mismatch causes the adapter to learn one schema and be queried
+    on another at test time.
+
+    Here every (ticker, fiscal_year) row is wrapped in a prompt that
+    lists ``fitted_fields`` verbatim. The response JSON includes every
+    field in ``fitted_fields``; values not present in the row's ground
+    truth get ``null`` (which the eval-side parser
+    :func:`_extract_json_object` skips, contributing fillna(0) → APE
+    100% on the eval side per ``feedback_penalize_incomplete``).
+    """
+    import json as _json
+
+    import pandas as _pd
+
+    from projects.agent_builder.scripts.whatif_bench.methods.llm_finetune import (
+        _safe_float,
+    )
+
+    if y is None or not hasattr(y, "empty") or y.empty:
+        return []
+    y_grouped = (
+        y.groupby(["ticker", "fiscal_year"])
+        .apply(lambda g: dict(zip(g["field"], g["value"])))
+        .to_dict()
+    )
+    fields_str = ", ".join(fitted_fields)
+    pairs: list[tuple[str, str]] = []
+    for _, row in X.iterrows():
+        ticker = str(row.get("ticker", "?"))
+        fy = row.get("fiscal_year", None)
+        key = (ticker, fy)
+        if key not in y_grouped:
+            for cand_key in y_grouped:
+                if str(cand_key[0]) == ticker and str(cand_key[1]) == str(fy):
+                    key = cand_key
+                    break
+        gt_fields = y_grouped.get(key, {})
+        if not gt_fields:
+            continue
+        if task == "T3":
+            sector = row.get("sector", "Unknown")
+            revenue = _safe_float(row.get("stmt_revenue", 0))
+            net_income = _safe_float(row.get("stmt_net_income", 0))
+            instr = (
+                f"You are a financial analyst. Given {ticker}'s known "
+                f"fundamentals (sector={sector}, revenue=${revenue:,.0f}, "
+                f"net_income=${net_income:,.0f}), predict these XBRL "
+                f"fields: [{fields_str}]"
+            )
+        else:  # T6
+            description = row.get(
+                "company_description", f"A company with ticker {ticker}",
+            )
+            sector = row.get("sector", "Unknown")
+            industry = row.get("industry", "Unknown")
+            instr = (
+                f"Given this company description: '{description}', "
+                f"sector: '{sector}', industry: '{industry}', generate "
+                f"plausible financial statement values for these XBRL "
+                f"fields: [{fields_str}]"
+            )
+        resp_dict: dict[str, Any] = {}
+        for f in fitted_fields:
+            v = gt_fields.get(f, None)
+            if v is None or (isinstance(v, float) and _pd.isna(v)):
+                resp_dict[f] = None
+            else:
+                try:
+                    resp_dict[f] = round(float(v), 2)
+                except (TypeError, ValueError):
+                    resp_dict[f] = None
+        resp = _json.dumps(resp_dict)
+        pairs.append((instr, resp))
+    return pairs
+
+
+def _build_pooled_pairs(granularity: str) -> tuple[
+    list[dict[str, str]], dict[str, int], dict[str, Any]
+]:
+    """Build the pooled SFT corpus across T1..T7 train splits.
+
+    Each task's training set is rendered into ``(instruction, response)``
+    pairs by the task-specific builders in :mod:`methods.llm_finetune`,
+    except T3 and T6 which use :func:`_t3_t6_pairs_fixed` (this file)
+    with a globally-fitted field list pooled from T3 + T6 train data;
+    that fixes the documented train/predict prompt-field-list mismatch.
+
+    Returns ``(rows, pair_counts_by_task, fitted_fields_meta)`` where
+    ``fitted_fields_meta`` is the sidecar dict written next to the
+    adapter for the eval path to load.
+    """
+    import numpy as np
+
+    from projects.agent_builder.scripts.whatif_bench import macrolens as ml
+    from projects.agent_builder.scripts.whatif_bench.methods.llm_finetune import (
+        _t1_pairs, _t2_t5_pairs, _t4_pairs, _t7_pairs,
+        _find_close_idx_from_array,
+    )
+
+    # ── Pre-load T3 + T6 train y to fit the global + per-ticker field lists ──
+    t3_train = ml.load("T3", "train", granularity=granularity)
+    t6_train = ml.load("T6", "train", granularity=granularity)
+
+    import pandas as pd
+    union_y = pd.concat(
+        [df for df in (t3_train.y, t6_train.y)
+         if df is not None and hasattr(df, "empty") and not df.empty],
+        ignore_index=True,
+    )
+    if union_y.empty or "field" not in union_y.columns:
+        raise RuntimeError("T3 + T6 train y is empty / lacks a 'field' column.")
+    fitted_fields_global: list[str] = sorted(
+        str(f) for f in union_y["field"].astype(str).unique()
+    )
+    fitted_fields_per_ticker: dict[str, list[str]] = {}
+    for t, grp in union_y.groupby("ticker", sort=False):
+        fitted_fields_per_ticker[str(t)] = sorted(
+            str(f) for f in grp["field"].astype(str).unique()
+        )
+    logger.info(
+        "T3+T6 fitted_fields_global has %d fields: %s",
+        len(fitted_fields_global), fitted_fields_global,
+    )
+
+    rows: list[dict[str, str]] = []
+    counts: dict[str, int] = {}
+    for task in ("T1", "T2", "T3", "T4", "T5", "T6", "T7"):
+        if task == "T3":
+            train = t3_train
+        elif task == "T6":
+            train = t6_train
+        else:
+            train = ml.load(task, "train", granularity=granularity)
+        X, y = train.X, train.y
+        if task == "T1":
+            X_arr = np.asarray(X, dtype=np.float32)
+            close_idx = _find_close_idx_from_array(X_arr)
+            pairs = _t1_pairs(
+                X_arr, np.asarray(y, dtype=np.float32), close_idx=close_idx,
+            )
+        elif task in ("T2", "T5"):
+            pairs = _t2_t5_pairs(X, np.asarray(y, dtype=np.float64), task=task)
+        elif task in ("T3", "T6"):
+            # CORRECTNESS FIX: use the globally-fitted field list (not per-row
+            # available fields) so training prompts match the eval-time
+            # prompt format produced by ``_predict_t3_t6`` after we populate
+            # ``_fitted_fields_global`` from our sidecar.
+            pairs = _t3_t6_pairs_fixed(
+                X, y, task=task, fitted_fields=fitted_fields_global,
+            )
+        elif task == "T4":
+            pairs = _t4_pairs(X, np.asarray(y, dtype=np.float32))
+        else:
+            pairs = _t7_pairs(X, y)
+        for instr, resp in pairs:
+            rows.append({
+                "prompt": f"### Instruction:\n{instr}\n\n### Response:\n",
+                "completion": resp,
+            })
+        counts[task] = len(pairs)
+        logger.info("built %d pairs for %s", len(pairs), task)
+
+    fitted_fields_meta = {
+        "fitted_fields_global": fitted_fields_global,
+        "fitted_fields_per_ticker": fitted_fields_per_ticker,
+        "granularity": granularity,
+        "source": "T3 + T6 train y union",
+    }
+    return rows, counts, fitted_fields_meta
+
+
+def _build_model_and_tokenizer(
+    *, model_id: str, per_gpu_gib: int,
+) -> tuple[Any, Any]:
+    """Load the base LLM under bnb-NF4.
+
+    Standard dense-Transformer path: ``AutoModelForCausalLM`` +
+    ``device_map="auto"``. The naïve auto-dispatcher works correctly
+    because bnb-NF4 quantises every ``nn.Linear`` in a vanilla dense
+    decoder (no MoE-experts-stay-bf16 trap, no multimodal wrapper,
+    no hybrid attention modules to special-case).
+    """
+    import torch
+    from transformers import (
+        AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig,
+    )
+
+    quant_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_compute_dtype=torch.bfloat16,
+    )
+
+    n_vis = torch.cuda.device_count() if torch.cuda.is_available() else 0
+    if n_vis < 1:
+        raise RuntimeError("no CUDA devices visible to PyTorch.")
+    max_memory = {i: f"{per_gpu_gib}GiB" for i in range(n_vis)}
+    logger.info(
+        "loading %s as AutoModelForCausalLM with bnb-NF4 (max_memory=%s)",
+        model_id, max_memory,
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        quantization_config=quant_config,
+        device_map="auto",
+        max_memory=max_memory,
+        torch_dtype=torch.bfloat16,
+        attn_implementation="eager",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    return model, tokenizer
+
+
+def run(
+    *,
+    base_hf_id: str = "Qwen/Qwen2.5-7B-Instruct",
+    granularity: str = "daily",
+    seed: int = 42,
+    output_dir: Path,
+    per_gpu_gib: int = 36,
+    max_length: int = 4096,
+    smoke_only: bool = False,
+) -> dict[str, Any]:
+    """Train one Scout multi-task QLoRA adapter across T1..T7 pooled.
+
+    Parameters
+    ----------
+    smoke_only
+        When True, run ``max_steps=2`` instead of one full epoch, so the
+        smoke pass verifies the load + LoRA-wrap + forward+backward +
+        optimiser step path before committing to the full training
+        wall-clock (~ 6-12 GPU-hours).
+    """
+    import torch
+    from datasets import Dataset
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    from trl import SFTConfig, SFTTrainer
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # 1. Pool data
+    t0 = time.perf_counter()
+    rows, counts, fitted_fields_meta = _build_pooled_pairs(
+        granularity=granularity,
+    )
+    if not rows:
+        raise RuntimeError("empty pooled corpus.")
+    pool_sec = time.perf_counter() - t0
+    logger.info(
+        "pooled %d pairs total (%s); pool build took %.1fs",
+        len(rows), counts, pool_sec,
+    )
+    # Write the fitted-fields sidecar BEFORE training so the eval path
+    # can populate ``_fitted_fields_per_ticker`` / ``_fitted_fields_global``
+    # on the loaded :class:`methods.LLMFineTuned` instance (matching the
+    # training prompts the adapter was tuned on).
+    sidecar_path = output_dir / "fitted_fields.json"
+    sidecar_path.write_text(json.dumps(fitted_fields_meta, indent=2))
+    logger.info("wrote T3/T6 fitted-fields sidecar to %s", sidecar_path)
+
+    # 2. Load model
+    model, tokenizer = _build_model_and_tokenizer(
+        model_id=base_hf_id, per_gpu_gib=per_gpu_gib,
+    )
+
+    # 3. Prepare for k-bit + apply LoRA
+    model = prepare_model_for_kbit_training(
+        model, use_gradient_checkpointing=True,
+    )
+    lora_cfg = LoraConfig(
+        r=16,                                       # Meta's recipe
+        lora_alpha=32,                              # Meta's recipe
+        lora_dropout=0.0,                           # Meta's recipe
+        target_modules=[
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj",
+        ],
+        bias="none",
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, lora_cfg)
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    total = sum(p.numel() for p in model.parameters())
+    logger.info(
+        "LoRA-adapted: %d trainable / %d total params (%.4f%%)",
+        trainable, total, 100.0 * trainable / max(1, total),
+    )
+
+    # 4. Format dataset for completion_only_loss
+    train_dataset = Dataset.from_list(rows)
+    if seed is not None:
+        train_dataset = train_dataset.shuffle(seed=seed)
+
+    # 5. SFTConfig — Meta's hyperparameters verbatim
+    sft_cfg = SFTConfig(
+        output_dir=str(output_dir),
+        num_train_epochs=1,                # Meta's recipe
+        per_device_train_batch_size=2,     # Meta's recipe
+        gradient_accumulation_steps=1,     # Meta's recipe
+        learning_rate=2e-5,                # Meta's recipe
+        lr_scheduler_type="cosine",
+        warmup_steps=100,                  # Meta's recipe
+        optim="adamw_torch",               # Meta uses AdamW (not paged_adamw_8bit)
+        weight_decay=0.0,
+        max_grad_norm=0.0,                 # Meta: clip_grad_norm: null -> disabled
+        bf16=True,
+        fp16=False,
+        gradient_checkpointing=True,
+        completion_only_loss=True,         # TRL 1.3 response-only loss
+        max_length=max_length,             # T1 trajectories ~ 2000 tokens
+        dataset_text_field=None,
+        packing=False,
+        save_strategy="epoch",
+        save_total_limit=1,
+        save_only_model=True,              # adapter checkpoints only
+        logging_steps=10,
+        report_to="none",
+        seed=seed,
+        max_steps=2 if smoke_only else -1,
+    )
+
+    trainer = SFTTrainer(
+        model=model,
+        args=sft_cfg,
+        train_dataset=train_dataset,
+        processing_class=tokenizer,
+    )
+
+    t1 = time.perf_counter()
+    trainer.train()
+    fit_sec = time.perf_counter() - t1
+    logger.info("training done in %.1fs (smoke=%s)", fit_sec, smoke_only)
+
+    # 6. Save adapter
+    adapter_dir = output_dir / "adapter"
+    tokenizer_dir = output_dir / "tokenizer"
+    model.save_pretrained(str(adapter_dir))
+    tokenizer.save_pretrained(str(tokenizer_dir))
+    logger.info("adapter saved to %s", adapter_dir)
+
+    return {
+        "probe": "scout_qlora_multitask",
+        "base_hf_id": base_hf_id,
+        "granularity": granularity,
+        "seed": seed,
+        "pair_counts": counts,
+        "pool_sec": pool_sec,
+        "fit_sec": fit_sec,
+        "smoke_only": smoke_only,
+        "adapter_dir": str(adapter_dir),
+        "tokenizer_dir": str(tokenizer_dir),
+        "max_length": max_length,
+        "fitted_fields_sidecar": str(sidecar_path),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--base-hf-id",
+        default="Qwen/Qwen2.5-7B-Instruct",
+        help="HF model id of the base.",
+    )
+    parser.add_argument("--granularity", default="daily")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument(
+        "--output-dir", type=Path,
+        default=Path(__file__).resolve().parents[1] / "adapters" / "qwen25_7b_qlora_multitask",
+    )
+    parser.add_argument("--per-gpu-gib", type=int, default=36)
+    parser.add_argument("--max-length", type=int, default=4096)
+    parser.add_argument(
+        "--smoke-only", action="store_true",
+        help="Run max_steps=2 instead of a full epoch (verifies load + "
+             "forward + backward + optimiser step in ~minutes).",
+    )
+    parser.add_argument(
+        "--report-path", type=Path, default=None,
+        help="JSON report path (default: <output_dir>/training_report.json).",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    report = run(
+        base_hf_id=args.base_hf_id,
+        granularity=args.granularity,
+        seed=args.seed,
+        output_dir=args.output_dir,
+        per_gpu_gib=args.per_gpu_gib,
+        max_length=args.max_length,
+        smoke_only=args.smoke_only,
+    )
+    report_path = args.report_path or (args.output_dir / "training_report.json")
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2, default=str))
+    logger.info("report -> %s", report_path)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

code/experiments/re_evaluate.py

@@ -0,0 +1,71 @@
+"""Re-score saved predictions with the current eval.py (no re-running models).
+
+Reads every ``experiments/predictions/<method>_<task>_seed<seed>[_setX].pkl``,
+calls ``ml.score`` with the current ``eval.py``, writes a fresh
+``RunRecord`` JSON to ``experiments/results/canon_reeval_<timestamp>.json``.
+
+Use this whenever ``eval.py`` is patched: regenerates metrics from cached
+predictions in ~seconds, no LLM/GPU spend.
+"""
+from __future__ import annotations
+import argparse, json, pickle, pathlib, sys
+import numpy as np
+import pandas as pd
+
+def main():
+    sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2]))
+    from whatif_bench import config
+    from whatif_bench import macrolens as ml
+
+    pred_dir = pathlib.Path(__file__).parent / "predictions"
+    out_dir = pathlib.Path(__file__).parent / "results"
+    out_path = out_dir / f"canon_reeval_{pd.Timestamp.utcnow().strftime('%Y%m%dT%H%M%SZ')}.json"
+    records = []
+    pkls = sorted(pred_dir.glob("*.pkl"))
+    print(f"re-evaluating {len(pkls)} prediction files")
+    for p in pkls:
+        with open(p, "rb") as f:
+            d = pickle.load(f)
+        task = d["task"]
+        meta_test = d["meta_test"]
+        y_test = d["y_test"]
+        y_pred = d["y_pred"]
+        # cluster keys
+        if task == "T4":
+            ck = meta_test["scenario_id"].values if "scenario_id" in meta_test.columns else None
+        elif task == "T7":
+            ck = meta_test["address"].values if "address" in meta_test.columns else None
+        elif "ticker" in meta_test.columns:
+            ck = meta_test["ticker"].values
+        else:
+            ck = None
+        kw = {"cluster_keys": ck}
+        if task == "T1" and "close_last" in meta_test.columns:
+            kw["close_last"] = meta_test["close_last"].values
+        try:
+            metrics = ml.score(task, y_test, y_pred, **kw)
+        except Exception as exc:
+            print(f"  {p.name}: score raised {type(exc).__name__}: {exc}")
+            continue
+        # Build a record (mirroring RunRecord essentials)
+        rec = {
+            "method_id": d["method_id"],
+            "task": task,
+            "granularity": d.get("granularity", "daily"),
+            "seed": d.get("seed", 42),
+            "status": "ok",
+            "ablation_setting": d.get("ablation_setting"),
+            "timestamp": pd.Timestamp.utcnow().isoformat(),
+            "metrics": {k: (v.model_dump() if hasattr(v,"model_dump") else v) for k,v in metrics.items()},
+        }
+        records.append(rec)
+        primary = {"T1":"mse","T2":"median_ape","T3":"overall_mape","T4":"return_mae_pct",
+                   "T5":"median_ape","T6":"overall_mape","T7":"rent_MAPE"}.get(task)
+        pv = (metrics or {}).get(primary)
+        pv = pv.value if pv is not None and hasattr(pv, "value") else None
+        print(f"  {d['method_id']:18s} {task} setting={d.get('ablation_setting')}  {primary}={pv}")
+    out_path.write_text(json.dumps(records, indent=2, default=str))
+    print(f"\nwrote {len(records)} re-evaluated records to {out_path}")
+
+if __name__ == "__main__":
+    main()

code/experiments/result_schema.py

@@ -0,0 +1,213 @@
+"""Pydantic v2 result schemas for MacroLens task runners.
+
+These models replace the legacy ``TypedDict`` shapes used pre-Phase-4. The
+orchestrator (:mod:`experiments.run_all`) persists results as
+:class:`macrolens.RunRecord` (full reproducibility envelope); these
+per-task models capture the *metric content* of a single record's
+``metrics`` field and are used by post-hoc tools (``gen_tables.py``,
+``analysis.py``) that need a typed handle on the per-task metric set.
+
+Every model:
+
+* Uses ``model_config = ConfigDict(extra="forbid", frozen=True)`` so unknown
+  keys raise at construction and instances are hashable.
+* Allows every metric to be ``None`` — runners that legitimately skip a
+  metric (e.g., a deterministic naive method that does not report CRPS)
+  emit ``None``, not a sentinel string.
+* Adds T5/T6/T7 (the legacy schema was missing T5/T6/T7).
+"""
+
+from __future__ import annotations
+
+import pydantic
+
+
+# ── Shared sub-schemas ────────────────────────────────────────────────────
+
+
+class BootstrapCI(pydantic.BaseModel):
+    """Bootstrap 95% CI for a scalar metric (matches ``MetricValue``)."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    mean: float | None = None
+    ci_lo: float | None = None
+    ci_hi: float | None = None
+    std: float | None = None
+
+
+class MultiSeedStats(pydantic.BaseModel):
+    """Mean +/- std over the headline T1 multi-seed subset."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    seed_mean: float | None = None
+    seed_std: float | None = None
+    per_seed: dict[int, float] | None = None
+
+
+# ── Per-task metric schemas ───────────────────────────────────────────────
+
+
+class T1Metrics(pydantic.BaseModel):
+    """T1 — Contextual Time-Series Forecasting."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T1"
+    horizon: int | None = None
+    granularity: str = "daily"
+    seed: int = 42
+    mse: float | None = None
+    mae: float | None = None
+    rmse: float | None = None
+    directional_accuracy: float | None = None
+    mse_ci: BootstrapCI | None = None
+    mae_ci: BootstrapCI | None = None
+    da_ci: BootstrapCI | None = None
+    multiseed: MultiSeedStats | None = None
+    n_instances: int | None = None
+    inference_time_sec: float | None = None
+    train_time_sec: float | None = None
+
+
+class T2Metrics(pydantic.BaseModel):
+    """T2 — Point-in-Time Equity Valuation."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T2"
+    granularity: str = "daily"
+    seed: int = 42
+    mape: float | None = None
+    median_ape: float | None = None
+    rank_correlation: float | None = None
+    rank_p_value: float | None = None
+    mape_ci: BootstrapCI | None = None
+    n_predictions: int | None = None
+    n_tickers: int | None = None
+    inference_time_sec: float | None = None
+
+
+class T3Metrics(pydantic.BaseModel):
+    """T3 — Statement Generation (per-field MAPE + balance equation)."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T3"
+    granularity: str = "daily"
+    seed: int = 42
+    overall_mape: float | None = None
+    per_field_mape: dict[str, float] | None = None
+    balance_equation_accuracy: float | None = None
+    balance_equation_checked: int | None = None
+    success_rate: float | None = None
+    n_fields_matched: int | None = None
+    n_field_misses: int | None = None
+    n_tickers: int | None = None
+    inference_time_sec: float | None = None
+
+
+class T4Metrics(pydantic.BaseModel):
+    """T4 — Scenario-Conditioned Return Forecasting."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T4"
+    granularity: str = "daily"
+    seed: int = 42
+    return_mae_pct: float | None = None
+    directional_accuracy: float | None = None
+    ci_calibration_95: float | None = None
+    return_mae_ci: BootstrapCI | None = None
+    n_predictions: int | None = None
+    n_scenarios: int | None = None
+    inference_time_sec: float | None = None
+
+
+class T5Metrics(pydantic.BaseModel):
+    """T5 — Private-Company Valuation (no market prices)."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T5"
+    granularity: str = "daily"
+    seed: int = 42
+    mape: float | None = None
+    median_ape: float | None = None
+    rank_correlation: float | None = None
+    rank_p_value: float | None = None
+    mape_ci: BootstrapCI | None = None
+    n_predictions: int | None = None
+    n_tickers: int | None = None
+    gap_vs_t2: float | None = None
+    inference_time_sec: float | None = None
+
+
+class T6Metrics(pydantic.BaseModel):
+    """T6 — Generator Evaluation (NL description -> XBRL)."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T6"
+    granularity: str = "daily"
+    seed: int = 42
+    overall_mape: float | None = None
+    per_field_mape: dict[str, float] | None = None
+    success_rate: float | None = None
+    n_fields_matched: int | None = None
+    n_field_misses: int | None = None
+    n_tickers: int | None = None
+    inference_time_sec: float | None = None
+
+
+class T7Metrics(pydantic.BaseModel):
+    """T7 — Real-Estate Valuation."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    method_id: str
+    task: str = "T7"
+    granularity: str = "daily"
+    seed: int = 42
+    rent_MAPE: float | None = None
+    price_MAPE: float | None = None
+    rent_median_APE: float | None = None
+    price_median_APE: float | None = None
+    rent_n_valid: int | None = None
+    price_n_valid: int | None = None
+    n_predictions: int | None = None
+    inference_time_sec: float | None = None
+
+
+# ── Family-level container ────────────────────────────────────────────────
+
+
+class FamilyResults(pydantic.BaseModel):
+    """Container emitted by each family's ``run_all_*()`` function."""
+
+    model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
+
+    family: str
+    panel_version: str | None = None
+    methods: dict[str, list[dict]] = pydantic.Field(default_factory=dict)
+
+
+# ── Task dispatch map ─────────────────────────────────────────────────────
+
+
+TASK_RESULT_TYPES: dict[str, type[pydantic.BaseModel]] = {
+    "T1": T1Metrics,
+    "T2": T2Metrics,
+    "T3": T3Metrics,
+    "T4": T4Metrics,
+    "T5": T5Metrics,
+    "T6": T6Metrics,
+    "T7": T7Metrics,
+}

code/experiments/run_all.py

@@ -0,0 +1,1041 @@
+"""Phase-4 unified-API experiment orchestrator.
+
+Thin runner that ties together:
+
+    data (``ml.load``) -> method (``ml.methods.<Class>``)
+                       -> eval (``ml.score``)
+                       -> :class:`macrolens.RunRecord`
+                       -> JSON via ``pydantic.TypeAdapter``.
+
+Every choice mirrors the unified-API plan §6 (RunRecord), §7 (Determinism
+flag), and Phase-4 Pipeline B pseudocode.
+
+Hard rules:
+
+* Zero benchmark-data IO outside ``ml.load`` (this file is a leaf consumer).
+* Methods/eval are accessed strictly via :mod:`macrolens` (no reaching into
+  private internals).
+* The runner does NOT override hyperparameters except for two cases:
+  (i) T1 + ``Persistence`` — the runner reads the actual ``close`` index
+  out of ``meta_test.attrs["feature_names"]`` and overrides
+  ``PersistenceConfig.close_feature_idx``;
+  (ii) opt-in ``--config-override`` flag (e.g. ``lightgbm.n_estimators=20``)
+  for fast smoke tests.
+* LLM/LLM-TS/LLM-FT method families require an externally-managed vLLM
+  HTTP endpoint (one ``vllm serve`` per HF model id). The runner reads the
+  endpoint URL from a per-method environment variable
+  (``MACROLENS_LLM_BASE_URL_<NAME>`` — see :func:`_resolve_llm_engine`),
+  constructs one :class:`methods._openai_engine.OpenAIChatEngine` per
+  ``(method_id, model_id)`` pair, and injects it via the ``engine=``
+  ctor kwarg. If no endpoint is configured for an LLM-family method, the
+  runner emits ``status="skip"`` with a clear ``error`` message — there
+  is NO silent fallback to a dry-run engine.
+
+Usage::
+
+    python -m projects.agent_builder.scripts.whatif_bench.experiments \\
+        --task T1 T2 \\
+        --method persistence log_size_ols lightgbm \\
+        --granularity daily --seeds 42 --no-checkpoint
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import logging
+import os
+import platform
+import subprocess
+import sys
+import time
+import traceback
+import tracemalloc
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Iterable
+
+import pydantic
+
+from .. import config
+from .. import macrolens as ml
+from ..macrolens import RunRecord
+from . import panel as panel_module
+
+logger = logging.getLogger(__name__)
+
+
+# ── Constants ─────────────────────────────────────────────────────────────
+
+
+# Method families that talk to an externally-managed vLLM HTTP endpoint.
+# The runner resolves one ``OpenAIChatEngine`` per family member from
+# ``MACROLENS_LLM_BASE_URL_<NAME>`` and injects it via ``engine=``.
+_LLM_FAMILIES: frozenset[str] = frozenset({"llm", "llm_ts", "llm_ft"})
+
+# Hard cap on how much traceback text is recorded on a failed RunRecord
+# so the result JSON stays bounded even when stack traces are huge.
+_TRACEBACK_TRUNCATE_BYTES: int = 4 * 1024
+
+
+# ── LLM engine resolution (env-var → OpenAIChatEngine) ────────────────────
+
+
+def _llm_endpoint_env_var(method_id: str) -> str:
+    """Canonical env-var name for a given LLM-family method id.
+
+    Mapping rule: uppercase the method id and prefix with
+    ``MACROLENS_LLM_BASE_URL_``. Examples::
+
+        llama_scout    -> MACROLENS_LLM_BASE_URL_LLAMA_SCOUT
+        gemma4         -> MACROLENS_LLM_BASE_URL_GEMMA4
+        chattime       -> MACROLENS_LLM_BASE_URL_CHATTIME
+        time_mqa       -> MACROLENS_LLM_BASE_URL_TIME_MQA
+        llm_finetuned  -> MACROLENS_LLM_BASE_URL_LLM_FINETUNED
+    """
+    return f"MACROLENS_LLM_BASE_URL_{method_id.upper()}"
+
+
+# Process-global cache: one OpenAIChatEngine per (env-var, model_id) pair
+# so all (task, seed) cells reuse the same HTTP client.
+_LLM_ENGINE_CACHE: dict[tuple[str, str], Any] = {}
+
+
+def _resolve_llm_engine(
+    method_id: str, cls: type,
+) -> tuple[Any | None, str | None]:
+    """Return ``(engine, error)`` for one LLM-family method.
+
+    Reads the endpoint URL from ``MACROLENS_LLM_BASE_URL_<METHOD_ID>``.
+    If unset, returns ``(None, "<reason>")`` so the runner can emit a
+    ``status="skip"`` record. If set, constructs (or returns the cached)
+    :class:`methods._openai_engine.OpenAIChatEngine` and returns it.
+
+    Exception: methods whose authors' inference code is fundamentally
+    incompatible with the OpenAI chat API (ChatTime's 10K-bin numeric
+    tokenisation; Time-MQA's LoRA prompt protocol) are loaded in-process
+    from the vendored authors' code via a dedicated engine wrapper. They
+    do not require an env-var endpoint.
+    """
+    # In-process engines for methods that can't be served via vllm-serve.
+    if method_id == "chattime":
+        try:
+            cfg = cls.default_config()
+            model_id = getattr(cfg, "model_id", "") or "ChengsenWang/ChatTime-1-7B-Chat"
+        except Exception:
+            model_id = "ChengsenWang/ChatTime-1-7B-Chat"
+        cache_key = ("inprocess:chattime", model_id)
+        cached = _LLM_ENGINE_CACHE.get(cache_key)
+        if cached is not None:
+            return cached, None
+        try:
+            from ..methods._chattime_engine import ChatTimeEngine
+            engine = ChatTimeEngine(model_path=model_id)
+        except Exception as exc:
+            return None, f"ChatTimeEngine construction failed: {exc!r}"
+        _LLM_ENGINE_CACHE[cache_key] = engine
+        return engine, None
+
+    env_var = _llm_endpoint_env_var(method_id)
+    base_url = os.environ.get(env_var, "").strip()
+    if not base_url:
+        return (
+            None,
+            f"No endpoint configured for {method_id}; "
+            f"set {env_var}=http://<host>:<port>/v1",
+        )
+
+    # Pull the model_id from the method's default config so the engine
+    # can target the matching ``model`` field on the vLLM endpoint.
+    try:
+        cfg = cls.default_config()
+        model_id = getattr(cfg, "model_id", "") or method_id
+    except Exception:
+        model_id = method_id
+
+    cache_key = (base_url, model_id)
+    cached = _LLM_ENGINE_CACHE.get(cache_key)
+    if cached is not None:
+        return cached, None
+
+    try:
+        from ..methods._openai_engine import OpenAIChatEngine
+    except ImportError as exc:  # pragma: no cover -- defensive
+        return None, f"OpenAI client import failed: {exc!r}"
+
+    api_key = os.environ.get("MACROLENS_LLM_API_KEY", "EMPTY") or "EMPTY"
+    n_workers = int(os.environ.get("MACROLENS_LLM_N_WORKERS", "8"))
+    timeout = float(os.environ.get("MACROLENS_LLM_TIMEOUT_SEC", "300"))
+    try:
+        engine = OpenAIChatEngine(
+            base_url=base_url, api_key=api_key, model_id=model_id,
+            n_workers=n_workers, request_timeout_sec=timeout,
+        )
+    except Exception as exc:
+        return None, f"OpenAIChatEngine construction failed: {exc!r}"
+
+    _LLM_ENGINE_CACHE[cache_key] = engine
+    return engine, None
+
+
+# ── Provenance helpers ────────────────────────────────────────────────────
+
+
+def _git_sha() -> str:
+    """Return the current git SHA, or ``"unknown"`` if outside a git tree."""
+    try:
+        out = subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL,
+        )
+        return out.decode().strip()
+    except Exception:
+        return "unknown"
+
+
+def _detect_hardware() -> dict[str, str]:
+    """Best-effort hardware fingerprint (CPU + GPU + CUDA)."""
+    hw: dict[str, str] = {
+        "cpu": platform.processor() or platform.machine(),
+        "platform": platform.platform(),
+        "python_version": platform.python_version(),
+    }
+    try:
+        import torch  # type: ignore
+
+        hw["torch_version"] = torch.__version__
+        if torch.cuda.is_available():
+            hw["gpu"] = torch.cuda.get_device_name(0)
+            hw["n_gpus"] = str(torch.cuda.device_count())
+            hw["cuda_version"] = str(torch.version.cuda)
+        else:
+            hw["gpu"] = "none"
+            hw["n_gpus"] = "0"
+            hw["cuda_version"] = "n/a"
+    except Exception:
+        hw["gpu"] = "unknown"
+        hw["n_gpus"] = "0"
+        hw["cuda_version"] = "n/a"
+    return hw
+
+
+def _truncate_traceback(exc: BaseException) -> str:
+    tb = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+    if len(tb) > _TRACEBACK_TRUNCATE_BYTES:
+        tb = tb[: _TRACEBACK_TRUNCATE_BYTES - 16] + "\n... [truncated]"
+    return tb
+
+
+def _checkpoint_path(
+    method_id: str, task: str, granularity: str, seed: int,
+    horizon: int | None = None,
+) -> Path:
+    """Canonical per-run checkpoint directory.
+
+    For T1, ``horizon`` is included in the path so multiple horizons
+    on the same (method, task, granularity, seed) tuple each get their
+    own fresh fit/save state and never collide.
+    """
+    base = (
+        Path(__file__).resolve().parent
+        / "checkpoints"
+        / method_id
+        / task
+        / granularity
+        / f"seed={seed}"
+    )
+    if task == "T1" and horizon is not None:
+        base = base / f"h={horizon}"
+    return base
+
+
+def _apply_overrides(config_overrides: dict[str, dict[str, Any]], method_id: str) -> dict[str, Any]:
+    """Return the kwarg dict for one method (post-override)."""
+    return dict(config_overrides.get(method_id, {}))
+
+
+def _now_iso() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat()
+
+
+# ── Inner per-(method, seed) execution ─────────────────────────────────────
+
+
+def _make_failed_record(
+    *,
+    method_id: str,
+    method_family: str,
+    task: str,
+    granularity: str,
+    seed: int,
+    status: str,
+    error: str,
+    n_train: int | None,
+    n_test: int | None,
+    hyperparams: dict[str, Any],
+    artifact_sha256: dict[str, str],
+    deterministic_mode: bool,
+    fit_time_sec: float | None = None,
+    predict_time_sec: float | None = None,
+    peak_mem_mb: float | None = None,
+    ablation_setting: str | None = None,
+) -> RunRecord:
+    return RunRecord(
+        method_id=method_id, method_family=method_family,
+        task=task, granularity=granularity, seed=seed,
+        status=status, error=error,
+        n_train=n_train, n_test=n_test,
+        hyperparams=hyperparams,
+        lib_versions={}, hardware=_detect_hardware(),
+        fit_time_sec=fit_time_sec, predict_time_sec=predict_time_sec,
+        peak_mem_mb=peak_mem_mb, metrics=None,
+        artifact_sha256=artifact_sha256,
+        timestamp=_now_iso(), git_sha=_git_sha(),
+        deterministic_mode=deterministic_mode,
+        ablation_setting=ablation_setting,
+    )
+
+
+def _sanity_gate(
+    task: str,
+    X_test: Any,
+    y_test: Any,
+    y_pred: Any,
+    y_train: Any,
+    meta_test: Any,
+) -> str | None:
+    """Persistence-/constant-floor sanity gate for regression tasks.
+
+    Compares the model's primary metric on the eval set against a trivial
+    reference floor (persistence for T1, train-median/-mean constant for
+    T2/T4/T5/T7). If model_metric > 10× baseline_metric (100× for T1's
+    persistence floor — kept tight because persistence is itself non-trivial)
+    the cell is flagged "suspect" via a returned reason string. T3 and T6
+    are long-form per-field tasks; their per-field MAPE floor is implicitly
+    the SectorMedian baseline already in the panel, so they are skipped here.
+
+    The gate is best-effort: any internal exception or shape mismatch
+    yields ``None`` so the runner never crashes on a sanity probe.
+    """
+    try:
+        import numpy as _np
+    except Exception:  # pragma: no cover -- numpy is a hard dep
+        return None
+
+    try:
+        # ── T1: persistence MSE floor ────────────────────────────────────
+        if task == "T1":
+            y_t = _np.asarray(y_test, dtype=_np.float64)
+            y_p = _np.asarray(y_pred, dtype=_np.float64)
+            close_last = None
+            if hasattr(meta_test, "columns") and "close_last" in meta_test.columns:
+                close_last = _np.asarray(
+                    meta_test["close_last"].values, dtype=_np.float64,
+                )
+            elif hasattr(X_test, "shape") and getattr(X_test, "ndim", 0) == 3:
+                close_last = _np.asarray(X_test[:, -1, -1], dtype=_np.float64)
+            if (close_last is None
+                    or y_t.ndim != 2 or y_p.ndim != 2
+                    or y_t.shape != y_p.shape):
+                return None
+            tile = _np.broadcast_to(close_last[:, None], y_t.shape)
+            pers_mse = float(_np.nanmean((tile - y_t) ** 2))
+            model_mse = float(_np.nanmean((y_p - y_t) ** 2))
+            if not (_np.isfinite(pers_mse) and _np.isfinite(model_mse)
+                    and pers_mse > 0):
+                return None
+            if model_mse > 100.0 * pers_mse:
+                return (
+                    f"T1 SUSPECT: model_MSE={model_mse:.4g} > 100x "
+                    f"persistence_MSE={pers_mse:.4g} on the same eval set; "
+                    "model likely emitting un-normalised raw close instead "
+                    "of per-window log-returns."
+                )
+            return None
+
+        # ── T2 / T5: constant (train-median) MAPE floor ─────────────────
+        if task in ("T2", "T5"):
+            y_tr = _np.asarray(y_train, dtype=_np.float64).ravel()
+            y_t = _np.asarray(y_test, dtype=_np.float64).ravel()
+            y_p = _np.asarray(y_pred, dtype=_np.float64).ravel()
+            if y_t.size == 0 or y_t.shape != y_p.shape:
+                return None
+            const = float(_np.nanmedian(y_tr))
+            if not _np.isfinite(const):
+                return None
+            denom = _np.abs(y_t)
+            mask = _np.isfinite(y_t) & _np.isfinite(y_p) & (denom > 0)
+            if not mask.any():
+                return None
+            const_mape = 100.0 * float(_np.nanmean(
+                _np.abs(const - y_t[mask]) / denom[mask]
+            ))
+            model_mape = 100.0 * float(_np.nanmean(
+                _np.abs(y_p[mask] - y_t[mask]) / denom[mask]
+            ))
+            if not (_np.isfinite(const_mape) and _np.isfinite(model_mape)
+                    and const_mape > 0):
+                return None
+            if model_mape > 10.0 * const_mape:
+                return (
+                    f"{task} SUSPECT: model_MAPE={model_mape:.4g} > 10x "
+                    f"baseline_MAPE={const_mape:.4g} on the same eval set; "
+                    "check method implementation"
+                )
+            return None
+
+        # ── T4: constant (train-mean) MAE floor on return % ─────────────
+        if task == "T4":
+            y_tr = _np.asarray(y_train, dtype=_np.float64).ravel()
+            y_t = _np.asarray(y_test, dtype=_np.float64).ravel()
+            y_p = _np.asarray(y_pred, dtype=_np.float64).ravel()
+            if y_t.size == 0 or y_t.shape != y_p.shape:
+                return None
+            const = float(_np.nanmean(y_tr))
+            if not _np.isfinite(const):
+                return None
+            mask = _np.isfinite(y_t) & _np.isfinite(y_p)
+            if not mask.any():
+                return None
+            const_mae = float(_np.nanmean(_np.abs(const - y_t[mask])))
+            model_mae = float(_np.nanmean(_np.abs(y_p[mask] - y_t[mask])))
+            if not (_np.isfinite(const_mae) and _np.isfinite(model_mae)
+                    and const_mae > 0):
+                return None
+            if model_mae > 10.0 * const_mae:
+                return (
+                    f"T4 SUSPECT: model_MAE={model_mae:.4g} > 10x "
+                    f"baseline_MAE={const_mae:.4g} on the same eval set; "
+                    "check method implementation"
+                )
+            return None
+
+        # ── T7: per-target constant (train-median) MAPE floors ──────────
+        if task == "T7":
+            try:
+                import pandas as _pd
+            except Exception:  # pragma: no cover
+                return None
+            if not (isinstance(y_train, _pd.DataFrame)
+                    and isinstance(y_test, _pd.DataFrame)
+                    and isinstance(y_pred, _pd.DataFrame)):
+                return None
+            if "address" not in y_test.columns or "address" not in y_pred.columns:
+                return None
+            merged = y_test.merge(
+                y_pred, on="address", how="inner",
+                suffixes=("_actual", "_pred"),
+            )
+            if merged.empty:
+                return None
+            for target, pred_col in (("rent", "pred_rent"),
+                                     ("price", "pred_price")):
+                actual_col = target if target in merged.columns else f"{target}_actual"
+                if pred_col not in merged.columns or actual_col not in merged.columns:
+                    continue
+                if target not in y_train.columns:
+                    continue
+                y_tr = _pd.to_numeric(y_train[target], errors="coerce").to_numpy()
+                const = float(_np.nanmedian(y_tr))
+                if not _np.isfinite(const):
+                    continue
+                actual = _pd.to_numeric(merged[actual_col], errors="coerce").to_numpy()
+                pred = _pd.to_numeric(merged[pred_col], errors="coerce").to_numpy()
+                denom = _np.abs(actual)
+                mask = _np.isfinite(actual) & _np.isfinite(pred) & (denom > 0)
+                if not mask.any():
+                    continue
+                const_mape = 100.0 * float(_np.nanmean(
+                    _np.abs(const - actual[mask]) / denom[mask]
+                ))
+                model_mape = 100.0 * float(_np.nanmean(
+                    _np.abs(pred[mask] - actual[mask]) / denom[mask]
+                ))
+                if not (_np.isfinite(const_mape) and _np.isfinite(model_mape)
+                        and const_mape > 0):
+                    continue
+                if model_mape > 10.0 * const_mape:
+                    return (
+                        f"T7 SUSPECT: model_{target}_MAPE={model_mape:.4g} "
+                        f"> 10x baseline_{target}_MAPE={const_mape:.4g} on "
+                        "the same eval set; check method implementation"
+                    )
+            return None
+
+        # T3, T6 (long-form per-field tasks): skipped by design.
+        return None
+    except Exception:  # noqa: BLE001 -- gate is best-effort
+        return None
+
+
+def _run_one(
+    *,
+    method_id: str,
+    cls: type,
+    task: str,
+    granularity: str,
+    seed: int,
+    X_train: Any, y_train: Any, meta_train: Any,
+    X_test: Any, y_test: Any, meta_test: Any,
+    no_checkpoint: bool,
+    deterministic: bool,
+    extra_kwargs: dict[str, Any],
+) -> RunRecord:
+    """Run a single (method, seed) cell on already-loaded data."""
+    method_family = getattr(cls, "family", "unknown")
+    artifact_sha256: dict[str, str] = {
+        **(meta_train.attrs.get("data_sha256") or {}),
+        **(meta_test.attrs.get("data_sha256") or {}),
+    }
+    n_train, n_test = len(X_train), len(X_test)
+    ablation_setting = (
+        meta_test.attrs.get("ablation_setting")
+        if meta_test is not None else None
+    )
+
+    # T1 + Persistence: discover the close-feature index from train meta.
+    ctor_kwargs: dict[str, Any] = dict(extra_kwargs)
+    if task == "T1" and method_id == "persistence":
+        feat_names = meta_test.attrs.get("feature_names") or []
+        if "close" in feat_names:
+            ctor_kwargs["close_feature_idx"] = int(feat_names.index("close"))
+
+    # Ctor.
+    try:
+        model = cls(task=task, **ctor_kwargs)
+    except Exception as exc:  # pragma: no cover -- defensive
+        return _make_failed_record(
+            method_id=method_id, method_family=method_family,
+            task=task, granularity=granularity, seed=seed,
+            status="fit_failed",
+            error=f"ctor: {_truncate_traceback(exc)}",
+            n_train=n_train, n_test=n_test,
+            hyperparams=ctor_kwargs, artifact_sha256=artifact_sha256,
+            deterministic_mode=deterministic,
+            ablation_setting=ablation_setting,
+        )
+
+    # For T1, derive horizon from y_test/y_train shape so the checkpoint path
+    # is horizon-specific. Without this, multiple horizons on the same
+    # (method, task, granularity, seed) tuple share one checkpoint dir; the
+    # first horizon's manifest gets loaded by every subsequent horizon and
+    # the runner silently emits wrong-shape predictions.
+    t1_horizon = None
+    if task == "T1":
+        try:
+            import numpy as _np  # noqa: F401
+            y_ref = y_test if hasattr(y_test, "shape") else y_train
+            if hasattr(y_ref, "shape") and len(y_ref.shape) == 2:
+                t1_horizon = int(y_ref.shape[1])
+        except Exception:
+            t1_horizon = None
+    ckpt = _checkpoint_path(method_id, task, granularity, seed, horizon=t1_horizon)
+    manifest_path = ckpt / "manifest.json"
+
+    fit_time_sec: float | None = None
+    predict_time_sec: float | None = None
+    peak_mem_mb: float | None = None
+
+    # Fit (or load from checkpoint).
+    try:
+        if manifest_path.exists() and not no_checkpoint:
+            model = cls.load(ckpt)  # type: ignore[attr-defined]
+            fit_time_sec = 0.0
+            # cls.load reconstructs state from disk and does NOT preserve
+            # injected runtime resources (the LLM-family engine, etc.).
+            # Re-attach any kwargs the runner originally injected so
+            # ``predict`` does not hit "no engine" failures on a checkpoint
+            # round-trip.
+            for k, v in ctor_kwargs.items():
+                if k in ("task",):
+                    continue
+                setattr(model, k, v)
+            # Also propagate the X_train cache for LLM in-context fitting.
+            if method_family in _LLM_FAMILIES:
+                if hasattr(model, "_X_train"):
+                    model._X_train = X_train
+                if hasattr(model, "_y_train"):
+                    model._y_train = y_train
+        else:
+            tracemalloc.start()
+            t0 = time.perf_counter()
+            model.fit(X_train, y_train, seed=seed)
+            fit_time_sec = time.perf_counter() - t0
+            _, peak = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+            peak_mem_mb = peak / (1024.0 * 1024.0)
+            # Skip writing checkpoint state under ``--no-checkpoint`` —
+            # those files would never be loaded back (the load branch is
+            # gated on ``not no_checkpoint``) and just accumulate.
+            if not no_checkpoint:
+                try:
+                    ckpt.mkdir(parents=True, exist_ok=True)
+                    model.save(ckpt)
+                except Exception:  # save failure is non-fatal for the run
+                    logger.warning("checkpoint save failed for %s/%s/%s", method_id, task, seed)
+    except Exception as exc:
+        return _make_failed_record(
+            method_id=method_id, method_family=method_family,
+            task=task, granularity=granularity, seed=seed,
+            status="fit_failed",
+            error=_truncate_traceback(exc),
+            n_train=n_train, n_test=n_test,
+            hyperparams=model.hyperparams() if hasattr(model, "hyperparams") else ctor_kwargs,
+            artifact_sha256=artifact_sha256,
+            deterministic_mode=deterministic,
+            fit_time_sec=fit_time_sec, peak_mem_mb=peak_mem_mb,
+            ablation_setting=ablation_setting,
+        )
+
+    # Predict.
+    try:
+        t1 = time.perf_counter()
+        y_pred = model.predict(X_test)
+        predict_time_sec = time.perf_counter() - t1
+        # Save y_pred + y_test + meta to parquet/npz so eval can be RE-RUN
+        # later without re-doing the expensive predict step. One file per
+        # (method, task, seed, ablation_setting). Failures are non-fatal.
+        try:
+            import pickle
+            # Predictions are experimental outputs, not dataset content.
+            # Live alongside experiments/results/, not under data_small_caps/.
+            pred_dir = Path(__file__).parent / "predictions"
+            pred_dir.mkdir(parents=True, exist_ok=True)
+            tag = f"{method_id}_{task}_{granularity}_seed{seed}"
+            if task == "T1" and t1_horizon is not None:
+                tag += f"_h{t1_horizon}"
+            if ablation_setting:
+                tag += f"_set{ablation_setting}"
+            pred_path = pred_dir / f"{tag}.pkl"
+            tmp = pred_path.with_suffix(".pkl.tmp")
+            with open(tmp, "wb") as f:
+                pickle.dump({
+                    "method_id": method_id, "task": task, "seed": seed,
+                    "granularity": granularity,
+                    "ablation_setting": ablation_setting,
+                    "y_pred": y_pred,
+                    "y_test": y_test,
+                    "meta_test": meta_test,
+                    "timestamp": _now_iso(),
+                }, f)
+            tmp.replace(pred_path)
+        except Exception:
+            logger.warning("save predictions failed for %s/%s", method_id, task)
+    except Exception as exc:
+        return _make_failed_record(
+            method_id=method_id, method_family=method_family,
+            task=task, granularity=granularity, seed=seed,
+            status="predict_failed",
+            error=_truncate_traceback(exc),
+            n_train=n_train, n_test=n_test,
+            hyperparams=model.hyperparams(), artifact_sha256=artifact_sha256,
+            deterministic_mode=deterministic,
+            fit_time_sec=fit_time_sec, peak_mem_mb=peak_mem_mb,
+            ablation_setting=ablation_setting,
+        )
+
+    # Score.
+    try:
+        # Cluster keys: ticker for T1/T2/T3/T5/T6, scenario_id for T4,
+        # address for T7. Loader ``meta`` always carries the right column.
+        if task == "T4":
+            cluster_keys = (
+                meta_test["scenario_id"].values
+                if "scenario_id" in meta_test.columns
+                else None
+            )
+        elif task == "T7":
+            cluster_keys = (
+                meta_test["address"].values
+                if "address" in meta_test.columns
+                else None
+            )
+        elif "ticker" in meta_test.columns:
+            cluster_keys = meta_test["ticker"].values
+        else:
+            cluster_keys = None
+
+        score_kwargs: dict[str, Any] = {"cluster_keys": cluster_keys}
+        if task == "T1" and "close_last" in meta_test.columns:
+            score_kwargs["close_last"] = meta_test["close_last"].values
+
+        metrics = ml.score(task, y_test, y_pred, **score_kwargs)
+    except Exception as exc:
+        return _make_failed_record(
+            method_id=method_id, method_family=method_family,
+            task=task, granularity=granularity, seed=seed,
+            status="score_failed",
+            error=_truncate_traceback(exc),
+            n_train=n_train, n_test=n_test,
+            hyperparams=model.hyperparams(), artifact_sha256=artifact_sha256,
+            deterministic_mode=deterministic,
+            fit_time_sec=fit_time_sec, predict_time_sec=predict_time_sec,
+            peak_mem_mb=peak_mem_mb,
+            ablation_setting=ablation_setting,
+        )
+
+    # If eval returned a primary metric of None (NaN-only signal — happens
+    # when an LLM emits non-canonical field names so the inner-join finds
+    # 0 valid (ticker, FY, field) tuples), surface the cell as
+    # ``score_failed`` rather than ``status=ok`` with a None metric. This
+    # keeps the no-silent-NaN rule honest at the runner level.
+    _PRIMARY_METRIC = {
+        "T1": "mse", "T2": "median_ape", "T3": "overall_mape",
+        "T4": "return_mae_pct", "T5": "median_ape", "T6": "overall_mape",
+        "T7": "rent_MAPE",
+    }
+    primary_key = _PRIMARY_METRIC.get(task)
+    primary_mv = (metrics or {}).get(primary_key) if primary_key else None
+    primary_value = (
+        primary_mv.value if primary_mv is not None
+        and hasattr(primary_mv, "value") else None
+    )
+    if primary_value is None:
+        return _make_failed_record(
+            method_id=method_id, method_family=method_family,
+            task=task, granularity=granularity, seed=seed,
+            status="score_failed",
+            error=(
+                f"primary metric '{primary_key}' is None on {task}; "
+                "predictions did not produce any valid (canonical) "
+                "match against y_true (e.g. all preds NaN, or non-canonical "
+                "field names). Refusing to record status=ok."
+            ),
+            n_train=n_train, n_test=n_test,
+            hyperparams=model.hyperparams(), artifact_sha256=artifact_sha256,
+            deterministic_mode=deterministic,
+            fit_time_sec=fit_time_sec, predict_time_sec=predict_time_sec,
+            peak_mem_mb=peak_mem_mb,
+            ablation_setting=ablation_setting,
+        )
+
+    # ── Per-task persistence/constant-floor sanity gate ─────────────────
+    # Blow-up guard: when a regression model's primary metric is
+    # >> the trivial-baseline floor on the same eval set it is emitting
+    # nonsense (e.g. T1 trained on raw close instead of log-returns —
+    # MSE 1e10-1e16; T2/T5 mis-scaled valuations; T4 wrong sign on
+    # returns; T7 unit-mixed rent/price). The gate covers T1, T2, T4,
+    # T5, T7. T3 / T6 are long-form per-field tasks whose floor is
+    # implicitly the SectorMedian baseline and are skipped here.
+    suspect_reason: str | None = _sanity_gate(
+        task, X_test, y_test, y_pred, y_train, meta_test,
+    )
+    if suspect_reason is not None:
+        logger.warning(suspect_reason)
+
+    return RunRecord(
+        method_id=method_id, method_family=method_family,
+        task=task, granularity=granularity, seed=seed,
+        status="ok", error=suspect_reason,
+        n_train=n_train, n_test=n_test,
+        hyperparams=model.hyperparams(),
+        lib_versions=model.lib_versions(),
+        hardware=_detect_hardware(),
+        fit_time_sec=fit_time_sec, predict_time_sec=predict_time_sec,
+        peak_mem_mb=peak_mem_mb, metrics=metrics,
+        artifact_sha256=artifact_sha256,
+        timestamp=_now_iso(), git_sha=_git_sha(),
+        deterministic_mode=deterministic,
+        ablation_setting=meta_test.attrs.get("ablation_setting") if meta_test is not None else None,
+    )
+
+
+def _seed_dispatch(args_tuple: tuple) -> RunRecord:
+    """Process-pool entry point — unpack args and call :func:`_run_one`."""
+    return _run_one(**args_tuple)
+
+
+# ── Public API ────────────────────────────────────────────────────────────
+
+
+def run_all(
+    tasks: list[str],
+    methods_list: list[str],
+    granularity: str = "daily",
+    *,
+    seeds: Iterable[int] = (42,),
+    deterministic: bool = False,
+    no_checkpoint: bool = False,
+    multi_seed_parallel: bool = False,
+    config_overrides: dict[str, dict[str, Any]] | None = None,
+    output_path: Path | None = None,
+    setting: str | None = None,
+    horizon: int | None = None,
+    lookback: int | None = None,
+) -> list[RunRecord]:
+    """Run every (task, method, seed) cell and persist :class:`RunRecord` JSON.
+
+    Parameters
+    ----------
+    tasks
+        Task ids in ``{"T1","T2","T3","T4","T5","T6","T7"}``.
+    methods_list
+        Registry ids (matching ``ml.methods.ALL_METHODS`` keys).
+    granularity
+        ``"daily"`` (default) | ``"weekly"`` | ``"monthly"``.
+    seeds
+        Iterable of integer seeds. Default ``(42,)``.
+    deterministic
+        When True, set ``MACROLENS_DETERMINISTIC=1`` and call
+        ``torch.use_deterministic_algorithms(True)`` once before any
+        method runs.
+    no_checkpoint
+        When True, ignore any existing checkpoint and re-train; new
+        checkpoints are still written.
+    multi_seed_parallel
+        When True, dispatch one process per seed via
+        :class:`concurrent.futures.ProcessPoolExecutor`.
+    config_overrides
+        Mapping ``{method_id: {kwarg: value, ...}}`` forwarded to the
+        method ctor (single-step override path used by the runner-side
+        ``--config-override`` flag).
+    output_path
+        When supplied, write the JSON list to this exact path; otherwise
+        write to ``<data_root>/results/<git_sha>_<utc_timestamp>.json``.
+
+    Returns
+    -------
+    list[RunRecord]
+        Every emitted record (including ``status != "ok"`` failures and
+        deferred-LLM ``status == "skip"`` placeholders).
+    """
+    if deterministic:
+        os.environ["MACROLENS_DETERMINISTIC"] = "1"
+        try:
+            import torch  # type: ignore
+            torch.use_deterministic_algorithms(True)
+            if hasattr(torch.backends, "cudnn"):
+                torch.backends.cudnn.deterministic = True
+        except Exception:
+            pass
+
+    overrides = config_overrides or {}
+    seed_list = list(seeds)
+    records: list[RunRecord] = []
+    adapter = pydantic.TypeAdapter(list[RunRecord])
+
+    # Resolve the output path eagerly so we can checkpoint after every cell.
+    if output_path is None:
+        ts = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        sha_short = _git_sha()[:8] if _git_sha() != "unknown" else "nogit"
+        # Experiment outputs live under experiments/, NOT under
+        # data_small_caps/ (raw + derived benchmark data only).
+        results_dir = Path(__file__).resolve().parent / "results"
+        results_dir.mkdir(parents=True, exist_ok=True)
+        output_path = results_dir / f"{sha_short}_{ts}.json"
+    else:
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _flush() -> None:
+        """Atomic-rename incremental write so a SIGTERM mid-run loses ~0 records."""
+        tmp = output_path.with_suffix(".json.tmp")
+        tmp.write_bytes(adapter.dump_json(records, indent=2))
+        tmp.replace(output_path)
+
+    def _log_cell(method_id: str, task_id: str, family: str, status: str,
+                  fit_s: float | None, pred_s: float | None,
+                  metrics: dict | None) -> None:
+        m_str = ""
+        if metrics:
+            primary_keys = ("mse", "mape", "median_ape", "return_mae_pct",
+                            "rent_MAPE", "overall_mape", "n_predictions")
+            for k in primary_keys:
+                if k in metrics and hasattr(metrics[k], "value"):
+                    v = metrics[k].value
+                    m_str = f"  {k}={'None' if v is None else f'{v:.4g}'}"
+                    break
+        ft = f"{fit_s:.1f}s" if fit_s is not None else "-"
+        pt = f"{pred_s:.1f}s" if pred_s is not None else "-"
+        print(f"  [{len(records):>3d}] {family:10s} {method_id:18s} {task_id} "
+              f"status={status:14s} fit={ft:>6s} predict={pt:>6s}{m_str}",
+              flush=True)
+
+    print(f"output_path={output_path}", flush=True)
+
+    if setting is not None:
+        valid = {"A", "B", "C", "D", "E"}
+        if setting not in valid:
+            raise ValueError(f"setting must be in {valid} or None, got {setting!r}")
+        print(f"ablation setting={setting}", flush=True)
+
+    for task in tasks:
+        print(f"\n=== task={task} ===  loading data...", flush=True)
+        t0 = time.perf_counter()
+        load_kwargs: dict[str, Any] = {"granularity": granularity}
+        if horizon is not None and task == "T1":
+            load_kwargs["horizon"] = horizon
+        if lookback is not None and task in ("T1", "T4"):
+            load_kwargs["lookback"] = lookback
+        if setting is not None:
+            if task in ("T3", "T6", "T7"):
+                print(f"  skipping task={task} for ablation (not in ABLATION_TASKS)",
+                      flush=True)
+                continue
+            load_kwargs["setting"] = setting
+        X_train, y_train, meta_train = ml.load(task, "train", **load_kwargs)
+        X_test, y_test, meta_test = ml.load(task, "test", **load_kwargs)
+        print(f"  loaded in {time.perf_counter()-t0:.1f}s  "
+              f"(n_train={len(X_train)}, n_test={len(X_test)})", flush=True)
+
+        for method_name in methods_list:
+            cls = ml.methods.ALL_METHODS.get(method_name)
+            if cls is None:
+                logger.warning("method '%s' not registered; skipping", method_name)
+                continue
+            if task not in cls.tasks:
+                continue  # silent skip per plan
+
+            method_family = getattr(cls, "family", "unknown")
+            extra_kwargs = _apply_overrides(overrides, method_name)
+
+            # LLM/LLM-TS/LLM-FT families require an externally-managed vLLM
+            # HTTP endpoint. Missing endpoint is a hard error — fail loudly
+            # rather than emitting a silent placeholder.
+            if method_family in _LLM_FAMILIES:
+                engine, err = _resolve_llm_engine(method_name, cls)
+                if engine is None:
+                    raise RuntimeError(
+                        f"{method_name} requires an LLM endpoint but "
+                        f"{_llm_endpoint_env_var(method_name)} is unset. "
+                        f"Reason: {err}. Either serve the endpoint and set "
+                        f"the env var, or omit this method from --method."
+                    )
+                # Engine resolved — inject via the ctor kwarg path.
+                extra_kwargs = {**extra_kwargs, "engine": engine}
+
+            if multi_seed_parallel and len(seed_list) > 1:
+                payloads = [
+                    {
+                        "method_id": method_name, "cls": cls,
+                        "task": task, "granularity": granularity, "seed": seed,
+                        "X_train": X_train, "y_train": y_train, "meta_train": meta_train,
+                        "X_test": X_test, "y_test": y_test, "meta_test": meta_test,
+                        "no_checkpoint": no_checkpoint,
+                        "deterministic": deterministic,
+                        "extra_kwargs": extra_kwargs,
+                    }
+                    for seed in seed_list
+                ]
+                with ProcessPoolExecutor(max_workers=len(seed_list)) as ex:
+                    futs = [ex.submit(_seed_dispatch, p) for p in payloads]
+                    for fut in as_completed(futs):
+                        rec = fut.result()
+                        records.append(rec)
+                        _log_cell(method_name, task, method_family, rec.status,
+                                  rec.fit_time_sec, rec.predict_time_sec,
+                                  rec.metrics)
+                        _flush()
+            else:
+                for seed in seed_list:
+                    rec = _run_one(
+                        method_id=method_name, cls=cls,
+                        task=task, granularity=granularity, seed=seed,
+                        X_train=X_train, y_train=y_train, meta_train=meta_train,
+                        X_test=X_test, y_test=y_test, meta_test=meta_test,
+                        no_checkpoint=no_checkpoint,
+                        deterministic=deterministic,
+                        extra_kwargs=extra_kwargs,
+                    )
+                    records.append(rec)
+                    _log_cell(method_name, task, method_family, rec.status,
+                              rec.fit_time_sec, rec.predict_time_sec, rec.metrics)
+                    _flush()
+
+    _flush()
+    logger.info("Wrote %d records to %s", len(records), output_path)
+    print(f"\n=== {len(records)} records written to {output_path} ===", flush=True)
+    return records
+
+
+# ── CLI plumbing (kept here for `python -m experiments.run_all` callers) ──
+
+
+def _parse_overrides(raw: list[str]) -> dict[str, dict[str, Any]]:
+    """Parse ``--config-override 'method.key=value'`` flags into a dict."""
+    overrides: dict[str, dict[str, Any]] = {}
+    for spec in raw:
+        if "=" not in spec or "." not in spec.split("=", 1)[0]:
+            raise ValueError(
+                f"--config-override expects 'method.key=value', got {spec!r}"
+            )
+        lhs, value = spec.split("=", 1)
+        method_id, key = lhs.split(".", 1)
+        # Coerce value: try int, then float, then bool, else str.
+        casted: Any = value
+        for caster in (int, float):
+            try:
+                casted = caster(value)
+                break
+            except ValueError:
+                continue
+        if isinstance(casted, str) and casted.lower() in ("true", "false"):
+            casted = casted.lower() == "true"
+        overrides.setdefault(method_id, {})[key] = casted
+    return overrides
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--task", nargs="+", required=True,
+                        choices=["T1", "T2", "T3", "T4", "T5", "T6", "T7"])
+    parser.add_argument("--method", nargs="+", required=True,
+                        help="Registry method ids (e.g. persistence lightgbm)")
+    parser.add_argument("--granularity", default="daily",
+                        choices=["daily", "weekly", "monthly"])
+    parser.add_argument("--seeds", type=int, nargs="+", default=[42])
+    parser.add_argument("--deterministic", action="store_true")
+    parser.add_argument("--no-checkpoint", action="store_true")
+    parser.add_argument("--multi-seed-parallel", action="store_true")
+    parser.add_argument(
+        "--config-override", action="append", default=[],
+        help=("Override a single method ctor kwarg, e.g. "
+              "'lightgbm.n_estimators=20'. Repeatable."),
+    )
+    parser.add_argument("--output", type=Path, default=None,
+                        help="Optional explicit output path.")
+    parser.add_argument(
+        "--setting", choices=["A", "B", "C", "D", "E"], default=None,
+        help=("Ablation feature-tier (A: OHLCV; B: +Fundamentals; "
+              "C: +Macro; D: +Scenario flags; E: D + filing text in prompt). "
+              "Applies to T1, T2, T4, T5 only; T3/T6/T7 silently skipped."),
+    )
+    parser.add_argument(
+        "--horizon", type=int, default=None,
+        help=("Forecast horizon for T1; ignored for T2-T7. Default: longest "
+              "canonical horizon for the granularity "
+              "(daily=252, weekly=52, monthly=12)."),
+    )
+    parser.add_argument(
+        "--lookback", type=int, default=None,
+        help=("Lookback window length for T1/T4; ignored for non-sequence "
+              "tasks. Default: shortest canonical lookback for the granularity "
+              "(daily=63, weekly=13, monthly=3). Use a longer value (e.g. "
+              "monthly=12) for architectures whose downsample stack needs "
+              "more timesteps."),
+    )
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s  %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    overrides = _parse_overrides(args.config_override)
+    run_all(
+        tasks=args.task, methods_list=args.method,
+        granularity=args.granularity, seeds=args.seeds,
+        deterministic=args.deterministic,
+        no_checkpoint=args.no_checkpoint,
+        multi_seed_parallel=args.multi_seed_parallel,
+        config_overrides=overrides,
+        output_path=args.output,
+        setting=args.setting,
+        horizon=args.horizon,
+        lookback=args.lookback,
+    )
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

code/experiments/run_experiments.sh

@@ -0,0 +1,192 @@
+#!/bin/bash
+# ==================================================================
+# MacroLens: Full Experiment Launch Script (30-method panel)
+# ==================================================================
+# Runs the 28-method panel x 7 tasks x 3 granularities on 4x A100-40GB
+# (physical GPU IDs 5,6,7,8). Other users keep 0-4 for themselves.
+#
+# Usage:
+#   # Quick validation (verify code works, ~4-8h)
+#   bash run_experiments.sh --quick
+#
+#   # Full experiments (all granularities, ~3-5 days)
+#   bash run_experiments.sh --full
+#
+#   # Single family
+#   bash run_experiments.sh --quick --family naive
+# ==================================================================
+
+set -euo pipefail
+
+MODE="${1:---quick}"
+FAMILY="${3:-all}"
+LOG_DIR="/mnt/local/patara/experiment_logs"
+mkdir -p "$LOG_DIR"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+# MacroLens-assigned physical GPU IDs. Single source of truth.
+MACROLENS_GPUS="4,5,6,7"
+
+# Parse mode
+QUICK_FLAG=""
+SEED_FLAGS=""
+case "$MODE" in
+    --quick)
+        QUICK_FLAG="--quick"
+        echo "=== QUICK VALIDATION MODE ==="
+        ;;
+    --full)
+        # Single-seed primary per panel.PRIMARY_SEED; the headline-T1 multi-seed
+        # subset is driven inside the runner by panel.seeds_for().
+        SEED_FLAGS=""
+        echo "=== FULL EXPERIMENT MODE (single-seed primary) ==="
+        ;;
+    *)
+        echo "Usage: $0 [--quick|--full] [--family FAMILY]"
+        exit 1
+        ;;
+esac
+
+# Allow --family as $2
+if [[ "${2:-}" == "--family" ]]; then
+    FAMILY="$3"
+fi
+
+run_family() {
+    local family=$1
+    local gpus=$2   # CUDA_VISIBLE_DEVICES string (physical IDs, e.g. "5,6,7,8")
+    local log="$LOG_DIR/${TIMESTAMP}_${family}.log"
+
+    echo "[$(date +%H:%M:%S)] Starting $family on GPUs $gpus -> $log"
+    CUDA_VISIBLE_DEVICES="$gpus" \
+        nohup uv run python -m projects.agent_builder.scripts.whatif_bench.baselines \
+        $QUICK_FLAG $SEED_FLAGS --family "$family" \
+        > "$log" 2>&1 &
+    echo "  PID: $!"
+}
+
+# ==================================================================
+# Batch 1: CPU-only families (no GPU)
+#   naive, classical, ablation classical arm - all CPU
+# ==================================================================
+run_batch_1() {
+    echo ""
+    echo "=== Batch 1: CPU families ==="
+    run_family "naive" ""
+    run_family "classical" ""
+    wait
+    echo "Batch 1 complete."
+}
+
+# ==================================================================
+# Batch 2: Sequence + TSFM ZS + TSFM FT (share 4 GPUs)
+#   sequence   -> 1 GPU (4)
+#   tsfm ZS    -> 1 GPU (5)
+#   tsfm FT    -> 2 GPUs (6,7)
+# ==================================================================
+run_batch_2() {
+    echo ""
+    echo "=== Batch 2: Sequence + TSFM ZS + TSFM FT ==="
+    run_family "sequence" "4"
+    run_family "tsfm" "5"
+    run_family "tsfm_ft" "6,7"
+    wait
+    echo "Batch 2 complete."
+}
+
+# ==================================================================
+# Batch 3: LLM-TS Multi-Task (ChatTime, ITFormer, Time-MQA)
+# Uses all 4 GPUs since each framework can benefit from parallel inference
+# on the 7B backbone.
+# ==================================================================
+run_batch_3() {
+    echo ""
+    echo "=== Batch 3: LLM-TS Multi-Task ==="
+    run_family "llm_ts_reason" "$MACROLENS_GPUS"
+    wait
+    echo "Batch 3 complete."
+}
+
+# ==================================================================
+# Batch 4: LLM ZS + FT (use all 4 GPUs; ZS first, then FT)
+#   Llama-4 Scout needs tensor-parallel 4 (all GPUs).
+#   Gemma-4 / EXAONE are TP=1 but run sequentially inside the runner.
+# ==================================================================
+run_batch_4() {
+    echo ""
+    echo "=== Batch 4: LLM ZS ==="
+    run_family "llm" "$MACROLENS_GPUS"
+    wait
+
+    echo "=== Batch 4: LLM FT (QLoRA NF4 + ZeRO-2) ==="
+    run_family "llm_ft" "$MACROLENS_GPUS"
+    wait
+    echo "Batch 4 complete."
+}
+
+# ==================================================================
+# Ablation (5 settings x 5 models on T1 h=21 + T4)
+# ==================================================================
+run_ablation() {
+    echo ""
+    echo "=== Ablation (5x5 on T1 h=21 + T4) ==="
+    run_family "ablation" "$MACROLENS_GPUS"
+    wait
+    echo "Ablation complete."
+}
+
+# ==================================================================
+# Multi-granularity (weekly + monthly, after daily completes)
+# ==================================================================
+run_multi_gran() {
+    echo ""
+    echo "=== Multi-granularity: weekly ==="
+    for family in naive classical sequence tsfm tsfm_ft llm_ts_reason llm llm_ft ablation; do
+        CUDA_VISIBLE_DEVICES="$MACROLENS_GPUS" \
+            uv run python -m projects.agent_builder.scripts.whatif_bench.baselines \
+            $QUICK_FLAG $SEED_FLAGS --family "$family" --granularity weekly \
+            >> "$LOG_DIR/${TIMESTAMP}_weekly.log" 2>&1
+    done
+
+    echo "=== Multi-granularity: monthly ==="
+    for family in naive classical sequence tsfm tsfm_ft llm_ts_reason llm llm_ft ablation; do
+        CUDA_VISIBLE_DEVICES="$MACROLENS_GPUS" \
+            uv run python -m projects.agent_builder.scripts.whatif_bench.baselines \
+            $QUICK_FLAG $SEED_FLAGS --family "$family" --granularity monthly \
+            >> "$LOG_DIR/${TIMESTAMP}_monthly.log" 2>&1
+    done
+    echo "Multi-granularity complete."
+}
+
+# ==================================================================
+# Main
+# ==================================================================
+echo "MacroLens Experiments - $MODE  (GPUs: $MACROLENS_GPUS)"
+echo "Logs: $LOG_DIR/${TIMESTAMP}_*.log"
+echo ""
+
+if [[ "$FAMILY" != "all" ]]; then
+    run_family "$FAMILY" "$MACROLENS_GPUS"
+    wait
+else
+    run_batch_1
+    run_batch_2
+    run_batch_3
+    run_batch_4
+    run_ablation
+
+    if [[ "$MODE" == "--full" ]]; then
+        run_multi_gran
+    fi
+fi
+
+echo ""
+echo "=== ALL EXPERIMENTS COMPLETE ==="
+echo "Results: data_small_caps/benchmark/daily/all_results*.json"
+echo "Logs: $LOG_DIR/${TIMESTAMP}_*.log"
+
+echo ""
+echo "=== Generating LaTeX tables ==="
+CUDA_VISIBLE_DEVICES="$MACROLENS_GPUS" \
+    uv run python -m projects.agent_builder.scripts.whatif_bench.baselines.gen_tables
+echo "Tables saved."

code/generate_scenarios.py

@@ -0,0 +1,1746 @@
+"""Layer 3 – Step 9: Detect natural-experiment scenarios from raw macro data.
+
+Reads raw CSVs from ``data/macro/`` (NOT the processed panel) and identifies
+historically significant macro events.  Scenarios are granularity-independent
+calendar-date events.
+
+Output: ``data/benchmark/{granularity}/scenarios.parquet``
+
+Uses all available FRED series + EIA commodity data to detect 49 event types
+covering rates, equity, commodities, FX, inflation, labor, credit, housing,
+money supply, financial conditions, and cross-asset composite signals.
+Short-term (5-day) and medium-term (21-day) windows are used for daily series.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------------
+
+def _load_fred(series_id: str) -> pd.DataFrame:
+    """Load a single FRED CSV, returning (date, value) DataFrame."""
+    path = config.MACRO_DIR / f"fred_{series_id}.csv"
+    if not path.exists():
+        return pd.DataFrame(columns=["date", "value"])
+    df = pd.read_csv(path)
+    if "date" not in df.columns:
+        return pd.DataFrame(columns=["date", "value"])
+    df["date"] = pd.to_datetime(df["date"])
+    non_date = [c for c in df.columns if c != "date"]
+    if not non_date:
+        return pd.DataFrame(columns=["date", "value"])
+    val_col = series_id if series_id in df.columns else non_date[0]
+    df = df[["date", val_col]].rename(columns={val_col: "value"})
+    df["value"] = pd.to_numeric(df["value"], errors="coerce")
+    return df.dropna(subset=["value"]).sort_values("date").reset_index(drop=True)
+
+
+def _load_commodity_spot(subdir: str, candidates: list[str]) -> pd.DataFrame:
+    """Load a commodity spot CSV from a macro subdirectory."""
+    commodity_dir = config.MACRO_DIR / subdir
+    if not commodity_dir.is_dir():
+        return pd.DataFrame(columns=["date", "value"])
+    for candidate in candidates:
+        path = commodity_dir / candidate
+        if not path.exists():
+            continue
+        df = pd.read_csv(path)
+        date_col = next((c for c in df.columns if "time" in c.lower() or "date" in c.lower()), None)
+        if date_col is None:
+            continue
+        num_cols = df.select_dtypes(include="number").columns.tolist()
+        val_col = next((c for c in df.columns if c != date_col and "spot" in c.lower()), None)
+        if val_col is None and num_cols:
+            val_col = num_cols[0]
+        if val_col is None:
+            continue
+        df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+        df = df[[date_col, val_col]].rename(columns={date_col: "date", val_col: "value"})
+        df["value"] = pd.to_numeric(df["value"], errors="coerce")
+        return df.dropna(subset=["value"]).sort_values("date").reset_index(drop=True)
+    return pd.DataFrame(columns=["date", "value"])
+
+
+def _load_crude_spot() -> pd.DataFrame:
+    return _load_commodity_spot("crude_oil", ["crude_spot_daily.csv"])
+
+
+def _load_natgas_spot() -> pd.DataFrame:
+    return _load_commodity_spot("natural_gas", [
+        "natural_gas_spot_weekly.csv",
+        "natural_gas_spot_daily.csv",
+    ])
+
+
+# ------------------------------------------------------------------
+# Detectors
+# ------------------------------------------------------------------
+
+def _detect_fed_rate_changes(df: pd.DataFrame) -> list[dict]:
+    """Detect FEDFUNDS changes >= SCENARIO_FEDFUNDS_DELTA between consecutive observations."""
+    if df.empty:
+        return []
+    events = []
+    delta = config.SCENARIO_FEDFUNDS_DELTA
+    prev_val = df["value"].iloc[0]
+    for _, row in df.iloc[1:].iterrows():
+        change = row["value"] - prev_val
+        if abs(change) >= delta:
+            direction = "raised" if change > 0 else "lowered"
+            events.append({
+                "event_type": "fed_rate_change",
+                "event_date": row["date"],
+                "event_description": (
+                    f"On {row['date'].date()}, the Fed {direction} rates by "
+                    f"{abs(change)*100:.0f}bps to {row['value']:.2f}%."
+                ),
+            })
+        prev_val = row["value"]
+    return events
+
+
+def _detect_vix_spikes(df: pd.DataFrame) -> list[dict]:
+    """Detect VIX > ratio * rolling mean."""
+    if len(df) < config.SCENARIO_VIX_ROLLING_WINDOW:
+        return []
+    events = []
+    ratio = config.SCENARIO_VIX_SPIKE_RATIO
+    window = config.SCENARIO_VIX_ROLLING_WINDOW
+    df = df.copy()
+    df["rolling_mean"] = df["value"].rolling(window, min_periods=window).mean()
+    df = df.dropna(subset=["rolling_mean"])
+    spike_mask = df["value"] > ratio * df["rolling_mean"]
+    # Group consecutive spike days; take the first day of each group
+    if spike_mask.any():
+        spike_idx = spike_mask[spike_mask].index
+        groups: list[list[int]] = []
+        current: list[int] = [spike_idx[0]]
+        for i in spike_idx[1:]:
+            if i == current[-1] + 1:
+                current.append(i)
+            else:
+                groups.append(current)
+                current = [i]
+        groups.append(current)
+        for g in groups:
+            row = df.loc[g[0]]
+            events.append({
+                "event_type": "vix_spike",
+                "event_date": row["date"],
+                "event_description": (
+                    f"On {row['date'].date()}, VIX spiked to {row['value']:.1f} "
+                    f"({row['value']/row['rolling_mean']:.1f}x its {window}-day average of "
+                    f"{row['rolling_mean']:.1f})."
+                ),
+            })
+    return events
+
+
+def _detect_oil_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect crude-oil moves >= threshold over rolling window."""
+    if len(df) < config.SCENARIO_OIL_ROLLING_WINDOW:
+        return []
+    events = []
+    window = config.SCENARIO_OIL_ROLLING_WINDOW
+    pct = config.SCENARIO_OIL_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return events
+    # De-duplicate: keep events at least `window` days apart
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "oil_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, crude oil {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over the prior {window} trading days "
+                f"to ${row['value']:.2f}/bbl."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_market_drawdowns(df: pd.DataFrame) -> list[dict]:
+    """Detect S&P 500 drops >= threshold over rolling window."""
+    if len(df) < config.SCENARIO_SP500_ROLLING_WINDOW:
+        return []
+    events = []
+    window = config.SCENARIO_SP500_ROLLING_WINDOW
+    pct = config.SCENARIO_SP500_DRAWDOWN
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    drops = df[df["pct_change"] <= -pct].copy()
+    if drops.empty:
+        return events
+    prev_date = None
+    for _, row in drops.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        events.append({
+            "event_type": "market_drawdown",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the S&P 500 dropped "
+                f"{abs(row['pct_change'])*100:.1f}% over the prior {window} trading days "
+                f"to {row['value']:.0f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_natgas_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect natural-gas spot moves >= threshold over rolling window."""
+    window = config.SCENARIO_NATGAS_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_NATGAS_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window * 7:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "natgas_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, natural gas {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over the prior {window} periods "
+                f"to ${row['value']:.2f}/MMBtu."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_nasdaq_moves(df: pd.DataFrame) -> list[dict]:
+    """Detect NASDAQ large moves (crashes or rallies) over rolling window."""
+    window = config.SCENARIO_NASDAQ_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_NASDAQ_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "rallied" if row["pct_change"] > 0 else "dropped"
+        events.append({
+            "event_type": "nasdaq_move",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the NASDAQ Composite {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over the prior {window} trading days "
+                f"to {row['value']:.0f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_yield_curve_events(dgs10: pd.DataFrame, dgs2: pd.DataFrame) -> list[dict]:
+    """Detect yield curve inversions and steep re-steepening events."""
+    if dgs10.empty or dgs2.empty:
+        return []
+    merged = pd.merge(dgs10, dgs2, on="date", suffixes=("_10y", "_2y"))
+    if merged.empty:
+        return []
+    merged = merged.sort_values("date").reset_index(drop=True)
+    merged["spread"] = merged["value_10y"] - merged["value_2y"]
+
+    window = config.SCENARIO_YIELD_CURVE_WINDOW
+    events = []
+
+    # Detect inversions: spread crosses below 0
+    merged["prev_spread"] = merged["spread"].shift(1)
+    inversions = merged[
+        (merged["spread"] < config.SCENARIO_YIELD_CURVE_INVERSION) &
+        (merged["prev_spread"] >= config.SCENARIO_YIELD_CURVE_INVERSION)
+    ]
+    prev_date = None
+    for _, row in inversions.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        events.append({
+            "event_type": "yield_curve_event",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the yield curve inverted: "
+                f"10Y-2Y spread fell to {row['spread']*100:.0f}bps "
+                f"(10Y={row['value_10y']:.2f}%, 2Y={row['value_2y']:.2f}%)."
+            ),
+        })
+        prev_date = row["date"]
+
+    # Detect un-inversions: spread crosses back above 0
+    un_inversions = merged[
+        (merged["spread"] >= config.SCENARIO_YIELD_CURVE_INVERSION) &
+        (merged["prev_spread"] < config.SCENARIO_YIELD_CURVE_INVERSION)
+    ]
+    prev_date = None
+    for _, row in un_inversions.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        events.append({
+            "event_type": "yield_curve_event",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the yield curve un-inverted: "
+                f"10Y-2Y spread recovered to {row['spread']*100:.0f}bps "
+                f"(10Y={row['value_10y']:.2f}%, 2Y={row['value_2y']:.2f}%)."
+            ),
+        })
+        prev_date = row["date"]
+
+    # Detect large steepening/flattening moves
+    if len(merged) > window:
+        merged["spread_change"] = merged["spread"] - merged["spread"].shift(window)
+        threshold = config.SCENARIO_YIELD_CURVE_STEEPENING
+        large = merged[merged["spread_change"].abs() >= threshold].dropna(subset=["spread_change"])
+        prev_date = None
+        for _, row in large.iterrows():
+            if prev_date is not None and (row["date"] - prev_date).days < window:
+                continue
+            direction = "steepened" if row["spread_change"] > 0 else "flattened"
+            events.append({
+                "event_type": "yield_curve_event",
+                "event_date": row["date"],
+                "event_description": (
+                    f"On {row['date'].date()}, the yield curve {direction} by "
+                    f"{abs(row['spread_change'])*100:.0f}bps over {window} days: "
+                    f"10Y-2Y spread at {row['spread']*100:.0f}bps."
+                ),
+            })
+            prev_date = row["date"]
+
+    return events
+
+
+def _detect_treasury_rate_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large moves in the 10-year Treasury yield."""
+    window = config.SCENARIO_DGS10_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    delta = config.SCENARIO_DGS10_DELTA
+    df = df.copy()
+    df["abs_change"] = df["value"] - df["value"].shift(window)
+    large = df[df["abs_change"].abs() >= delta].dropna(subset=["abs_change"])
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "surged" if row["abs_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "treasury_rate_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the 10-year Treasury yield {direction} "
+                f"{abs(row['abs_change'])*100:.0f}bps over {window} trading days "
+                f"to {row['value']:.2f}%."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_usd_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large moves in the trade-weighted USD index."""
+    window = config.SCENARIO_USD_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_USD_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "strengthened" if row["pct_change"] > 0 else "weakened"
+        events.append({
+            "event_type": "usd_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the trade-weighted USD {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} trading days "
+                f"to {row['value']:.1f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# Generic helpers for monthly / weekly series
+# ------------------------------------------------------------------
+
+def _detect_mom_change(df: pd.DataFrame, event_type: str, label: str,
+                       threshold: float, unit: str = "", fmt: str = ".1f",
+                       de_dup_days: int = 28) -> list[dict]:
+    """Generic month-over-month percentage change detector."""
+    if len(df) < 2:
+        return []
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change()
+    large = df[df["pct_change"].abs() >= threshold].dropna(subset=["pct_change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < de_dup_days:
+            continue
+        direction = "jumped" if row["pct_change"] > 0 else "dropped"
+        events.append({
+            "event_type": event_type,
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {label} {direction} "
+                f"{abs(row['pct_change'])*100:{fmt}}% month-over-month "
+                f"to {row['value']:{fmt}}{unit}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_level_change(df: pd.DataFrame, event_type: str, label: str,
+                         delta: float, window: int, unit: str = "%",
+                         de_dup_days: int | None = None) -> list[dict]:
+    """Generic absolute level change detector over a rolling window."""
+    if len(df) < window:
+        return []
+    de_dup = de_dup_days or window
+    df = df.copy()
+    df["abs_change"] = df["value"] - df["value"].shift(window)
+    large = df[df["abs_change"].abs() >= delta].dropna(subset=["abs_change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < de_dup:
+            continue
+        direction = "surged" if row["abs_change"] > 0 else "plunged"
+        events.append({
+            "event_type": event_type,
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {label} {direction} "
+                f"{abs(row['abs_change'])*100:.0f}bps over {window} periods "
+                f"to {row['value']:.2f}{unit}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_spike_ratio(df: pd.DataFrame, event_type: str, label: str,
+                        ratio: float, window: int, unit: str = "",
+                        de_dup_days: int | None = None) -> list[dict]:
+    """Generic spike detector: value > ratio * rolling mean."""
+    if len(df) < window:
+        return []
+    de_dup = de_dup_days or window * 7
+    df = df.copy()
+    df["rolling_mean"] = df["value"].rolling(window, min_periods=window).mean()
+    df = df.dropna(subset=["rolling_mean"])
+    spike_mask = df["value"] > ratio * df["rolling_mean"]
+    if not spike_mask.any():
+        return []
+    events = []
+    spike_df = df[spike_mask]
+    prev_date = None
+    for _, row in spike_df.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < de_dup:
+            continue
+        events.append({
+            "event_type": event_type,
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {label} spiked to {row['value']:.0f}{unit} "
+                f"({row['value']/row['rolling_mean']:.1f}x its {window}-period average "
+                f"of {row['rolling_mean']:.0f}{unit})."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# New detectors: inflation, labor, credit, housing, etc.
+# ------------------------------------------------------------------
+
+def _detect_cpi_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large CPI month-over-month changes."""
+    return _detect_mom_change(df, "inflation_shock", "CPI",
+                              config.SCENARIO_CPI_MOM_THRESHOLD, fmt=".2f")
+
+
+def _detect_ppi_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large PPI month-over-month changes."""
+    return _detect_mom_change(df, "ppi_shock", "PPI",
+                              config.SCENARIO_PPI_MOM_THRESHOLD, fmt=".1f")
+
+
+def _detect_unemployment_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect unemployment rate jumps."""
+    if len(df) < 2:
+        return []
+    df = df.copy()
+    df["change"] = df["value"].diff()
+    large = df[df["change"].abs() >= config.SCENARIO_UNRATE_DELTA].dropna(subset=["change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 28:
+            continue
+        direction = "rose" if row["change"] > 0 else "fell"
+        events.append({
+            "event_type": "unemployment_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the unemployment rate {direction} "
+                f"{abs(row['change']):.1f}pp to {row['value']:.1f}%."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_jobless_claims_spikes(df: pd.DataFrame) -> list[dict]:
+    """Detect spikes in initial jobless claims."""
+    return _detect_spike_ratio(df, "jobless_claims_spike", "initial jobless claims",
+                               config.SCENARIO_ICSA_SPIKE_RATIO,
+                               config.SCENARIO_ICSA_ROLLING_WINDOW,
+                               unit="K", de_dup_days=28)
+
+
+def _detect_payroll_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in nonfarm payrolls."""
+    return _detect_mom_change(df, "payroll_shock", "nonfarm payrolls",
+                              config.SCENARIO_PAYROLLS_DELTA, fmt=".1f")
+
+
+def _detect_hy_spread_events(df: pd.DataFrame) -> list[dict]:
+    """Detect high-yield credit spread blow-outs."""
+    return _detect_level_change(df, "hy_spread_event", "the high-yield credit spread",
+                                config.SCENARIO_HY_SPREAD_DELTA,
+                                config.SCENARIO_HY_SPREAD_WINDOW)
+
+
+def _detect_ig_spread_events(df: pd.DataFrame) -> list[dict]:
+    """Detect investment-grade corporate spread moves."""
+    return _detect_level_change(df, "ig_spread_event", "the IG corporate spread",
+                                config.SCENARIO_IG_SPREAD_DELTA,
+                                config.SCENARIO_IG_SPREAD_WINDOW)
+
+
+def _detect_ted_spread_spikes(df: pd.DataFrame) -> list[dict]:
+    """Detect TED spread crossing above threshold."""
+    if df.empty:
+        return []
+    df = df.copy()
+    df["prev"] = df["value"].shift(1)
+    crossings = df[(df["value"] >= config.SCENARIO_TED_SPIKE) &
+                   (df["prev"] < config.SCENARIO_TED_SPIKE)].dropna(subset=["prev"])
+    events = []
+    prev_date = None
+    for _, row in crossings.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 30:
+            continue
+        events.append({
+            "event_type": "ted_spread_spike",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the TED spread spiked to "
+                f"{row['value']*100:.0f}bps, signaling interbank stress."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_financial_stress(df: pd.DataFrame) -> list[dict]:
+    """Detect financial stress index exceeding threshold."""
+    if df.empty:
+        return []
+    threshold = config.SCENARIO_FSI_THRESHOLD
+    df = df.copy()
+    df["prev"] = df["value"].shift(1)
+    crossings = df[(df["value"] >= threshold) &
+                   (df["prev"] < threshold)].dropna(subset=["prev"])
+    events = []
+    prev_date = None
+    for _, row in crossings.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        events.append({
+            "event_type": "financial_stress",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the St. Louis Fed Financial Stress Index "
+                f"rose to {row['value']:.2f}, indicating elevated systemic stress."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_mortgage_rate_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large moves in 30-year mortgage rates."""
+    return _detect_level_change(df, "mortgage_rate_shock", "the 30-year mortgage rate",
+                                config.SCENARIO_MORTGAGE_DELTA,
+                                config.SCENARIO_MORTGAGE_ROLLING_WINDOW)
+
+
+def _detect_sentiment_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large drops in consumer sentiment."""
+    if len(df) < config.SCENARIO_SENTIMENT_ROLLING_WINDOW + 1:
+        return []
+    df = df.copy()
+    w = config.SCENARIO_SENTIMENT_ROLLING_WINDOW
+    df["pct_change"] = df["value"].pct_change(periods=w)
+    large = df[df["pct_change"].abs() >= config.SCENARIO_SENTIMENT_PCT_CHANGE].dropna(subset=["pct_change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 28:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "sentiment_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, U. of Michigan Consumer Sentiment {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% to {row['value']:.1f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_industrial_production_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large changes in industrial production."""
+    return _detect_mom_change(df, "industrial_production_shock", "industrial production",
+                              config.SCENARIO_INDPRO_PCT_CHANGE, fmt=".1f")
+
+
+def _detect_retail_sales_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large changes in retail sales."""
+    return _detect_mom_change(df, "retail_sales_shock", "retail sales",
+                              config.SCENARIO_RETAIL_PCT_CHANGE,
+                              unit="B", fmt=".0f")
+
+
+def _detect_housing_starts_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large changes in housing starts."""
+    return _detect_mom_change(df, "housing_starts_shock", "housing starts",
+                              config.SCENARIO_HOUSING_PCT_CHANGE, fmt=".0f",
+                              de_dup_days=28)
+
+
+def _detect_home_price_events(df: pd.DataFrame) -> list[dict]:
+    """Detect Case-Shiller home price acceleration/deceleration."""
+    if len(df) < 13:
+        return []
+    df = df.copy()
+    df["yoy"] = df["value"].pct_change(periods=12)
+    df["yoy_change"] = df["yoy"] - df["yoy"].shift(3)
+    large = df[df["yoy_change"].abs() >= config.SCENARIO_HOME_PRICE_YOY_DELTA].dropna(subset=["yoy_change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        direction = "accelerated" if row["yoy_change"] > 0 else "decelerated"
+        events.append({
+            "event_type": "home_price_event",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, U.S. home price growth {direction}: "
+                f"YoY rate shifted {row['yoy_change']*100:+.1f}pp to "
+                f"{row['yoy']*100:.1f}% (Case-Shiller index at {row['value']:.1f})."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_m2_events(df: pd.DataFrame) -> list[dict]:
+    """Detect M2 money supply contraction or surge."""
+    if len(df) < 13:
+        return []
+    df = df.copy()
+    df["yoy"] = df["value"].pct_change(periods=12)
+    events = []
+    prev_date = None
+    # Detect contraction
+    contracting = df[df["yoy"] <= config.SCENARIO_M2_YOY_THRESHOLD].dropna(subset=["yoy"])
+    for _, row in contracting.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        events.append({
+            "event_type": "m2_contraction",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, M2 money supply contracted "
+                f"{abs(row['yoy'])*100:.1f}% year-over-year to "
+                f"${row['value']/1e6:.2f}T, a rare monetary tightening signal."
+            ),
+        })
+        prev_date = row["date"]
+    # Detect surges (>10% YoY)
+    prev_date = None
+    surging = df[df["yoy"] >= 0.10].dropna(subset=["yoy"])
+    for _, row in surging.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        events.append({
+            "event_type": "m2_surge",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, M2 money supply surged "
+                f"{row['yoy']*100:.1f}% year-over-year to "
+                f"${row['value']/1e6:.2f}T, signaling aggressive monetary expansion."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_dgs30_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large moves in the 30-year Treasury yield."""
+    return _detect_level_change(df, "long_bond_shock", "the 30-year Treasury yield",
+                                config.SCENARIO_DGS30_DELTA,
+                                config.SCENARIO_DGS30_ROLLING_WINDOW)
+
+
+def _detect_sp_nasdaq_divergence(sp: pd.DataFrame, nq: pd.DataFrame) -> list[dict]:
+    """Detect S&P 500 vs NASDAQ divergence (sector rotation signals)."""
+    if sp.empty or nq.empty:
+        return []
+    merged = pd.merge(sp, nq, on="date", suffixes=("_sp", "_nq")).sort_values("date")
+    if len(merged) < config.SCENARIO_SP_NASDAQ_WINDOW:
+        return []
+    w = config.SCENARIO_SP_NASDAQ_WINDOW
+    merged["sp_ret"] = merged["value_sp"].pct_change(periods=w)
+    merged["nq_ret"] = merged["value_nq"].pct_change(periods=w)
+    merged["divergence"] = merged["nq_ret"] - merged["sp_ret"]
+    large = merged[merged["divergence"].abs() >= config.SCENARIO_SP_NASDAQ_DIVERGENCE].dropna(subset=["divergence"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < w:
+            continue
+        if row["divergence"] > 0:
+            desc = f"NASDAQ outperformed S&P 500 by {row['divergence']*100:.1f}pp"
+        else:
+            desc = f"NASDAQ underperformed S&P 500 by {abs(row['divergence'])*100:.1f}pp"
+        events.append({
+            "event_type": "sector_rotation",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {desc} over {w} trading days "
+                f"(NASDAQ {row['nq_ret']*100:+.1f}% vs S&P {row['sp_ret']*100:+.1f}%), "
+                f"signaling sector rotation."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_vix_regime_change(df: pd.DataFrame) -> list[dict]:
+    """Detect sustained elevated VIX (regime change)."""
+    if df.empty:
+        return []
+    threshold = config.SCENARIO_VIX_REGIME_THRESHOLD
+    min_days = config.SCENARIO_VIX_REGIME_MIN_DAYS
+    df = df.copy()
+    df["elevated"] = df["value"] >= threshold
+    events = []
+    in_regime = False
+    start_date = None
+    for _, row in df.iterrows():
+        if row["elevated"] and not in_regime:
+            in_regime = True
+            start_date = row["date"]
+        elif not row["elevated"] and in_regime:
+            duration = (row["date"] - start_date).days
+            if duration >= min_days:
+                events.append({
+                    "event_type": "volatility_regime",
+                    "event_date": start_date,
+                    "event_description": (
+                        f"Starting {start_date.date()}, VIX remained above "
+                        f"{threshold:.0f} for {duration} consecutive days, "
+                        f"indicating a sustained high-volatility regime."
+                    ),
+                })
+            in_regime = False
+    # Handle ongoing regime at end of data
+    if in_regime and start_date is not None:
+        duration = (df["date"].iloc[-1] - start_date).days
+        if duration >= min_days:
+            events.append({
+                "event_type": "volatility_regime",
+                "event_date": start_date,
+                "event_description": (
+                    f"Starting {start_date.date()}, VIX remained above "
+                    f"{threshold:.0f} for {duration}+ days (ongoing), "
+                    f"indicating a sustained high-volatility regime."
+                ),
+            })
+    return events
+
+
+def _detect_yield_curve_3m10y(df: pd.DataFrame) -> list[dict]:
+    """Detect 10Y-3M yield curve inversions (classic recession signal)."""
+    if df.empty:
+        return []
+    df = df.copy()
+    df["prev"] = df["value"].shift(1)
+    events = []
+    # Inversion: spread crosses below 0
+    inversions = df[(df["value"] < 0) & (df["prev"] >= 0)].dropna(subset=["prev"])
+    prev_date = None
+    for _, row in inversions.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        events.append({
+            "event_type": "yield_curve_3m10y_inversion",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the 10Y-3M yield curve inverted to "
+                f"{row['value']*100:.0f}bps — a classic recession warning signal."
+            ),
+        })
+        prev_date = row["date"]
+    # Un-inversion
+    un_inversions = df[(df["value"] >= 0) & (df["prev"] < 0)].dropna(subset=["prev"])
+    prev_date = None
+    for _, row in un_inversions.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 60:
+            continue
+        events.append({
+            "event_type": "yield_curve_3m10y_uninversion",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the 10Y-3M yield curve un-inverted to "
+                f"{row['value']*100:.0f}bps after a period of inversion."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# NEW: FX, DJIA, breakeven inflation, JOLTS, earnings, vehicles,
+#      permits, existing home sales, NFCI, Fed balance sheet,
+#      monetary base, business loans, PCE inflation, SOFR,
+#      WTI oil (FRED), Henry Hub gas (FRED),
+#      cross-asset composites, and short-term shock windows
+# ------------------------------------------------------------------
+
+def _detect_fx_shocks(df: pd.DataFrame, pair_name: str) -> list[dict]:
+    """Detect large moves in an FX pair."""
+    window = config.SCENARIO_FX_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_FX_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "strengthened" if row["pct_change"] > 0 else "weakened"
+        events.append({
+            "event_type": "fx_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {pair_name} {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} trading days "
+                f"to {row['value']:.4f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_breakeven_inflation_shocks(df: pd.DataFrame, tenor: str) -> list[dict]:
+    """Detect large moves in breakeven inflation rates."""
+    return _detect_level_change(
+        df, "breakeven_inflation_shock",
+        f"the {tenor} breakeven inflation rate",
+        config.SCENARIO_BEI_DELTA, config.SCENARIO_BEI_ROLLING_WINDOW,
+    )
+
+
+def _detect_djia_moves(df: pd.DataFrame) -> list[dict]:
+    """Detect DJIA large moves over rolling window."""
+    window = config.SCENARIO_DJIA_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_DJIA_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "rallied" if row["pct_change"] > 0 else "dropped"
+        events.append({
+            "event_type": "djia_move",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the DJIA {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} trading days "
+                f"to {row['value']:.0f}."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_jolts_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in JOLTS job openings."""
+    return _detect_mom_change(df, "jolts_shock", "JOLTS job openings",
+                              config.SCENARIO_JOLTS_PCT_CHANGE,
+                              unit="K", fmt=".0f",
+                              de_dup_days=config.SCENARIO_JOLTS_DEDUP_DAYS)
+
+
+def _detect_earnings_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in average hourly earnings."""
+    return _detect_mom_change(df, "earnings_shock", "average hourly earnings",
+                              config.SCENARIO_EARNINGS_MOM_THRESHOLD,
+                              unit="$/hr", fmt=".2f")
+
+
+def _detect_vehicle_sales_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in total vehicle sales."""
+    return _detect_mom_change(df, "vehicle_sales_shock", "total vehicle sales",
+                              config.SCENARIO_VEHICLE_PCT_CHANGE,
+                              unit="M", fmt=".1f")
+
+
+def _detect_permit_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in building permits."""
+    return _detect_mom_change(df, "building_permit_shock", "building permits",
+                              config.SCENARIO_PERMIT_PCT_CHANGE,
+                              unit="K", fmt=".0f")
+
+
+def _detect_existing_home_sales_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in existing home sales."""
+    return _detect_mom_change(df, "existing_home_sales_shock", "existing home sales",
+                              config.SCENARIO_EXISTING_HOME_SALES_PCT,
+                              unit="K", fmt=".0f")
+
+
+def _detect_nfci_events(df: pd.DataFrame) -> list[dict]:
+    """Detect Chicago Fed NFCI crossing above 0 (tighter than average)."""
+    if df.empty:
+        return []
+    threshold = config.SCENARIO_NFCI_THRESHOLD
+    df = df.copy()
+    df["prev"] = df["value"].shift(1)
+    # Tightening: crosses above threshold
+    crossings_up = df[(df["value"] >= threshold) &
+                      (df["prev"] < threshold)].dropna(subset=["prev"])
+    # Loosening: crosses back below from above
+    crossings_down = df[(df["value"] < threshold) &
+                        (df["prev"] >= threshold)].dropna(subset=["prev"])
+    events = []
+    prev_date = None
+    for _, row in crossings_up.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 30:
+            continue
+        events.append({
+            "event_type": "nfci_tightening",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the Chicago Fed NFCI rose to "
+                f"{row['value']:.3f}, crossing above 0 — signaling tighter-than-average "
+                f"financial conditions."
+            ),
+        })
+        prev_date = row["date"]
+    prev_date = None
+    for _, row in crossings_down.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < 30:
+            continue
+        events.append({
+            "event_type": "nfci_loosening",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the Chicago Fed NFCI fell to "
+                f"{row['value']:.3f}, crossing below 0 — signaling easing "
+                f"financial conditions."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_fed_balance_sheet_events(df: pd.DataFrame) -> list[dict]:
+    """Detect large changes in Fed balance sheet (WALCL)."""
+    window = config.SCENARIO_FED_BS_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_FED_BS_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].dropna(subset=["pct_change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window * 7:
+            continue
+        direction = "expanded" if row["pct_change"] > 0 else "contracted"
+        events.append({
+            "event_type": "fed_balance_sheet",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the Fed balance sheet {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} weeks "
+                f"to ${row['value']/1e6:.2f}T."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_monetary_base_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in the monetary base."""
+    return _detect_mom_change(df, "monetary_base_shock", "the monetary base",
+                              config.SCENARIO_MONETARY_BASE_PCT,
+                              unit="B", fmt=".0f")
+
+
+def _detect_business_loan_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in C&I loans."""
+    return _detect_mom_change(df, "business_loan_shock", "C&I loans",
+                              config.SCENARIO_BUSLOANS_PCT_CHANGE,
+                              unit="B", fmt=".0f")
+
+
+def _detect_pce_inflation_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large month-over-month changes in PCE price index."""
+    return _detect_mom_change(df, "pce_inflation_shock", "PCE price index",
+                              config.SCENARIO_PCEPI_MOM_THRESHOLD,
+                              fmt=".2f")
+
+
+def _detect_sofr_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect large moves in SOFR rate."""
+    return _detect_level_change(df, "sofr_shock", "the SOFR rate",
+                                config.SCENARIO_SOFR_DELTA,
+                                config.SCENARIO_SOFR_WINDOW)
+
+
+def _detect_wti_oil_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect WTI oil shocks from FRED daily data (DCOILWTICO)."""
+    window = config.SCENARIO_OIL_ROLLING_WINDOW
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_OIL_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "wti_oil_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, WTI crude oil {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} trading days "
+                f"to ${row['value']:.2f}/bbl."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_henry_hub_shocks(df: pd.DataFrame) -> list[dict]:
+    """Detect Henry Hub natural gas shocks from FRED daily data (DHHNGSP)."""
+    window = config.SCENARIO_OIL_ROLLING_WINDOW  # reuse same window size
+    if len(df) < window:
+        return []
+    pct = config.SCENARIO_NATGAS_PCT_CHANGE
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": "henry_hub_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, Henry Hub natural gas {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over {window} trading days "
+                f"to ${row['value']:.2f}/MMBtu."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# Cross-asset composite detectors
+# ------------------------------------------------------------------
+
+def _detect_real_yield_shocks(dgs10: pd.DataFrame, bei: pd.DataFrame) -> list[dict]:
+    """Detect real yield (DGS10 - T10YIE) large moves."""
+    if dgs10.empty or bei.empty:
+        return []
+    merged = pd.merge(dgs10, bei, on="date", suffixes=("_nom", "_bei")).sort_values("date")
+    if merged.empty:
+        return []
+    merged["real_yield"] = merged["value_nom"] - merged["value_bei"]
+    window = config.SCENARIO_REAL_YIELD_WINDOW
+    if len(merged) < window:
+        return []
+    merged["change"] = merged["real_yield"] - merged["real_yield"].shift(window)
+    delta = config.SCENARIO_REAL_YIELD_DELTA
+    large = merged[merged["change"].abs() >= delta].dropna(subset=["change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "surged" if row["change"] > 0 else "plunged"
+        events.append({
+            "event_type": "real_yield_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the real yield (10Y nominal - breakeven) "
+                f"{direction} {abs(row['change'])*100:.0f}bps over {window} days "
+                f"to {row['real_yield']:.2f}%."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_credit_compression(hy: pd.DataFrame, ig: pd.DataFrame) -> list[dict]:
+    """Detect credit compression/expansion (HY spread - IG spread)."""
+    if hy.empty or ig.empty:
+        return []
+    merged = pd.merge(hy, ig, on="date", suffixes=("_hy", "_ig")).sort_values("date")
+    if merged.empty:
+        return []
+    merged["gap"] = merged["value_hy"] - merged["value_ig"]
+    window = config.SCENARIO_CREDIT_COMPRESSION_WINDOW
+    if len(merged) < window:
+        return []
+    merged["change"] = merged["gap"] - merged["gap"].shift(window)
+    delta = config.SCENARIO_CREDIT_COMPRESSION_DELTA
+    large = merged[merged["change"].abs() >= delta].dropna(subset=["change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        if row["change"] > 0:
+            desc = "widened (risk aversion)"
+        else:
+            desc = "compressed (risk appetite)"
+        events.append({
+            "event_type": "credit_compression",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the HY-IG credit spread gap {desc} "
+                f"by {abs(row['change'])*100:.0f}bps over {window} days "
+                f"to {row['gap']*100:.0f}bps."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_term_premium_shocks(dgs30: pd.DataFrame, dgs2: pd.DataFrame) -> list[dict]:
+    """Detect term premium (DGS30 - DGS2) large moves."""
+    if dgs30.empty or dgs2.empty:
+        return []
+    merged = pd.merge(dgs30, dgs2, on="date", suffixes=("_30", "_2")).sort_values("date")
+    if merged.empty:
+        return []
+    merged["spread"] = merged["value_30"] - merged["value_2"]
+    window = config.SCENARIO_TERM_PREMIUM_WINDOW
+    if len(merged) < window:
+        return []
+    merged["change"] = merged["spread"] - merged["spread"].shift(window)
+    delta = config.SCENARIO_TERM_PREMIUM_DELTA
+    large = merged[merged["change"].abs() >= delta].dropna(subset=["change"])
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window:
+            continue
+        direction = "steepened" if row["change"] > 0 else "flattened"
+        events.append({
+            "event_type": "term_premium_shock",
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, the 30Y-2Y term premium {direction} "
+                f"by {abs(row['change'])*100:.0f}bps over {window} days "
+                f"to {row['spread']*100:.0f}bps "
+                f"(30Y={row['value_30']:.2f}%, 2Y={row['value_2']:.2f}%)."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# Short-term (5-day) shock detectors for daily series
+# ------------------------------------------------------------------
+
+def _detect_short_term_shocks(df: pd.DataFrame, event_type: str, label: str,
+                               pct_threshold: float, window: int,
+                               unit: str = "", fmt: str = ".0f") -> list[dict]:
+    """Generic short-term percentage shock detector."""
+    if len(df) < window:
+        return []
+    df = df.copy()
+    df["pct_change"] = df["value"].pct_change(periods=window)
+    large = df[df["pct_change"].abs() >= pct_threshold].copy()
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window * 2:
+            continue
+        direction = "surged" if row["pct_change"] > 0 else "plunged"
+        events.append({
+            "event_type": event_type,
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {label} {direction} "
+                f"{abs(row['pct_change'])*100:.1f}% over just {window} trading days "
+                f"to {row['value']:{fmt}}{unit} — an acute short-term shock."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+def _detect_short_term_level_shocks(df: pd.DataFrame, event_type: str, label: str,
+                                     delta: float, window: int,
+                                     unit: str = "%") -> list[dict]:
+    """Generic short-term absolute-level shock detector."""
+    if len(df) < window:
+        return []
+    df = df.copy()
+    df["change"] = df["value"] - df["value"].shift(window)
+    large = df[df["change"].abs() >= delta].dropna(subset=["change"])
+    if large.empty:
+        return []
+    events = []
+    prev_date = None
+    for _, row in large.iterrows():
+        if prev_date is not None and (row["date"] - prev_date).days < window * 2:
+            continue
+        direction = "surged" if row["change"] > 0 else "plunged"
+        events.append({
+            "event_type": event_type,
+            "event_date": row["date"],
+            "event_description": (
+                f"On {row['date'].date()}, {label} {direction} "
+                f"{abs(row['change'])*100:.0f}bps over just {window} trading days "
+                f"to {row['value']:.2f}{unit} — a rapid rate move."
+            ),
+        })
+        prev_date = row["date"]
+    return events
+
+
+# ------------------------------------------------------------------
+# Public API
+# ------------------------------------------------------------------
+
+def run(granularity: str | None = None) -> pd.DataFrame:
+    """Detect all scenario events and save to benchmark directory.
+
+    Returns the scenarios DataFrame.
+    """
+    if granularity is None:
+        granularity = config.GRANULARITY
+
+    out_dir = config.DATA_DIR / "benchmark" / granularity
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    all_events: list[dict] = []
+
+    # Fed rate changes
+    fed = _load_fred("FEDFUNDS")
+    fed_events = _detect_fed_rate_changes(fed)
+    all_events.extend(fed_events)
+    logger.info("Fed rate changes: %d events.", len(fed_events))
+
+    # VIX spikes
+    vix = _load_fred("VIXCLS")
+    vix_events = _detect_vix_spikes(vix)
+    all_events.extend(vix_events)
+    logger.info("VIX spikes: %d events.", len(vix_events))
+
+    # Oil shocks
+    crude = _load_crude_spot()
+    if not crude.empty:
+        oil_events = _detect_oil_shocks(crude)
+        all_events.extend(oil_events)
+        logger.info("Oil shocks: %d events.", len(oil_events))
+    else:
+        logger.warning("No crude oil spot data available; skipping oil shock detection.")
+
+    # Natural gas shocks
+    natgas = _load_natgas_spot()
+    if not natgas.empty:
+        ng_events = _detect_natgas_shocks(natgas)
+        all_events.extend(ng_events)
+        logger.info("Natural gas shocks: %d events.", len(ng_events))
+    else:
+        logger.warning("No natural gas spot data available; skipping.")
+
+    # Market drawdowns (S&P 500)
+    sp500 = _load_fred("SP500")
+    dd_events = _detect_market_drawdowns(sp500)
+    all_events.extend(dd_events)
+    logger.info("Market drawdowns: %d events.", len(dd_events))
+
+    # NASDAQ large moves
+    nasdaq = _load_fred("NASDAQCOM")
+    nasdaq_events = _detect_nasdaq_moves(nasdaq)
+    all_events.extend(nasdaq_events)
+    logger.info("NASDAQ moves: %d events.", len(nasdaq_events))
+
+    # Yield curve events (DGS10 - DGS2)
+    dgs10 = _load_fred("DGS10")
+    dgs2 = _load_fred("DGS2")
+    yc_events = _detect_yield_curve_events(dgs10, dgs2)
+    all_events.extend(yc_events)
+    logger.info("Yield curve events: %d events.", len(yc_events))
+
+    # Treasury rate shocks (10-year yield)
+    tr_events = _detect_treasury_rate_shocks(dgs10)
+    all_events.extend(tr_events)
+    logger.info("Treasury rate shocks: %d events.", len(tr_events))
+
+    # USD index shocks
+    usd = _load_fred("DTWEXBGS")
+    usd_events = _detect_usd_shocks(usd)
+    all_events.extend(usd_events)
+    logger.info("USD shocks: %d events.", len(usd_events))
+
+    # 30-year Treasury shocks
+    dgs30 = _load_fred("DGS30")
+    if not dgs30.empty:
+        dgs30_events = _detect_dgs30_shocks(dgs30)
+        all_events.extend(dgs30_events)
+        logger.info("30Y Treasury shocks: %d events.", len(dgs30_events))
+
+    # CPI inflation shocks
+    cpi = _load_fred("CPIAUCSL")
+    if not cpi.empty:
+        cpi_events = _detect_cpi_shocks(cpi)
+        all_events.extend(cpi_events)
+        logger.info("CPI inflation shocks: %d events.", len(cpi_events))
+
+    # PPI shocks
+    ppi = _load_fred("PPIACO")
+    if not ppi.empty:
+        ppi_events = _detect_ppi_shocks(ppi)
+        all_events.extend(ppi_events)
+        logger.info("PPI shocks: %d events.", len(ppi_events))
+
+    # Unemployment shocks
+    unrate = _load_fred("UNRATE")
+    if not unrate.empty:
+        un_events = _detect_unemployment_shocks(unrate)
+        all_events.extend(un_events)
+        logger.info("Unemployment shocks: %d events.", len(un_events))
+
+    # Jobless claims spikes
+    icsa = _load_fred("ICSA")
+    if not icsa.empty:
+        icsa_events = _detect_jobless_claims_spikes(icsa)
+        all_events.extend(icsa_events)
+        logger.info("Jobless claims spikes: %d events.", len(icsa_events))
+
+    # Payroll shocks
+    payems = _load_fred("PAYEMS")
+    if not payems.empty:
+        pay_events = _detect_payroll_shocks(payems)
+        all_events.extend(pay_events)
+        logger.info("Payroll shocks: %d events.", len(pay_events))
+
+    # High-yield credit spread
+    hy = _load_fred("BAMLH0A0HYM2")
+    if not hy.empty:
+        hy_events = _detect_hy_spread_events(hy)
+        all_events.extend(hy_events)
+        logger.info("HY spread events: %d events.", len(hy_events))
+
+    # IG corporate spread
+    ig = _load_fred("BAMLC0A0CM")
+    if not ig.empty:
+        ig_events = _detect_ig_spread_events(ig)
+        all_events.extend(ig_events)
+        logger.info("IG spread events: %d events.", len(ig_events))
+
+    # TED spread spikes
+    ted = _load_fred("TEDRATE")
+    if not ted.empty:
+        ted_events = _detect_ted_spread_spikes(ted)
+        all_events.extend(ted_events)
+        logger.info("TED spread spikes: %d events.", len(ted_events))
+
+    # Financial stress index
+    fsi = _load_fred("STLFSI2")
+    if not fsi.empty:
+        fsi_events = _detect_financial_stress(fsi)
+        all_events.extend(fsi_events)
+        logger.info("Financial stress events: %d events.", len(fsi_events))
+
+    # Mortgage rate shocks
+    mort = _load_fred("MORTGAGE30US")
+    if not mort.empty:
+        mort_events = _detect_mortgage_rate_shocks(mort)
+        all_events.extend(mort_events)
+        logger.info("Mortgage rate shocks: %d events.", len(mort_events))
+
+    # Consumer sentiment shocks
+    sent = _load_fred("UMCSENT")
+    if not sent.empty:
+        sent_events = _detect_sentiment_shocks(sent)
+        all_events.extend(sent_events)
+        logger.info("Sentiment shocks: %d events.", len(sent_events))
+
+    # Industrial production shocks
+    indpro = _load_fred("INDPRO")
+    if not indpro.empty:
+        ip_events = _detect_industrial_production_shocks(indpro)
+        all_events.extend(ip_events)
+        logger.info("Industrial production shocks: %d events.", len(ip_events))
+
+    # Retail sales shocks
+    retail = _load_fred("RSAFS")
+    if not retail.empty:
+        rs_events = _detect_retail_sales_shocks(retail)
+        all_events.extend(rs_events)
+        logger.info("Retail sales shocks: %d events.", len(rs_events))
+
+    # Housing starts shocks
+    houst = _load_fred("HOUST")
+    if not houst.empty:
+        hs_events = _detect_housing_starts_shocks(houst)
+        all_events.extend(hs_events)
+        logger.info("Housing starts shocks: %d events.", len(hs_events))
+
+    # Home price events
+    cshpi = _load_fred("CSUSHPISA")
+    if not cshpi.empty:
+        hp_events = _detect_home_price_events(cshpi)
+        all_events.extend(hp_events)
+        logger.info("Home price events: %d events.", len(hp_events))
+
+    # M2 money supply events
+    m2 = _load_fred("M2SL")
+    if not m2.empty:
+        m2_events = _detect_m2_events(m2)
+        all_events.extend(m2_events)
+        logger.info("M2 money supply events: %d events.", len(m2_events))
+
+    # S&P vs NASDAQ divergence (sector rotation)
+    if not sp500.empty and not nasdaq.empty:
+        div_events = _detect_sp_nasdaq_divergence(sp500, nasdaq)
+        all_events.extend(div_events)
+        logger.info("Sector rotation events: %d events.", len(div_events))
+
+    # VIX regime changes
+    if not vix.empty:
+        regime_events = _detect_vix_regime_change(vix)
+        all_events.extend(regime_events)
+        logger.info("Volatility regime events: %d events.", len(regime_events))
+
+    # 10Y-3M yield curve (T10Y3M) — direct spread from FRED
+    t10y3m = _load_fred("T10Y3M")
+    if not t10y3m.empty:
+        yc3m_events = _detect_yield_curve_3m10y(t10y3m)
+        all_events.extend(yc3m_events)
+        logger.info("Yield curve 3M-10Y events: %d events.", len(yc3m_events))
+
+    # ── NEW: DJIA large moves ──
+    djia = _load_fred("DJIA")
+    if not djia.empty:
+        djia_events = _detect_djia_moves(djia)
+        all_events.extend(djia_events)
+        logger.info("DJIA moves: %d events.", len(djia_events))
+
+    # ── NEW: WTI crude oil from FRED daily ──
+    wti = _load_fred("DCOILWTICO")
+    if not wti.empty:
+        wti_events = _detect_wti_oil_shocks(wti)
+        all_events.extend(wti_events)
+        logger.info("WTI oil shocks (FRED): %d events.", len(wti_events))
+
+    # ── NEW: Henry Hub natural gas from FRED daily ──
+    hh = _load_fred("DHHNGSP")
+    if not hh.empty:
+        hh_events = _detect_henry_hub_shocks(hh)
+        all_events.extend(hh_events)
+        logger.info("Henry Hub gas shocks (FRED): %d events.", len(hh_events))
+
+    # ── NEW: FX pair shocks ──
+    for series_id, pair_name in [
+        ("DEXUSEU", "USD/EUR"), ("DEXJPUS", "JPY/USD"),
+        ("DEXUSUK", "USD/GBP"), ("DEXCHUS", "CNY/USD"),
+    ]:
+        fx = _load_fred(series_id)
+        if not fx.empty:
+            fx_events = _detect_fx_shocks(fx, pair_name)
+            all_events.extend(fx_events)
+            logger.info("FX shocks (%s): %d events.", pair_name, len(fx_events))
+
+    # ── NEW: Breakeven inflation shocks ──
+    for series_id, tenor in [("T10YIE", "10-year"), ("T5YIE", "5-year")]:
+        bei = _load_fred(series_id)
+        if not bei.empty:
+            bei_events = _detect_breakeven_inflation_shocks(bei, tenor)
+            all_events.extend(bei_events)
+            logger.info("Breakeven inflation (%s): %d events.", tenor, len(bei_events))
+
+    # ── NEW: PCE inflation ──
+    pcepi = _load_fred("PCEPI")
+    if not pcepi.empty:
+        pce_events = _detect_pce_inflation_shocks(pcepi)
+        all_events.extend(pce_events)
+        logger.info("PCE inflation shocks: %d events.", len(pce_events))
+
+    # ── NEW: SOFR rate shocks ──
+    sofr = _load_fred("SOFR")
+    if not sofr.empty:
+        sofr_events = _detect_sofr_shocks(sofr)
+        all_events.extend(sofr_events)
+        logger.info("SOFR shocks: %d events.", len(sofr_events))
+
+    # ── NEW: JOLTS job openings ──
+    jolts = _load_fred("JTSJOL")
+    if not jolts.empty:
+        jolts_events = _detect_jolts_shocks(jolts)
+        all_events.extend(jolts_events)
+        logger.info("JOLTS shocks: %d events.", len(jolts_events))
+
+    # ── NEW: Average hourly earnings ──
+    earnings = _load_fred("CES0500000003")
+    if not earnings.empty:
+        earn_events = _detect_earnings_shocks(earnings)
+        all_events.extend(earn_events)
+        logger.info("Earnings shocks: %d events.", len(earn_events))
+
+    # ── NEW: Total vehicle sales ──
+    vehicles = _load_fred("TOTALSA")
+    if not vehicles.empty:
+        veh_events = _detect_vehicle_sales_shocks(vehicles)
+        all_events.extend(veh_events)
+        logger.info("Vehicle sales shocks: %d events.", len(veh_events))
+
+    # ── NEW: Building permits ──
+    permits = _load_fred("PERMIT")
+    if not permits.empty:
+        perm_events = _detect_permit_shocks(permits)
+        all_events.extend(perm_events)
+        logger.info("Building permit shocks: %d events.", len(perm_events))
+
+    # ── NEW: Existing home sales ──
+    ehs = _load_fred("EXHOSLUSM495S")
+    if not ehs.empty:
+        ehs_events = _detect_existing_home_sales_shocks(ehs)
+        all_events.extend(ehs_events)
+        logger.info("Existing home sales shocks: %d events.", len(ehs_events))
+
+    # ── NEW: Chicago Fed NFCI ──
+    nfci = _load_fred("NFCI")
+    if not nfci.empty:
+        nfci_events = _detect_nfci_events(nfci)
+        all_events.extend(nfci_events)
+        logger.info("NFCI events: %d events.", len(nfci_events))
+
+    # ── NEW: Fed balance sheet ──
+    walcl = _load_fred("WALCL")
+    if not walcl.empty:
+        bs_events = _detect_fed_balance_sheet_events(walcl)
+        all_events.extend(bs_events)
+        logger.info("Fed balance sheet events: %d events.", len(bs_events))
+
+    # ── NEW: Monetary base ──
+    bogm = _load_fred("BOGMBASE")
+    if not bogm.empty:
+        bogm_events = _detect_monetary_base_shocks(bogm)
+        all_events.extend(bogm_events)
+        logger.info("Monetary base shocks: %d events.", len(bogm_events))
+
+    # ── NEW: Business / C&I loans ──
+    busloans = _load_fred("BUSLOANS")
+    if not busloans.empty:
+        bl_events = _detect_business_loan_shocks(busloans)
+        all_events.extend(bl_events)
+        logger.info("Business loan shocks: %d events.", len(bl_events))
+
+    # ── NEW: Cross-asset composites ──
+
+    # Real yield: DGS10 - T10YIE
+    bei_10y = _load_fred("T10YIE")
+    if not dgs10.empty and not bei_10y.empty:
+        ry_events = _detect_real_yield_shocks(dgs10, bei_10y)
+        all_events.extend(ry_events)
+        logger.info("Real yield shocks: %d events.", len(ry_events))
+
+    # Credit compression: HY - IG spread gap
+    if not hy.empty and not ig.empty:
+        cc_events = _detect_credit_compression(hy, ig)
+        all_events.extend(cc_events)
+        logger.info("Credit compression events: %d events.", len(cc_events))
+
+    # Term premium: DGS30 - DGS2
+    if not dgs30.empty and not dgs2.empty:
+        tp_events = _detect_term_premium_shocks(dgs30, dgs2)
+        all_events.extend(tp_events)
+        logger.info("Term premium shocks: %d events.", len(tp_events))
+
+    # ── NEW: Short-term (5-day) shocks for acute market events ──
+
+    # S&P 500 acute crash
+    if not sp500.empty:
+        sp_short = _detect_short_term_shocks(
+            sp500, "sp500_acute_shock", "the S&P 500",
+            config.SCENARIO_SP500_SHORT_DRAWDOWN,
+            config.SCENARIO_SP500_SHORT_WINDOW)
+        all_events.extend(sp_short)
+        logger.info("S&P 500 acute shocks (5d): %d events.", len(sp_short))
+
+    # NASDAQ acute shock
+    if not nasdaq.empty:
+        nq_short = _detect_short_term_shocks(
+            nasdaq, "nasdaq_acute_shock", "the NASDAQ",
+            config.SCENARIO_NASDAQ_SHORT_PCT,
+            config.SCENARIO_NASDAQ_SHORT_WINDOW)
+        all_events.extend(nq_short)
+        logger.info("NASDAQ acute shocks (5d): %d events.", len(nq_short))
+
+    # Oil acute shock
+    if not wti.empty:
+        oil_short = _detect_short_term_shocks(
+            wti, "oil_acute_shock", "WTI crude oil",
+            config.SCENARIO_OIL_SHORT_PCT,
+            config.SCENARIO_OIL_SHORT_WINDOW,
+            unit="$/bbl", fmt=".2f")
+        all_events.extend(oil_short)
+        logger.info("Oil acute shocks (5d): %d events.", len(oil_short))
+
+    # 10Y Treasury acute rate move
+    if not dgs10.empty:
+        dgs10_short = _detect_short_term_level_shocks(
+            dgs10, "treasury_acute_shock", "the 10Y Treasury yield",
+            config.SCENARIO_DGS10_SHORT_DELTA,
+            config.SCENARIO_DGS10_SHORT_WINDOW)
+        all_events.extend(dgs10_short)
+        logger.info("10Y Treasury acute shocks (5d): %d events.", len(dgs10_short))
+
+    # Build DataFrame
+    if all_events:
+        df = pd.DataFrame(all_events)
+        df["event_date"] = pd.to_datetime(df["event_date"])
+        df = df.sort_values("event_date").reset_index(drop=True)
+        df["scenario_id"] = [f"sc_{i:04d}" for i in range(len(df))]
+        df["pre_window_start"] = df["event_date"] - pd.Timedelta(days=config.SCENARIO_PRE_WINDOW_DAYS)
+        df["post_window_end"] = df["event_date"] + pd.Timedelta(days=config.SCENARIO_POST_WINDOW_DAYS)
+        # Reorder columns
+        df = df[["scenario_id", "event_type", "event_date", "event_description",
+                  "pre_window_start", "post_window_end"]]
+    else:
+        df = pd.DataFrame(columns=[
+            "scenario_id", "event_type", "event_date", "event_description",
+            "pre_window_start", "post_window_end",
+        ])
+
+    # Filter out scenarios whose event_date falls outside the valid panel
+    # window. Scenarios before START_DATE have no pre-event prices; those
+    # at the very end have no post-event prices. Both produce empty ground
+    # truth and should be dropped to keep scenarios.parquet = GT set.
+    if not df.empty:
+        panel_start = pd.Timestamp(config.START_DATE)
+        panel_end = pd.Timestamp(config.END_DATE)
+        # Leave at least 21 trading days after the event for post-window returns
+        # AND at least 21 trading days before for pre-event baseline
+        min_event = panel_start + pd.Timedelta(days=35)
+        max_event = panel_end - pd.Timedelta(days=35)
+        before = len(df)
+        df = df[(df["event_date"] >= min_event) & (df["event_date"] <= max_event)].copy()
+        # Re-number scenario_ids to keep them contiguous after filtering
+        df = df.sort_values("event_date").reset_index(drop=True)
+        df["scenario_id"] = [f"sc_{i:04d}" for i in range(len(df))]
+        dropped = before - len(df)
+        if dropped > 0:
+            logger.info("Filtered %d scenarios outside valid panel window [%s, %s]",
+                        dropped, panel_start.date(), max_event.date())
+
+    df.to_parquet(out_dir / "scenarios.parquet", index=False)
+    logger.info("Saved %d scenario events -> %s", len(df), out_dir / "scenarios.parquet")
+    return df

code/macrolens/__init__.py

@@ -0,0 +1,162 @@
+"""MacroLens — public unified API (v0.2).
+
+The 10-line workflow::
+
+    import macrolens as ml
+
+    X_train, y_train, meta_train = ml.load("T1", "train", granularity="daily")
+    X_test,  y_test,  meta_test  = ml.load("T1", "test")
+
+    model = ml.methods.LightGBMRegressor(task="T1")
+    model.fit(X_train, y_train, seed=42)
+    y_pred = model.predict(X_test)
+
+    metrics = ml.score("T1", y_test, y_pred,
+                       cluster_keys=meta_test["ticker"].values)
+    print(metrics["mse"].value, metrics["mse"].ci_lo, metrics["mse"].ci_hi)
+
+Public surface
+--------------
+
+* :func:`load` — sklearn-style ``(X, y, meta)`` data layer.
+* :func:`score` / :func:`compare_methods` — eval layer.
+* :func:`info` / :func:`features` — benchmark metadata.
+* :func:`list_methods` — registered method names (filterable by family / task).
+* :data:`methods` — sub-namespace; ``ml.methods.<ClassName>(task=...)``.
+* :class:`LoadedData`, :class:`MetricValue`, :class:`RunRecord` — types.
+
+Legacy v0.1 entry points (``load_tsf``, ``to_arrays``, ``evaluate``,
+``ask_lumina``, ...) remain importable during the v0.1 → v0.2 transition;
+they will be removed in Phase 7.
+"""
+
+from __future__ import annotations
+
+# ── v0.2 unified API (primary surface) ────────────────────────────────────
+from . import methods  # noqa: F401  (sub-namespace; ml.methods.<Name>)
+from ._types import LoadedData, MetricValue, RunRecord
+from .data import load
+from .eval import compare_methods, score
+from .meta import BENCHMARK_NAME, __version__, features, info
+from .methods import ALL_METHODS, list_methods
+
+
+# ── Legacy v0.1 entry points (transitional) ───────────────────────────────
+# These are imported lazily below so the new public surface stays usable
+# even when the legacy modules grow new dependencies. Failures during the
+# transitional period are captured and surfaced as ImportError on first
+# attribute access (rather than crashing every ``import macrolens`` call).
+def _import_legacy() -> dict[str, object]:
+    out: dict[str, object] = {}
+    try:
+        from ._evaluate import evaluate, format_submission
+        out["evaluate"] = evaluate
+        out["format_submission"] = format_submission
+    except Exception:  # pragma: no cover -- legacy module surface drift
+        pass
+    try:
+        from ._fast import TSFTorchDataset, load_torch, to_arrays
+        out["TSFTorchDataset"] = TSFTorchDataset
+        out["load_torch"] = load_torch
+        out["to_arrays"] = to_arrays
+        # legacy `features` function on _fast shadowed by meta.features in
+        # the v0.2 surface; expose under a private alias for back-compat.
+        from ._fast import features as _legacy_features
+        out["_legacy_features"] = _legacy_features
+    except Exception:  # pragma: no cover
+        pass
+    try:
+        from ._loaders import load_panel, load_scenarios, load_task, load_tsf
+        out["load_panel"] = load_panel
+        out["load_scenarios"] = load_scenarios
+        out["load_task"] = load_task
+        out["load_tsf"] = load_tsf
+    except Exception:  # pragma: no cover
+        pass
+    try:
+        from ._meta import BENCHMARK_VERSION
+        out["BENCHMARK_VERSION"] = BENCHMARK_VERSION
+    except Exception:  # pragma: no cover
+        pass
+    try:
+        from ._types import (
+            BenchmarkInfo,
+            GenerationMetrics,
+            REValuationMetrics,
+            ScenarioMetrics,
+            TaskSample,
+            TSFMetrics,
+            TSFSample,
+            ValuationMetrics,
+        )
+        out["BenchmarkInfo"] = BenchmarkInfo
+        out["GenerationMetrics"] = GenerationMetrics
+        out["REValuationMetrics"] = REValuationMetrics
+        out["ScenarioMetrics"] = ScenarioMetrics
+        out["TaskSample"] = TaskSample
+        out["TSFMetrics"] = TSFMetrics
+        out["TSFSample"] = TSFSample
+        out["ValuationMetrics"] = ValuationMetrics
+    except Exception:  # pragma: no cover
+        pass
+    return out
+
+
+_LEGACY = _import_legacy()
+
+
+def __getattr__(name: str):
+    """Resolve legacy attributes lazily (and ``ask_lumina`` even more so)."""
+    if name in _LEGACY:
+        return _LEGACY[name]
+    if name == "ask_lumina":
+        # The lumina agent imports openrouter / vector store deps that may
+        # not be installed in CPU-only paper-scope environments. Defer the
+        # import to first call.
+        from ..agents.lumina import ask as ask_lumina
+        return ask_lumina
+    if name == "lakehouse":
+        def _lakehouse(tag: str = "macrolens-v1.0"):
+            from ..lakehouse import Client
+            return Client.from_release(tag)
+        return _lakehouse
+    raise AttributeError(f"module 'macrolens' has no attribute {name!r}")
+
+
+__all__ = [
+    # v0.2 unified API
+    "load",
+    "score",
+    "compare_methods",
+    "info",
+    "features",
+    "list_methods",
+    "methods",
+    "ALL_METHODS",
+    "LoadedData",
+    "MetricValue",
+    "RunRecord",
+    "BENCHMARK_NAME",
+    "__version__",
+    # legacy (lazy)
+    "evaluate",
+    "format_submission",
+    "TSFTorchDataset",
+    "load_torch",
+    "to_arrays",
+    "load_panel",
+    "load_scenarios",
+    "load_task",
+    "load_tsf",
+    "ask_lumina",
+    "lakehouse",
+    "BENCHMARK_VERSION",
+    "BenchmarkInfo",
+    "GenerationMetrics",
+    "REValuationMetrics",
+    "ScenarioMetrics",
+    "TaskSample",
+    "TSFMetrics",
+    "TSFSample",
+    "ValuationMetrics",
+]