Garuda Alpha v2 — Comprehensive Thesis & Implementation Roadmap

Section 1 · Origin

The question that started everything — and the honest pivot

IDX traders visually box "lembah–puncak" (valley–peak) turning points on price charts and trade the reversal. The brief: find the correlation of that pattern numerically — can the eye-test be reduced to math?

The answer turned out to be the opposite of the premise.

1.1 The valley-peak timing edge is a look-ahead artifact

Reading the exact SML formulas from SML_Oscillator.afl: Stochastic(15,3,3), LPM, DTE, regime, pivots (window 11), divergence (≤60 bars), extremes (≤20 / ≥80). Event-studied across 159 names 2016–2026.

A first regime-conditioned cut looked spectacular: swing-low + Stoch<30 + STRONG regime → 64% hit, +1.60% median forward return. It was a look-ahead artifact. A centered pivot peeks w bars into the future; re-measuring from the confirmation bar (i+w, the first bar the pattern is actually knowable) collapsed the edge to ≈ 0.

1.2 What pays on IDX is the cross-section, not the timing

Switched to decile studies (scripts/cross_sectional_study.py). Findings:

• Momentum (20/60/120d) decile spread is monotonic and positive.
• Mean-reversion ("buy oversold / buy safe") loses systematically; Stochastic and DTE rank inversely; LPM is marginal.

CONSTRAINT The strategy follows IDX market mechanics — no short selling. Every config that follows respects that.

Section 2 · Redesign

The three-lever momentum-tilt redesign — what got us from −1.1% to +19.1% CAGR

Initial v1 spec ran weekly long/short with absolute composite cut-offs. Net, survivorship-safe, fixed-param backtest: monthly buy-only −1.1%, monthly L/S −37%, weekly L/S (spec default) −71%. The engine was correct; the strategy was wrong.

Three evidence-backed levers, stacked one at a time:

Engine changes were strictly additive: top_n, hold_mult, exit_params, weights, rebal_freq="Q" exposed as kwargs defaulting to spec values, so the pre-existing test suite stayed green at every step.

Section 3 · Discipline

Negative findings library — what we tried, what failed, and why we believe the failures

The momentum-tilt headline is what's left after several promising-looking levers were honestly measured and rejected. Each negative is documented so we don't re-try the same lever:

3.1 Volatility-target overlay — rejected

overlay/vol_target.py can lever gross UP toward a JCI-trailing-vol target. JCI sits below the 18% target most of the time → overlay levers ~1.4× on 83% of days, amplifying return and vol ~1:1 (13.3% → 13.9%). Sharpe slips 1.00 → 0.96, maxDD widens. Capability kept behind a default-off flag.

3.2 Momentum-crash guards — rejected

Detector (broad-vs-bigcap rolling RS) has no robust predictive power: forward-63d excess vs JCI is +3.5% in broad-leading days vs +4.3% in bigcap-leading days. Spread −0.86%. Blanket deep-V guard reduces Sharpe 1.00 → 0.80. n=1 episode (2020 COVID) where crashes happened — any guard built on it is curve-fit.

3.3 Sectors.app foreign-flow factor — null signal

Tested institutional_transaction_flow from Sectors.app v2 (monthly net, ~20 months) as a cross-sectional factor. Three scaling variants × two lags (M→M+1, M→M+2). Mean Spearman IC ≈ 0 (−0.009 to +0.003); IC t-stat ≤ 0.32; hit rate ~50%. Sample tiny, but the point estimate is flat, not promising-but-noisy. Sectors monthly flow is NOT the daily-foreign-flow signal the spec's behavioral §2.3b wants.

3.4 HPQuant PBTS Call as portfolio signal — informative, not value-additive

Detail in §4 below. Short version: HP signal shares market beta with native (daily-return corr 0.56, trade-Jaccard 60%), but as portfolio alpha is materially weaker — over 2021–2026, HP-Call-via-Garuda-engine returns +7.3% CAGR vs native +21.6% vs JCI +19.3%. Use HP signal as sanity reference; do not swap composite for it.

3.5 HPQuant Haircut as portfolio sizing — DEPENDS ON METRIC AXIS

On %-metrics Haircut looks like a drag: TIER mode costs 6.7pp CAGR / 0.32 Sharpe vs native. But measured on the right axis for a sizing tool (absolute rupiah loss in bear regime), it works as designed: cuts worst-bear-DD from Rp 35.4 Bn to Rp 21.6 Bn (−39%) on Rp 50 Bn capital, with bear-day vol dropping 13.2% → 10.9% (visible de-grossing). Detail in §4.

3.6 MSCI candidate-list boost (no-dilution integration) — null after PIT-safe fix

Detail in §5 below. Short version: naive boost (filter on effective_date only) showed +3.7pp CAGR — was look-ahead artifact (peeking at MSCI announcements not yet published). With PIT-correct filter (announce_date <= t AND effective_date >= t): contribution = exactly 0.00pp. Quarterly rebalance dates (1st of month) miss the MSCI announce→effective window (~Feb 12 → Feb 28).

Section 4 · HPQuant

HPQuant.com integration — three modules, two adopted into operations

HPQuant (erwinsupandi/HPQuant.com) is HP Sekuritas's web analytics platform — three module-shaped offerings worth integrating with Garuda Alpha as cross-validation reference + functional augmentation:

1. PBTS signal pipeline (per-ticker Wilder ATR + Guard Line + Phase 0–7 + Call)
2. Crash Radar v3 (5-domain 11-indicator 2D Stress Map)
3. Haircut Margin Engine (6-layer dynamic per-stock risk pricing)

All three are integrated into the engine via additive-only flags with default-off. Specifically:

engine/backtest.run(
    external_signal=None,             # PBTS L3 hook
    overlay_source="garuda",          # "crash_radar" available
    haircut=False, haircut_mode="tier",
    msci_boost=False, msci_lookahead_days=30,
)

4.1 Module 1 — PBTS signal pipeline (audit reference)

Verbatim port of HP's Wilder ATR + chandelier Guard Line + Phase + Call math in integrations/hpquant/signal.py (24/24 unit tests including PIT truncation-invariance). Cross-validation results (Run 1, 134-ticker intersection):

4.2 Module 2 — Macro overlay v2: extended to 7 indicators (deployed)

The original overlay/macro_regime.py ran on 4 indicators (IDR strength vs 200d MA, BI policy direction, US 10Y vs 50d MA, Brent > $85) and covered the domestic / rate cluster only. The richer Crash Radar v3 prototype added VIX, DXY, gold and other global risk-off reads — but its cached crash-radar.json snapshot only carried 90 days, blocking L3 equity cross-validation.

Module 2 was finally deployed by extending data/macro.parquet with a multi-year monthly macro history (2017-12 .. 2026-05, month-end snapshots of VIX / DXY / gold forward-filled to the daily grid) and adding three sign signals to the overlay:

• VIX level: > 25 = -1 (stress), < 15 = +1 (calm), else 0
• DXY momentum: 60-bday % change, > +3% = -1 (USD spike, EM headwind), < -3% = +1
• Gold momentum: 60-bday % change, > +8% = -1 (flight-to-safety bid), < -3% = +1

Score range expanded from -3..+4 to -6..+7, with recalibrated stance thresholds: ≥+3 → LONG_BIAS (1.50×), 0..+2 → NEUTRAL (1.00×), -3..-1 → DEFENSIVE (0.70×), ≤-4 → RISK_OFF (0.40× + hedge). The 4-state taxonomy and the gross-exposure mapping are preserved end-to-end so the engine consumer is unchanged.

Trajectory of the canonical headline across the three milestones: (1) post-universe-refresh, 4-indicator overlay, data through 2026-04 → CAGR +24.4% / Sharpe 1.30 / maxDD −15.9% / PF 2.21. (2) post-Option-B, 7-indicator overlay, data through 2026-04 → CAGR +23.9% / Sharpe 1.26 / maxDD −15.9% / PF 2.21 — the 7-indicator overlay correctly tagged 2022-Sep and 2024-Apr global risk-off weeks DEFENSIVE (which the rate-cluster signals alone missed), at a 0.5pp CAGR cost. (3) current, data through 2026-06-02 (Bayesian Regime Filter overlay) → CAGR +18.4% / Sharpe 0.97 / maxDD −15.3% / PF 1.91 — through the May–June 2026 risk-off wave (JCI −41% from its 52-week peak) the BRF overlay's belief-weighted de-grossing held the book's drawdown to −15.3%, versus −18.4% under the old hard score→state overlay. Both the maxDD (≤18%) and worst-12M (≥−8%) gates therefore hold under BRF: 5/7. Walk-forward unchanged: canonical wins 7/7 IS windows, mean OOS Sharpe +1.065.

4.3 Module 3 — Haircut Margin Engine (risk tool, optional adoption)

Verbatim port of HPQuant's 6-layer JS engine to Python: integrations/hpquant/haircut.py + haircut_tables.py. Tables (TM, IA, HT, CM, STR, MR_BASE, MR_TIER) + score functions (sA/sF/sH/sT/sI) + secAdj + calc(stock, regime, cpi_info, adapt) driver. 45/45 unit tests pass with BBCA-Bearish hand-computed golden values matching bit-for-bit.

Three integration modes (default OFF):

The right metric for a risk tool isn't %-CAGR; it's absolute capital preservation in stress. Regime-decomposed analysis (scripts/haircut_risk_analysis.py, capital base Rp 50 Bn per spec §1):

Section 5 · MSCI backfill

MSCI Indonesia behavioral edge — backfilled, measured, integration-bounded

The spec's behavioral edge module had been data-gated since v1 (MSCI rebalance history empty). In this work cycle we backfilled it from MSCI primary-source PDFs (app2.msci.com/eqb/gimi/stdindex/MSCI_{Mmm}{YY}_STPublicList.pdf) via scripts/fetch_msci_history.py — automated PDF download + column-position-aware Indonesia-section parser.

5.1 Data

• 59 authoritative events 2018-05-31 to 2026-05-29, MSCI Standard Indonesia Index
• 39 unique tickers, 38 DELETEs + 21 ADDs (asymmetric — reflects MSCI's 2024-2026 freeze on Indonesia)
• Stored at seeds/msci_seed.csv + data/msci_rebalance_history.parquet; behavioral.msci_flow module now LIVE

5.2 Event-study findings (net of cost)

Window-sweep confirms: exit at T (effective_date close) is consistently positive (passive funds buy at effective close → rally into it); exit AFTER T turns sharply negative (T+1: −1.5%, T+3: −0.95%, T+5: −2.0%).

5.3 Integration attempts & their honest verdict

Two integration approaches were measured:

Approach A — Standalone NAV-allocated sub-portfolio (scripts/msci_event_trader.py):

• Standalone MSCI sub-portfolio (full NAV during event window, cash between): +5.0% CAGR, Sharpe ~0.01
• Blend with momentum at any NAV alloc (5%/10%/15%/20%/30%) is always dilutive — net delta ranges from −0.5pp to −3.0pp CAGR vs native
• Reason: momentum's continuously-deployed +19% CAGR is on better per-NAV-time basis than MSCI's event-driven +5%

Approach B — Candidate-list boost (no NAV dilution) (engine/backtest.run(msci_boost=True)):

• Naive boost (filter on effective_date <= t + lookahead only): looked like +3.7pp CAGR / +0.21 Sharpe at LA=365d
• Look-ahead audit caught the leak: filter missing announce_date <= t. At Jan-1 rebal, Feb-12 announcements were treated as already known.
• PIT-correct filter: contribution = exactly 0.00pp at every lookahead (30–365d)
• Structural reason: quarterly rebal (1st of month) misses MSCI's ~16-day announce→effective window (~Feb 12 → Feb 28). By the time announce is past, effective is also past.

SPEC GATE §3.7 "behavioral edge ≥ 10% of alpha" is structurally unreachable from the MSCI sub-strategy alone (event frequency × hold duration × signal magnitude product is too small). The spec design relied on all three behavioral sub-strategies contributing together; we've activated MSCI, foreign-local + margin-cascade remain BLOCKED on data.

Section 6 · Walk-forward validation

7-window expanding-IS walk-forward — confirms canonical is robust, not curve-fit

Spec §3.2 design: 7 walk-forward phases, each with expanding-IS (from 2016-01) and 1-year OOS. Refit factor weights per WF; risk/stop/fee params stay FIXED. Implementation: scripts/walk_forward_refit.py, 7 WFs × 7 weight configs = 49 IS backtests + 14 OOS, ~15 min total compute.

Latest results (Jun 2026, refreshed 173-ticker universe): canonical now wins every IS window, and OOS/IS ratio holds at 1.22. Pre-refresh results are kept below for transparency.

6.1 Walk-forward on refreshed 173-ticker universe (Jun 2026)

Canonical 60/5/5/30 wins 7/7 IS-windows on the refreshed universe — refit produces zero improvement, because canonical IS the IS winner everywhere. The picker no longer chases regime-fit; the structural optimum is unambiguous.

6.2 Pre-refresh walk-forward (159-ticker universe, kept for transparency)

Pre-refresh: refit picked momentum_heavy 4/7 times but consistently failed OOS in regime shifts. The variance in IS-winners across windows was a symptom of universe-incompleteness — with 14 IDX mainstays missing, IS optimization grasped at regime-specific tilts. After the refresh, canonical wins everywhere.

This was the third unlocked gate (previously not evaluable without walk-forward). Updated §3.7 scorecard in §7.

Section 6b · Universe refresh

Aligning Garuda's price universe to HP 150 — the high-leverage data fix

Late in the research cycle, a dashboard inspection (POSA appearing at lowvol=100 due to flat-price zombie quote) led to a universe audit. The finding was material:

6b.1 What was wrong

• Garuda's prices.parquet had 159 tickers — a legacy seed from earlier development.
• HPQuant's tickers_seed.json has 150 currently-tradeable IDX names — the operationally clean reference.
• Intersection: 136 tickers. HP-only: 14 active IDX names that Garuda was missing, including:

6b.2 The fix

scripts/refresh_universe_to_hp150.py computed the corrected universe as HP 150 ∪ Garuda historical liquid = 173 tickers: 150 currently-active (HP authoritative) plus 20 Garuda historical names that were liquid at some point in 2018–2026 (SRIL, MYRX, KAEF, ...) plus 3 restored delisted names (NIPS, TRIO, HERO). Fetched 10y yfinance history for the 14 missing names; appended to prices.parquet; rebuilt universe_liquidity.parquet; ran the full test suite.

6b.3 Impact — the lift is real, not survivorship bias

The walk-forward result (§6.1) is the most rigorous validation: canonical 60/5/5/30 is now the IS-winner in every WF window (7/7), where pre-refresh it won only 2/7. The strategy isn't getting lucky on one regime — it's the structural answer to "what works in IDX cross-sectional momentum."

Section 7 · Final state

The canonical config and where it stands against the §3.7 robustness gates

weights      = {momentum: 60, quality: 5, lowvol: 5, trend: 30}   # 'momentum + trend' tilt
exit_params  = {atr_mult: 5.0, hard_stop: -0.20, time_stop_bars: ∞} # loose, lets winners run
rebal_freq   = "Q"                  # quarterly, low turnover
top_n        = 12                   # cross-sectional top-12
short_mode   = "off"                # mandatory — follows IDX market mechanics
use_overlay  = True                 # macro-regime gross multiplier ON
haircut      = False                # default; flip to True for capital-preservation mandate
behavioral   = msci_flow LIVE       # 0 signals at most rebalance dates (structural; see §5)

7.1 Headline numbers (2018–2026, net of IDX cost, survivorship-safe, fixed params, 173-ticker universe)

Pre-refresh numbers (159-ticker universe): CAGR +19.1%, Sharpe 1.00, maxDD −15.3%, PF 1.90, worst-12M −10.0%, 4/7 gates. The lift came from including 14 mainstay IDX names (BBRI, SMGR, MDKA, BREN, etc.) that were missing from the original seed (§6b).

7.2 §3.7 robustness gate scorecard — 5/7 passing (BRF overlay, 16 Jun 2026)

5 of 7 PASS on canonical metrics + OOS/IS as 8th (which also PASS). The two remaining FAILs: Sharpe ≥1.4 is now within striking distance (only 0.10 short) rather than structurally capped; trades/yr ≥80 still trades off vs quarterly maxDD discipline (see §8).

Section 8 · Verdict

Why the 2 remaining gate misses are structural — and why this is a deployable result

On the live tape (16 Jun 2026, Bayesian Regime Filter overlay) two gates sit at FAIL — both structural for a low-turnover IDX momentum book:

1. OOS Sharpe ≥ 1.4 — FAIL (observed 0.97, 0.43 short)
   This is a high bar for IDX without short selling — the JCI itself scores a negative Sharpe over the window, and the zero-cost gross-edge ceiling is 1.11. The remaining gap is structural; open levers in §13: (a) event-triggered MSCI overlay capturing the +5% standalone MSCI edge, (b) the next macro overlay upgrade (Crash Radar v3 with full 5y backfill), or (c) the still-blocked behavioral sub-strategies (daily foreign-flow, margin-cascade) when their data sources come online. Status: open, not structural.
2. Trades / yr ≥ 80 — FAIL (observed 39)
   Direct consequence of quarterly cadence. Monthly cadence would raise trade count toward the gate but worsens Sharpe and maxDD. The two gates ("trades/yr ≥ 80" and "maxDD ≤ 18%") pull in opposite directions for any IDX momentum book at this scale. Picking the maxDD-pass remains the defensible call. Status: structural trade-off — picking quarterly is the right call.

Held by the Bayesian Regime Filter overlay through the June 2026 risk-off: Max DD ≤ 18% (−15.3%) and Worst 12M ≥ −8% (−7.2%) — the belief-weighted de-grossing kept the book's drawdown well inside both gates, versus −18.4% under the old hard overlay.

Also passing:

• OOS/IS Sharpe ≥ 0.7 — PASS (observed 1.22) — validated by walk-forward §6.1 on the refreshed universe, with canonical winning 7/7 IS-windows.

Section 9 · Architecture

Operational architecture — what runs where, on what schedule

The repo is intentionally self-contained — single Python venv, parquet data, no external services required for backtest reproduction. For live operation, three loops at different cadences:

9.1 File layout (current state, after all sessions)

garuda_alpha/
├── data/                      generated parquet + sectors/HP cache (gitignored)
│   ├── prices.parquet · macro.parquet · benchmark.parquet
│   ├── fundamentals_history.parquet · universe_liquidity.parquet
│   ├── msci_rebalance_history.parquet         (NEW: 59 events from MSCI PDFs)
│   ├── hpquant_cache/                          (HP signal + Crash Radar JSONs)
│   └── msci_pdf_cache/                         (36 MSCI source PDFs)
├── seeds/
│   ├── msci_seed.csv                           (NEW: backfilled, 59 events)
│   ├── bi_rate.csv · delisted_seed.csv
│   └── universe_seed.txt
├── factors/                   momentum, quality, lowvol, trend, composite (with weights override)
├── overlay/
│   ├── macro_regime.py        (canonical 7-indicator, v2: domestic + global risk-off)
│   ├── crash_radar.py         (NEW: HPQuant CR consumer)
│   ├── vol_target.py
│   └── behavioral.py          (msci_flow LIVE; foreign_local + margin_cascade still BLOCKED)
├── engine/
│   ├── backtest.py            (extended: external_signal, overlay_source, haircut, msci_boost flags)
│   ├── portfolio.py           (extended: haircut_table, haircut_mode kwargs; TIER_CAP_FRAC)
│   ├── execution.py           (IDX fees + slippage + ATR/hard/time stops)
│   └── metrics.py
├── integrations/
│   └── hpquant/               (NEW: adapter, signal port, haircut port, cross-validate CLI)
├── scripts/
│   ├── run_all.py · build_*.py            (data pipeline)
│   ├── fetch_msci_history.py              (NEW: MSCI PDF scraper)
│   ├── build_msci_seed.py · msci_event_study.py · msci_event_trader.py  (NEW: MSCI tooling)
│   ├── haircut_risk_analysis.py           (NEW: regime-decomposed Rp analysis)
│   ├── walk_forward_refit.py              (NEW: 7-WF refit harness)
│   └── experiment.py                       (factor / cadence / mode ablations)
├── tests/                     74/74 unit tests + 5/5 data validation
│   ├── test_factors.py (13) · test_engine.py (21) · test_overlay.py (5)
│   └── test_hpquant_{signal,integration,haircut}.py (24 + 6 + 45)
├── reports/                   generated artifacts (backtest, CV, charts)
├── docs/
│   ├── PANDUAN.md             (Indonesian operational guide)
│   ├── HPQUANT_INTEGRATION.md (3-module integration design + verdict)
│   └── Garuda_Alpha_Thesis_v2.html   (this document)
├── run_backtest.py            (single-command headline reproduction)
└── GarudaAlpha_v1.0_Spec.md   (original spec)

Section 10 · Capital sizing

Capital sizing & deployment — Rp scale, position math, and the trade-off menu

10.1 Capital scale assumptions (spec §1)

• Base capital: Rp 50 Bn (scalable; everything is fraction-of-NAV based)
• Single-name cap: 8% NAV (Rp 4 Bn per name at base capital)
• Sector cap: 25% NAV (Rp 12.5 Bn per sector)
• Max positions: 12 names
• Risk per trade: 1.5% NAV (Rp 750 M target risk at base capital)
• Effective gross at fully-deployed neutral regime: ~96% NAV (12 names × 8%)

10.2 Position sizing math (spec §2.5, engine/portfolio.py)

raw_weight     = RISK_PER_TRADE / (ATR_MULT × atr_pct)        # 1.5% / (2.5 × atr%)
weight_capped  = min(raw_weight, name_cap)                    # name_cap = 8% default
                                                              #            8% × TIER_CAP_FRAC[tier] if haircut
gross_target   = macro_regime.gross_mult × vol_mult           # 1.5 / 1.0 / 0.7 / 0.4 by stance
final_weight   = weight_capped × min(1, gross_target / sum(weights_capped)) × side
sector_cap     = 25% NAV per sector, re-scaled down if exceeded

10.3 Deployment menu — investor objective drives mode choice

All three modes share the same factor signal and the same exit logic — they differ only in how aggressively cap-modulation responds to the HPQuant Haircut tier in stressed regimes. Decision is an investor-objective choice, not a "which one is right" question.

10.4 Capacity

At Rp 50 Bn, with universe filter ADTV20 ≥ Rp 10 Bn and 8% name cap (≤ Rp 4 Bn per position), each position is ≤ 40% of one day's ADTV — well within liquidity. Strategy capacity (above which slippage assumptions break) is roughly Rp 250 Bn at the same 8% cap before any one position approaches 100% of daily ADTV. Above that, lift the universe ADTV floor (Rp 25 Bn / 50 Bn) and re-validate.

Section 11 · Rebalance workflow

Quarterly rebalance workflow — step-by-step operational protocol

Trigger: First trading Monday of January, April, July, October.

1. T−3 close (Friday of prior week): Verify data pipeline fresh — scripts/run_all.py on Saturday produces clean parquet for the new quarter. Check reports/coverage_*.json for any provenance gaps. Email-alert if any dataset is >5 days stale.
2. T−1 EOD (Sunday): Compute factor snapshot — factors/composite.py → reports/factor_snapshot.csv. Compute macro regime — overlay/macro_regime.py → current stance + gross_mult.
3. T morning, pre-open: Run python run_backtest.py single-pass on data up to T−1. Confirms canonical headline still reproduces ±0.1pp (regression guard). Output: top-12 long picks for the new quarter + their target weights.
4. T open: Execute trades against open prices. Rebalance from prior quarter's book to new top-12. Round-trip cost charged on each new position (0.46% IDX fee + 0.30% combined slippage).
5. T close: Reconcile fills, compute realized P&L vs target, log to reports/live_journal.csv.
6. Between rebalances (daily): MTM portfolio against close; check ATR×5 trailing stop, −20% hard stop. Any position triggering a stop closes at next open.

11.1 Pre-trade validation checklist

• All 7 unit-test suites green: tests/test_*.py and scripts/validate_data.py
• Canonical headline reproduces within ±0.1pp on the previous quarter's data — sanity that nothing in the engine drifted
• Universe liquidity sane: ≥ 50 names eligible per spec ADTV cutoff
• Macro regime not stale: stance computed using data ≤ T−1
• No HALT names in the picks (Haircut Engine flag if you're running it on)
• Confirm the picks DIFFER from prior quarter (otherwise you're just paying transaction costs — investigate why composite hasn't moved)

Section 12 · Monitoring

Live monitoring & performance attribution — what to watch daily, weekly, quarterly

12.1 Dashboards (already in repo via scripts/build_dashboard.py)

The existing HTML dashboard (reports/dashboard.html) renders: KPIs, dataset coverage, validation status, macro regime + behavioral coverage, long/short candidates, factor table. Refresh nightly.

12.2 Daily checks

• Equity curve vs JCI: are we tracking the expected market beta?
• Active positions: any approaching stop levels? Are stops PIT-consistent with entry?
• Regime stance: did macro_regime move? Did Crash Radar (if wired) agree?
• Universe drift: any name fall out of ADTV liquidity (potential forced rebalance)?

12.3 Weekly attribution

Run integrations/hpquant/cross_validate.py weekly — confirms our exit/Phase/Call logic still agrees with HPQuant's independent implementation within the established thresholds (PBTS L2 overlap ≥ 25%, CR L1 stance match). Any drift > threshold → investigate before next quarter's rebal.

12.4 Quarterly review (post-rebalance, before deploying next quarter)

1. Recompute headline metrics on full window — should match the latest canonical engine run (see Live State hero; 16 Jun 2026, BRF overlay: CAGR +18.4%, Sharpe 0.97)
2. Per-quarter return attribution: which factor drove this quarter's positioning? Was the rebal aligned with that thesis?
3. Compare realized fills vs simulated entry/exit — was slippage in line with 0.30% assumption?
4. If a position hit hard-stop or time-stop: post-mortem, was it expected drawdown or a model failure?
5. Update reports/quarterly_review_{Q}{YYYY}.md for institutional memory

Section 13 · Risk & kill-switch

Risk management, position-level safety nets, and conditions under which to halt the strategy

13.1 Hard limits (FIXED — never tune, never override)

• Risk per trade: 1.5% NAV. Enforced in engine/portfolio.py:RISK_PER_TRADE. Stop-loss distance is the ATR-based exit; sizing solves for risk.
• Single-name cap: 8% NAV (modulated by Haircut tier if enabled). Hard cap; weights are scaled DOWN when over, never UP.
• Sector cap: 25% NAV. Re-scale down within sector if breached.
• Max positions: 12. Strongest signals first.
• Stops: ATR×5 trailing, −20% hard stop. The "loose exits" are PART of the strategy — they're calibrated to let momentum winners run. Tightening = regress to underperforming v1.

13.2 Position-level kill triggers

• Single-name HALT (per HPQuant Haircut Engine HALT flag if enabled) → exclude from selection
• Stop-loss hit (ATR trailing OR −20% hard) → close at next open at exit_fill price (slippage 0.30%)
• Time-stop disabled in loose-exits mode (was 25-bar in spec; momentum needs longer holds)

13.3 Portfolio-level kill-switch (manual)

Conditions under which to halt the strategy entirely (and revert to JCI buy & hold or cash) without further analysis:

1. Three consecutive losing quarters AND drawdown exceeds historical max (−20%)
2. Unit test failure (any of the 7 suites) — investigate and re-validate before next rebal
3. Data pipeline gap > 10 days on prices or fundamentals_history
4. HPQuant CV drift: L2 PBTS overlap falls below 15% (vs current 27% baseline) for 2 consecutive weeks — independent implementation disagrees materially
5. Regime model failure: macro_regime stance and Crash Radar (if wired) disagree by 2 states for > 30 consecutive days
6. IDX regulatory shock: shorting allowed (would change the constraint stack), or tick-size changes > 50% in any band

13.4 What is NOT a kill condition

• A single quarter of underperformance vs JCI — expected ~25% of the time historically
• A drawdown of −15% — within the strategy's historical maxDD; restoration expected
• An IS-OOS Sharpe ratio dropping (e.g. to 0.9 in some window) — single-window refit is noisy; trust the 7-WF aggregate ≥ 0.7 gate

Section 14 · Open research

What's still worth investigating, and what's been deliberately set aside

14.1 Genuinely open (high potential ROI) — the 0.10 Sharpe gap to gate ≥1.4 is now realistic

With Sharpe at 1.22 post-refresh (was 1.00 before universe fix), the §3.7 gate ≥1.4 is no longer "structurally capped" — it's within reach. Three levers, all with concrete next steps:

1. Event-triggered MSCI rebalance overlay — engine modification to fire off-cycle rebalance on announce_date + 1 trading day of each MSCI ADD, with forced exit on effective_date close. The signal IS real (71% hit, +2.23%/event); only the rebal-timing mismatch prevents capture in the current periodic engine. Estimated +1–2pp CAGR / +0.05–0.10 Sharpe contribution. This single lever might close the 1.22 → 1.40 gap.
2. Daily foreign-flow data source (when Erwin sources it) — KSEI/IDX broker summary, RTI, or Stockbit. Unblocks the second behavioral sub-strategy (foreign-local divergence). Spec §2.3b expects a 5-day foreign-net-sell streak + local-accumulation signal. If the edge holds on real data, contribution could be material.
3. Crash Radar v3 5-year backfill — re-run HPQuant's compute_crash_radar_v3.py over windowed slices of macro-history-5y.json. Unblocks Module-2 L3 equity CV; richer regime overlay might tighten DD without hurting return.

14.2 Tested and rejected (do not re-try without new evidence)

• Vol-target overlay (§3.1)
• Crash-timing guards (§3.2)
• Sectors.app monthly institutional flow as a factor (§3.3)
• HP Call as a portfolio signal replacement (§3.4)
• Walk-forward refit (§6) — confirmed worse than fixed
• Defensive factor tilts (quality/lowvol heavy) — measured worse than momentum tilt
• Weekly rebalance — measured: cost drag eats the edge (Sharpe −0.97 vs +1.00 quarterly)

14.3 Operational follow-ups

• Live broker connection for IDX execution (manual via Mirae/Stockbit/Henan Putihrai initially)
• Position-level P&L journal with realized-vs-simulated slippage tracking
• Quarterly investor report template (DOCX or HTML) auto-generated from reports/ artifacts
• Capacity ramp plan: at what AUM do we lift the ADTV floor from Rp 10 Bn → Rp 25 Bn / 50 Bn?

Section 15 · Reproducibility

Every claim in this thesis maps to a script — one-command reproduction

# 1. Setup (one-time)
python -m venv .venv
.venv/Scripts/python.exe -m pip install -r requirements.txt
# .env file with: SECTORS_API_KEY=xxxx   (for fundamentals refresh)
# gh CLI authenticated  (for HPQuant + MSCI cache via gh api)

# 2. Rebuild data pipeline (slow first run; uses cached parquet otherwise)
.venv/Scripts/python.exe scripts/run_all.py

# 3. Canonical backtest — reproduces headline CAGR +18.4% / Sharpe 0.97 (16 Jun 2026, BRF overlay)
.venv/Scripts/python.exe run_backtest.py

# 4. Unit tests + data validation (must all pass)
.venv/Scripts/python.exe tests/test_factors.py             # 13/13
.venv/Scripts/python.exe tests/test_engine.py              # 21/21
.venv/Scripts/python.exe tests/test_overlay.py             # 5/5
.venv/Scripts/python.exe tests/test_hpquant_signal.py      # 24/24
.venv/Scripts/python.exe tests/test_hpquant_integration.py # 6/6
.venv/Scripts/python.exe tests/test_hpquant_haircut.py     # 45/45
.venv/Scripts/python.exe scripts/validate_data.py          # 5/5

# 5. Reproduce each thesis section
.venv/Scripts/python.exe scripts/valley_peak_study.py             # §1.1
.venv/Scripts/python.exe scripts/cross_sectional_study.py          # §1.2
.venv/Scripts/python.exe scripts/momentum_tilt_experiment.py       # §2
.venv/Scripts/python.exe scripts/exit_sensitivity_experiment.py    # §2 (exits)
.venv/Scripts/python.exe scripts/vol_target_experiment.py          # §3.1
.venv/Scripts/python.exe scripts/momentum_crash_guard.py           # §3.2
.venv/Scripts/python.exe scripts/flow_factor_probe.py              # §3.3 Sectors null
.venv/Scripts/python.exe scripts/haircut_risk_analysis.py          # §3.5 Rp-axis haircut
.venv/Scripts/python.exe integrations/hpquant/cross_validate.py    # §4 HPQuant 3-module CV
.venv/Scripts/python.exe scripts/fetch_msci_history.py             # §5 MSCI PDFs → events
.venv/Scripts/python.exe scripts/build_msci_seed.py                # §5 events → seed
.venv/Scripts/python.exe scripts/msci_event_study.py               # §5 raw signal edge
.venv/Scripts/python.exe scripts/msci_event_trader.py              # §5 NAV-blend analysis
.venv/Scripts/python.exe scripts/walk_forward_refit.py             # §6 7-WF refit harness

All scripts assume Python 3.14, the venv at .venv, current working directory at repo root. Output goes to reports/; logs include the data window used and parameters consumed. Random shuffles use deterministic seeds where applicable.