horizon-code 0.5.1 → 0.6.1

package/src/strategy/prompts.ts

@@ -76,8 +76,7 @@ After EVERY code fence, add a brief **Capital & Risk** section explaining in pla
 - **Position sizing**: How big each trade is (max_order_size contracts, ~$X at current prices)
 - **Risk level**: Conservative / Moderate / Aggressive — based on notional-to-capital ratio
 
-Example:
-> **Capital & Risk**: This strategy assumes $1,000 in paper mode. Max exposure is $500 across all markets. The kill switch triggers at 5% drawdown ($25 loss). Each order is at most 10 contracts (~$5-7 at typical prices). Risk level: **Conservative** (50% max exposure).
+Example: "Capital & Risk: $1,000 paper. Max $500 exposure. Kill switch at 5% ($25). 10 contracts/order. Conservative (50% exposure)."
 
 ### 4. Risk Scaling Rules
 - Conservative: max_notional ≤ 30% of capital, max_drawdown_pct ≤ 3%
@@ -220,22 +219,14 @@ class NWSFeed: def __init__(self, office: str = "", grid_x: int = 0, grid_y: int
 class RESTJsonPathFeed: def __init__(self, url: str, price_path: str | None = None, bid_path: str | None = None, ask_path: str | None = None, interval: float = 5.0): ...
 class ChainlinkFeed: def __init__(self, contract_address: str, rpc_url: str, decimals: int = 8, interval: float = 10.0): ...
 class MempoolFeed: def __init__(self, rpc_url: str): ...             # Polygon mempool watcher
-class AlpacaFeed: def __init__(self, symbols: list[str], data_source: str = "iex"): ...  # Stock real-time
-class CoinbaseFeed: def __init__(self, product_ids: list[str]): ...  # Crypto WebSocket
-class RobinhoodFeed: def __init__(self, symbols: list[str], interval: float = 5.0): ...
-class IBKRFeed: def __init__(self, conids: list[int], paper: bool = True): ...  # Interactive Brokers
-class CalendarFeed: def __init__(self, events_json: str | None = None, interval: float = 60.0): ...  # Economic events
-class TreasuryFeed: def __init__(self, series_ids: list[str] | None = None, interval: float = 3600.0): ...  # FRED yields
+# Also available: AlpacaFeed, CoinbaseFeed, RobinhoodFeed, IBKRFeed, CalendarFeed, TreasuryFeed
 
 # ── Exchange Types (for hz.run exchange=... or exchanges=[...]) ──
 
 class Polymarket: def __init__(self, private_key: str | None = None): ...
 class Kalshi: def __init__(self, email: str | None = None, password: str | None = None, api_key: str | None = None): ...
 class Limitless: def __init__(self, api_key: str | None = None, private_key: str | None = None): ...
-class Alpaca: def __init__(self, api_key: str | None = None, api_secret: str | None = None, paper: bool = True): ...
-class Coinbase: def __init__(self, api_key: str | None = None, api_secret: str | None = None): ...
-class Robinhood: def __init__(self, username: str | None = None, password: str | None = None): ...
-class InteractiveBrokers: def __init__(self, host: str = "127.0.0.1", port: int = 7497, client_id: int = 0): ...
+# Also available: Alpaca, Coinbase, Robinhood, InteractiveBrokers
 
 # ── Built-in Pipeline Factories ──
 
@@ -262,16 +253,6 @@ class InteractiveBrokers: def __init__(self, host: str = "127.0.0.1", port: int
 # hz.flow_signal(feed_name) -> Signal                             # Net buy/sell pressure
 # hz.imbalance_signal(feed_name) -> Signal                        # Orderbook imbalance
 # Signal(name="my_signal", fn=my_function, weight=1.0)
-
-# ── Advanced Modules (use lookup_sdk_docs for full API) ──
-# Arbitrage: parity_arb, event_arb, spread_convergence, stat_arb, mm_arb, latency_arb, composite_arb
-# Copy-Trading: copy_trades, copy_trader
-# Wallet Intelligence: score_wallet, analyze_wallet, scan_bots, reverse_copy
-# Wallet Profiler: profile_wallet, hunt, hunter
-# Stealth Execution (Ultra): estimate_impact, smart_route, stealth_execute — TWAP, iceberg, sniper
-# Sentinel (Ultra): sentinel_report, suggest_hedges, sentinel — continuous risk monitoring
-# Oracle (Ultra): forecast_market, scan_edges, oracle — AI-driven forecasting
-# Whale Galaxy (Ultra): scan_galaxy, detect_clusters, auto_target, galaxy_tracker
 `;
 
 const BACKTEST_REFERENCE = `
@@ -370,205 +351,98 @@ hz.dashboard(plot_bundle, width=72, height=16)         # Full multi-section ASCI
 result = hz.backtest(...)
 bundle = hz.from_backtest(result)
 print(hz.dashboard(bundle))
-
-# ── Walk-Forward Optimization ──
-
-from horizon.walkforward import walk_forward
-result = walk_forward(
-    data=tick_data,
-    pipeline_factory=lambda params: [make_fair(params), make_quoter(params)],
-    param_grid={"spread": [0.02, 0.04, 0.06], "size": [5, 10, 20]},
-    n_splits=5,
-    train_ratio=0.7,
-    expanding=True,
-    objective="sharpe_ratio",
-    purge_gap=3600.0,
-)
-
-# ── Calibration Analytics ──
-
-from horizon._horizon import calibration_curve, log_loss, edge_decay
-# calibration_curve(predictions, outcomes, n_bins) -> (bin_centers, actual_freqs, ece, brier)
-# log_loss(predictions, outcomes) -> float
-# edge_decay(edge_series, timestamps) -> half_life_seconds
 `;
 
 const ADVANCED_SDK_REFERENCE = `
 # ── Advanced SDK Capabilities ──
 
 ## Volatility Suite
-Six Rust-native estimators for adaptive spread sizing:
-hz.volatility(lookback=20, method="yang_zhang")  # Pipeline function
+hz.volatility(lookback=20, method="yang_zhang")  # Pipeline function, injects VolatilitySnapshot into ctx
 # Methods: "close_to_close", "parkinson", "garman_klass", "yang_zhang", "ewma", "rolling"
-# Injects VolatilitySnapshot into ctx with .best property (best estimator auto-selected)
-# Use: widen spreads in high-vol regimes, tighten in low-vol
-
-## Example — volatility-adaptive market maker:
-def adaptive_quoter(ctx, fair):
-    if fair is None:
-        return []
-    vol = ctx.params.get("_volatility", None)  # Injected by hz.volatility() pipeline
-    base_spread = ctx.params.get("spread", 0.06)
-    if vol and vol.best > 0:
-        spread = base_spread * (1 + vol.best * 2)  # widen on high vol
-    else:
-        spread = base_spread
-    return hz.quotes(fair, spread=spread, size=ctx.params.get("size", 5))
+# Access via ctx.params.get("_volatility").best — widen spreads in high-vol, tighten in low-vol
 
 ## Execution Algorithms
-For large orders that need careful execution:
-from horizon import TWAP, VWAP, Iceberg
-
 TWAP(engine, side, size, duration_secs=300, num_slices=10)   # Equal time slices
-VWAP(engine, side, size, duration_secs=300, volume_profile=[0.1, 0.15, ...])  # Volume-weighted
+VWAP(engine, side, size, duration_secs=300, volume_profile=[...])  # Volume-weighted
 Iceberg(engine, side, total_size, show_size=5)               # Hidden size
-
 # All have: .start(), .on_tick(), .is_complete, .total_filled
-# Use TWAP for uniform execution, VWAP for volume-aware, Iceberg for hiding size
 
 ## Market Discovery
-Find real markets programmatically instead of hardcoding slugs:
 hz.discover_markets(exchange="polymarket", query="bitcoin", min_volume=10000, sort_by="volume")
-hz.top_markets(exchange="polymarket", limit=20)  # Highest-volume active markets
-hz.discover_events(exchange="polymarket")         # Multi-outcome events
+hz.top_markets(exchange="polymarket", limit=20)
+hz.discover_events(exchange="polymarket")
 
 ## Portfolio Management
-For multi-strategy coordination and risk budgeting:
-port = hz.Portfolio(name="my_fund", capital=10000)
-port.add_position(market_id, side, size, entry_price)
-port.update_price(market_id, current_price)
-# Optimization: port.optimize("kelly") | "equal_weight" | "risk_parity" | "min_variance"
-# Risk: port.var_95(), port.cvar_95(), port.correlation_matrix()
-# Rebalance: port.needs_rebalance(threshold=0.05), port.rebalance_orders()
-
-## Kelly Criterion (built-in)
-hz.edge(fair_prob=0.55, market_price=0.50)          # Expected value
-hz.kelly(prob=0.55, price=0.50)                     # Full Kelly fraction
-hz.fractional_kelly(prob=0.55, price=0.50, fraction=0.25)  # Conservative (recommended)
-hz.kelly_size(prob=0.55, price=0.50, bankroll=1000, max_size=50)  # Contract units
-hz.kelly_sizer(fraction=0.25, bankroll=1000)        # Pipeline factory
-hz.kelly_sizer_with_liquidity(fraction=0.25, bankroll=1000)  # Dampens for illiquid markets
+hz.Portfolio(name, capital) — .add_position(), .update_price(), .optimize("kelly"|"equal_weight"|"risk_parity"|"min_variance"), .var_95(), .cvar_95(), .needs_rebalance(threshold), .rebalance_orders()
+
+## Kelly Criterion
+hz.edge(fair_prob, market_price)                              # Expected value
+hz.kelly(prob, price)                                         # Full Kelly fraction
+hz.fractional_kelly(prob, price, fraction=0.25)               # Conservative (recommended)
+hz.kelly_size(prob, price, bankroll, max_size)                 # Contract units
+hz.kelly_sizer(fraction=0.25, bankroll=1000)                  # Pipeline factory
+hz.kelly_sizer_with_liquidity(fraction=0.25, bankroll=1000)   # Dampens for illiquid markets
 
 ## Sentinel — Continuous Risk Monitor
-hz.sentinel(portfolio, config={
-    "drawdown_levels": [-5, -10, -20, -30],  # alert, reduce, pause, exit
-    "regime_lookback": 50,
-    "var_confidence": 0.95,
-})
-# Auto-reduces position size in high-drawdown regimes
-# Detects: drawdown escalation, regime change, correlation spikes
+hz.sentinel(portfolio, config={"drawdown_levels": [-5,-10,-20,-30], "regime_lookback": 50, "var_confidence": 0.95})
+hz.suggest_hedges(portfolio, budget=500)
 # Actions: alert, reduce_positions, pause_trading, emergency_exit
-hz.suggest_hedges(portfolio, budget=500)  # Hedge recommendations
-
-## Promotion Gates (paper → live)
-Before deploying live, strategies should pass:
-- Sharpe ratio >= 1.0
-- At least 30 trades
-- Walk-forward p-value < 0.05
-- Probability of Backtest Overfitting (PBO) < 50%
-- Max drawdown < 10% of capital
 
 ## Quant Functions (Rust-native, call as hz.function_name)
 
 ### Risk Analytics
-hz.var(returns, confidence=0.95)          # Value at Risk
-hz.cvar(returns, confidence=0.95)         # Conditional VaR (expected shortfall)
-hz.max_drawdown(equity_curve)             # Maximum drawdown
-hz.sharpe_ratio(returns, rf=0.0)          # Annualized Sharpe
-hz.sortino_ratio(returns, rf=0.0)         # Downside-only Sharpe
-
-### Volatility (individual functions)
-hz.parkinson_vol(highs, lows)             # Range-based
-hz.garman_klass_vol(opens, highs, lows, closes)
-hz.yang_zhang_vol(opens, highs, lows, closes)
-hz.ewma_vol(returns, lambda_=0.94)        # Exponentially weighted
-hz.rolling_vol(returns, window=20)
+hz.var(returns, confidence=0.95); hz.cvar(returns, confidence=0.95)
+hz.max_drawdown(equity_curve); hz.sharpe_ratio(returns, rf=0.0); hz.sortino_ratio(returns, rf=0.0)
+
+### Volatility (individual)
+hz.parkinson_vol(highs, lows); hz.garman_klass_vol(opens, highs, lows, closes)
+hz.yang_zhang_vol(opens, highs, lows, closes); hz.ewma_vol(returns, lambda_=0.94); hz.rolling_vol(returns, window=20)
 
 ### Information Theory
-hz.shannon_entropy(distribution)          # Bits of uncertainty
-hz.kl_divergence(p, q)                    # Distribution divergence
-hz.mutual_information(x, y)              # Shared information
+hz.shannon_entropy(distribution); hz.kl_divergence(p, q); hz.mutual_information(x, y)
 
 ### Market Microstructure
-hz.kyles_lambda(prices, volumes)          # Price impact coefficient
-hz.amihud_ratio(returns, volumes)         # Illiquidity measure
-hz.roll_spread(returns)                   # Implicit bid-ask
-hz.lob_imbalance(bids, asks, levels=5)   # Orderbook pressure
-hz.weighted_mid(bids, asks)              # Depth-weighted mid
+hz.kyles_lambda(prices, volumes); hz.amihud_ratio(returns, volumes); hz.roll_spread(returns)
+hz.lob_imbalance(bids, asks, levels=5); hz.weighted_mid(bids, asks)
 
 ### Statistical Testing
-hz.deflated_sharpe(sharpe, n_trials, n_obs)   # Backtest overfitting check
-hz.benjamini_hochberg(p_values, alpha=0.05)   # False discovery rate
-
-### Advanced Filters & Detectors
-KalmanFilter(dim_state, dim_obs)          # Linear state estimation
-UnscentedKF(dim_state, dim_obs)          # Non-linear state estimation
-ParticleFilter(n_particles, dim_state)    # Sequential Monte Carlo
-BocpdDetector(hazard_rate=100)           # Bayesian changepoint detection
-MarkovRegimeModel(n_regimes=2)           # Regime switching
-VpinDetector(volume_bucket_size)         # Informed trading probability
-CusumDetector(threshold, drift)          # Sequential change detection
-OfiTracker(window=100)                   # Order flow imbalance
+hz.deflated_sharpe(sharpe, n_trials, n_obs); hz.benjamini_hochberg(p_values, alpha=0.05)
+
+### Filters & Detectors
+KalmanFilter(dim_state, dim_obs); UnscentedKF(dim_state, dim_obs); ParticleFilter(n_particles, dim_state)
+BocpdDetector(hazard_rate=100); MarkovRegimeModel(n_regimes=2); VpinDetector(volume_bucket_size)
+CusumDetector(threshold, drift); OfiTracker(window=100)
 
 ### Copulas & Dependence
-hz.fit_copula(u, v, family="gaussian")    # Bivariate copula
-hz.best_copula(u, v)                     # Auto-select family
-hz.fit_vine(data)                        # Vine copula for >2 variables
+hz.fit_copula(u, v, family="gaussian"); hz.best_copula(u, v); hz.fit_vine(data)
 
 ### Portfolio Optimization
-hz.hrp_weights(returns)                  # Hierarchical Risk Parity
-hz.denoise_covariance(cov_matrix, n_obs) # Marcenko-Pastur shrinkage
-hz.robust_optimize(returns, gamma=1.0)   # Worst-case robust
+hz.hrp_weights(returns); hz.denoise_covariance(cov_matrix, n_obs); hz.robust_optimize(returns, gamma=1.0)
 
 ### Optimal Execution
 hz.gp_optimal_trajectory(total_size, urgency, risk_aversion, n_steps)  # Garleanu-Pedersen
 hz.ac_optimal_schedule(total_size, volatility, n_steps, risk_aversion)  # Almgren-Chriss
-hz.queue_fill_prob(queue_pos, total_depth, cancel_rate)  # Fill probability
+hz.queue_fill_prob(queue_pos, total_depth, cancel_rate)
 
 ### Data Preparation (AFML)
-hz.tick_bars(trades, threshold)           # Fixed-count bars
-hz.volume_bars(trades, threshold)         # Fixed-volume bars
-hz.dollar_bars(trades, threshold)         # Fixed-dollar bars
-hz.triple_barrier_labels(prices, upper, lower, max_holding)  # Event-driven labels
-hz.frac_diff_weights(d, threshold=1e-5)  # Fractional differentiation
-hz.min_frac_diff(series, max_d=1.0)      # Min d for stationarity
+hz.tick_bars(trades, threshold); hz.volume_bars(trades, threshold); hz.dollar_bars(trades, threshold)
+hz.triple_barrier_labels(prices, upper, lower, max_holding)
+hz.frac_diff_weights(d, threshold=1e-5); hz.min_frac_diff(series, max_d=1.0)
 
 ### Lead-Lag & Causality
-hz.granger_causality(x, y, max_lag=10)   # Causal relationships
-hz.cross_correlation_lags(x, y, max_lag) # Temporal alignment
-hz.lead_lag_network(series_dict)         # Multi-asset structure
+hz.granger_causality(x, y, max_lag=10); hz.cross_correlation_lags(x, y, max_lag); hz.lead_lag_network(series_dict)
 
 ### Stat Arb
-hz.cointegration_test(x, y)             # Engle-Granger test
-hz.spread_zscore(x, y, lookback=60)     # Mean-reversion z-score
+hz.cointegration_test(x, y); hz.spread_zscore(x, y, lookback=60)
 
-## hz.run() — Full Parameter Reference
-hz.run(
-    exchange=hz.Polymarket(),      # Single exchange (or exchanges=[...] for multi)
-    markets=["slug-1", "slug-2"],  # Market slugs
-    feeds={"mid": hz.PolymarketBook("slug-1")},
-    pipeline=[signal_fn, quoter_fn],  # Or dict: {"slug-1": [fn1], "*": [default_fn]}
-    risk=hz.Risk(...),
-    mode="paper",                  # "paper" | "live"
-    params={"spread": 0.06},
-    interval=0.5,                  # Seconds between cycles (default 0.5)
-    events=[hz.Event(...)],        # For multi-outcome events
-    db_path="./strategy.db",       # SQLite persistence (default: enabled)
-    netting_pairs=[("mkt-a", "mkt-b")],  # Cross-hedge pairs
-    dashboard=True,                # Enable built-in TUI dashboard
-)
+### Walk-Forward Optimization
+from horizon.walkforward import walk_forward
+walk_forward(data, pipeline_factory, param_grid, n_splits=5, train_ratio=0.7, expanding=True, objective="sharpe_ratio", purge_gap=3600.0)
 
-## hz.backtest() — Advanced Parameters
-hz.backtest(
-    pipeline=[...], markets=[...], feeds={...}, risk=hz.Risk(...),
-    data_points=500, initial_capital=1000, base_price=0.50,
-    fill_model="deterministic",    # "deterministic" | "probabilistic" | "glft"
-    fill_model_params={},          # Model-specific: {"fill_rate": 0.7}
-    impact_temporary_bps=2.0,      # Temporary market impact
-    impact_permanent_fraction=0.1, # Permanent price impact
-    latency_ms=50.0,              # Simulated execution latency
-    rng_seed=42,                  # For reproducibility
-)
+### Calibration Analytics
+from horizon._horizon import calibration_curve, log_loss, edge_decay
+# calibration_curve(predictions, outcomes, n_bins) -> (bin_centers, actual_freqs, ece, brier)
+# log_loss(predictions, outcomes) -> float; edge_decay(edge_series, timestamps) -> half_life_seconds
 `;
 
 
@@ -671,55 +545,23 @@ hz.run(
 
 const EXAMPLE_BACKTEST = `
 import horizon as hz
-from horizon.context import FeedData
 import json
 
-def fair_value(ctx):
-    feed = ctx.feeds.get("default", FeedData())
-    return feed.price if feed.price > 0 else 0.50
-
-def quoter(ctx, fair):
-    skew = ctx.inventory.net * 0.002
-    return hz.quotes(fair - skew, spread=0.06, size=5)
-
-data = [
-    {"timestamp": float(i), "price": 0.50 + 0.05 * ((-1) ** i) * (i % 10) / 10}
-    for i in range(500)
-]
-
 result = hz.backtest(
-    name="mm_backtest",
-    markets=["test-market"],
-    data=data,
+    name="mm_backtest", markets=["test-market"],
+    data=[{"timestamp": float(i), "price": 0.50 + 0.05*((-1)**i)*(i%10)/10} for i in range(500)],
     pipeline=[fair_value, quoter],
-    risk=hz.Risk(max_position=50, max_drawdown_pct=10),
-    initial_capital=100.0,
+    risk=hz.Risk(max_position=50, max_drawdown_pct=10), initial_capital=100.0,
 )
 
-# Output structured JSON for TUI parsing
+# TUI output markers (REQUIRED for dashboard parsing):
 m = result.metrics
 print("---BACKTEST_JSON---")
-print(json.dumps({
-    "strategy_name": "mm_backtest",
-    "summary": result.summary(),
-    "equity_curve": [e for _, e in result.equity_curve],
-    "trade_count": len(result.trades),
-    "metrics": {
-        "total_return": m.total_return,
-        "max_drawdown": m.max_drawdown,
-        "sharpe_ratio": m.sharpe_ratio,
-        "sortino_ratio": m.sortino_ratio,
-        "win_rate": m.win_rate,
-        "profit_factor": m.profit_factor,
-        "total_trades": m.trade_count,
-        "expectancy": m.expectancy,
-        "total_fees": m.total_fees,
-    },
-    "pnl_by_market": result.pnl_by_market(),
-}))
+print(json.dumps({"strategy_name": "mm_backtest", "summary": result.summary(),
+    "equity_curve": [e for _, e in result.equity_curve], "trade_count": len(result.trades),
+    "metrics": {k: getattr(m, k) for k in ["total_return","max_drawdown","sharpe_ratio","sortino_ratio","win_rate","profit_factor","trade_count","expectancy","total_fees"]},
+    "pnl_by_market": result.pnl_by_market()}))
 print("---END_BACKTEST_JSON---")
-
-# ASCII dashboard
 bundle = hz.from_backtest(result)
 print("---ASCII_DASHBOARD---")
 print(hz.dashboard(bundle))
@@ -728,275 +570,15 @@ print("---END_ASCII_DASHBOARD---")
 
 const STRATEGY_TEMPLATES = `
 # ── Strategy Templates ──
-# Reference these when the user asks for a specific strategy type.
-# Adapt parameters to the user's market, capital, and risk tolerance.
-
-## Template 1: Conservative Market Maker
-# Style: Wide spreads, small size, low risk. Good for beginners.
-# Capital: $500-2000 | Risk: Conservative | Expected Sharpe: 0.5-1.5
-# Best for: High-volume markets with tight spreads
-
-import horizon as hz
-
-def fair_value(ctx):
-    feed = ctx.feeds.get("mid")
-    if not feed or feed.is_stale(30):
-        return None
-    return feed.price
-
-def conservative_quoter(ctx, fair):
-    if fair is None:
-        return []
-    inv = ctx.inventory.net
-    max_pos = ctx.params.get("max_position", 50)
-    skew = inv / max_pos if max_pos > 0 else 0
-    spread = ctx.params.get("spread", 0.10) * (1 + abs(skew) * 0.5)
-    size = ctx.params.get("size", 5)
-    if abs(inv) > max_pos * 0.8:
-        size = max(1, size // 2)
-    return hz.quotes(fair, spread=spread, size=size)
-
-hz.run(
-    name="ConservativeMarketMaker",
-    exchange=hz.Polymarket(),
-    markets=["your-market-slug"],
-    feeds={"mid": hz.PolymarketBook("your-market-slug")},
-    pipeline=[fair_value, conservative_quoter],
-    risk=hz.Risk(
-        max_position=50,
-        max_notional=500,
-        max_drawdown_pct=3,
-        max_order_size=5,
-    ),
-    mode="paper",
-    params={"initial_capital": 1000, "spread": 0.10, "size": 5, "max_position": 50}
-)
-# Capital & Risk: $1,000 paper. Max $500 exposure. Kill switch at 3% ($15). Conservative.
-
-## Template 2: Momentum Follower with Kelly Sizing
-# Style: Directional, follows price trends. Uses Kelly for position sizing.
-# Capital: $1000-5000 | Risk: Moderate | Expected Sharpe: 1.0-2.0
-# Best for: Trending markets (elections, crypto events)
-
-import horizon as hz
-from collections import deque
-
-_prices: dict[str, deque] = {}
-
-def momentum_signal(ctx):
-    feed = ctx.feeds.get("mid")
-    if not feed or feed.is_stale(30):
-        return None
-    slug = ctx.market.slug
-    lookback = int(ctx.params.get("lookback", 20))
-    if slug not in _prices:
-        _prices[slug] = deque(maxlen=lookback)
-    _prices[slug].append(feed.price)
-    if len(_prices[slug]) < lookback:
-        return None
-    oldest = _prices[slug][0]
-    if oldest == 0:
-        return None
-    momentum = (feed.price - oldest) / oldest
-    return {"mid": feed.price, "momentum": momentum}
-
-def kelly_quoter(ctx, signal):
-    if signal is None:
-        return []
-    momentum = signal["momentum"]
-    threshold = ctx.params.get("threshold", 0.02)
-    if abs(momentum) < threshold:
-        return []
-    fair = signal["mid"]
-    prob = 0.5 + min(0.2, abs(momentum) * 2)
-    fraction = ctx.params.get("kelly_fraction", 0.25)
-    kelly_f = max(0, (prob - (1 - prob)) * fraction)
-    size = max(1, int(kelly_f * ctx.params.get("bankroll", 1000) / fair))
-    size = min(size, ctx.params.get("max_size", 20))
-    spread = ctx.params.get("spread", 0.04)
-    return hz.quotes(fair, spread=spread, size=size)
-
-hz.run(
-    name="MomentumFollower",
-    exchange=hz.Polymarket(),
-    markets=["your-market-slug"],
-    feeds={"mid": hz.PolymarketBook("your-market-slug")},
-    pipeline=[momentum_signal, kelly_quoter],
-    risk=hz.Risk(
-        max_position=100,
-        max_notional=1000,
-        max_drawdown_pct=5,
-        max_order_size=20,
-    ),
-    mode="paper",
-    params={"initial_capital": 2000, "lookback": 20, "threshold": 0.02, "spread": 0.04, "kelly_fraction": 0.25, "bankroll": 2000, "max_size": 20}
-)
-# Capital & Risk: $2,000 paper. Max $1,000 exposure. Kill switch at 5% ($50). Moderate.
-
-## Template 3: Mean Reversion
-# Style: Fades extreme prices toward fair value using z-score.
-# Capital: $500-2000 | Risk: Conservative-Moderate | Expected Sharpe: 0.8-1.5
-# Best for: Range-bound markets, markets with known fair value
-
-import horizon as hz
-from collections import deque
-import math
-
-_history: dict[str, deque] = {}
-
-def mean_reversion_signal(ctx):
-    feed = ctx.feeds.get("mid")
-    if not feed or feed.is_stale(30):
-        return None
-    slug = ctx.market.slug
-    window = int(ctx.params.get("window", 30))
-    if slug not in _history:
-        _history[slug] = deque(maxlen=window)
-    _history[slug].append(feed.price)
-    if len(_history[slug]) < window:
-        return None
-    prices = list(_history[slug])
-    mean = sum(prices) / len(prices)
-    std = math.sqrt(sum((p - mean) ** 2 for p in prices) / len(prices))
-    if std < 0.001:
-        return None
-    zscore = (feed.price - mean) / std
-    return {"mid": feed.price, "mean": mean, "zscore": zscore}
-
-def reversion_quoter(ctx, signal):
-    if signal is None:
-        return []
-    z = signal["zscore"]
-    entry_z = ctx.params.get("entry_z", 1.5)
-    if abs(z) < entry_z:
-        return []
-    fair = signal["mean"]
-    spread = ctx.params.get("spread", 0.06)
-    size = ctx.params.get("size", 10)
-    return hz.quotes(fair, spread=spread, size=size)
-
-hz.run(
-    name="MeanReversion",
-    exchange=hz.Polymarket(),
-    markets=["your-market-slug"],
-    feeds={"mid": hz.PolymarketBook("your-market-slug")},
-    pipeline=[mean_reversion_signal, reversion_quoter],
-    risk=hz.Risk(
-        max_position=80,
-        max_notional=800,
-        max_drawdown_pct=5,
-        max_order_size=10,
-    ),
-    mode="paper",
-    params={"initial_capital": 1000, "window": 30, "entry_z": 1.5, "spread": 0.06, "size": 10}
-)
-# Capital & Risk: $1,000 paper. Max $800 exposure. Kill switch at 5% ($40). Moderate.
-
-## Template 4: Cross-Market Arb (Polymarket vs Kalshi)
-# Style: Captures price discrepancies between exchanges.
-# Capital: $2000-10000 | Risk: Low (market-neutral) | Expected Sharpe: 1.5-3.0
-# Best for: Markets listed on both Polymarket and Kalshi
-
-import horizon as hz
-
-def arb_detector(ctx):
-    poly = ctx.feeds.get("poly")
-    kalshi = ctx.feeds.get("kalshi")
-    if not poly or poly.is_stale(30) or not kalshi or kalshi.is_stale(30):
-        return None
-    edge = abs(poly.price - kalshi.price)
-    min_edge = ctx.params.get("min_edge", 0.03)
-    if edge < min_edge:
-        return None
-    if poly.price < kalshi.price:
-        return {"buy_exchange": "poly", "fair": poly.price, "edge": edge}
-    else:
-        return {"buy_exchange": "kalshi", "fair": kalshi.price, "edge": edge}
-
-def arb_quoter(ctx, signal):
-    if signal is None:
-        return []
-    size = ctx.params.get("size", 10)
-    spread = ctx.params.get("spread", 0.02)
-    return hz.quotes(signal["fair"], spread=spread, size=size)
-
-hz.run(
-    name="CrossMarketArb",
-    exchanges=[hz.Polymarket(), hz.Kalshi()],
-    markets=["your-market-slug"],
-    feeds={
-        "poly": hz.PolymarketBook("your-market-slug"),
-        "kalshi": hz.KalshiBook("your-kalshi-ticker"),
-    },
-    pipeline=[arb_detector, arb_quoter],
-    risk=hz.Risk(
-        max_position=100,
-        max_notional=2000,
-        max_drawdown_pct=3,
-        max_order_size=10,
-    ),
-    mode="paper",
-    params={"initial_capital": 5000, "min_edge": 0.03, "spread": 0.02, "size": 10}
-)
-# Capital & Risk: $5,000 paper. Max $2,000 exposure. Kill switch at 3% ($60). Low risk (market-neutral).
-
-## Template 5: Multi-Signal Ensemble
-# Style: Combines price, spread, momentum, and flow signals.
-# Capital: $1000-5000 | Risk: Moderate | Expected Sharpe: 1.0-2.5
-# Best for: Liquid markets with diverse data
-
-import horizon as hz
-from collections import deque
-
-_momentum_history: dict[str, deque] = {}
-
-def multi_signal(ctx):
-    feed = ctx.feeds.get("mid")
-    if not feed or feed.is_stale(30):
-        return None
-    slug = ctx.market.slug
-    lookback = int(ctx.params.get("lookback", 15))
-    if slug not in _momentum_history:
-        _momentum_history[slug] = deque(maxlen=lookback)
-    _momentum_history[slug].append(feed.price)
-    price_signal = feed.price
-    spread_signal = (feed.ask - feed.bid) if feed.ask > 0 and feed.bid > 0 else 0.05
-    history = _momentum_history[slug]
-    momentum_signal = (feed.price - history[0]) / history[0] if len(history) >= lookback and history[0] > 0 else 0
-    inventory_signal = -ctx.inventory.net * 0.001
-    weights = ctx.params.get("weights", [0.4, 0.2, 0.2, 0.2])
-    combined = (
-        weights[0] * price_signal +
-        weights[1] * (1 - spread_signal * 10) * price_signal +
-        weights[2] * momentum_signal * price_signal +
-        weights[3] * inventory_signal
-    )
-    fair = max(0.01, min(0.99, combined))
-    return fair
-
-def ensemble_quoter(ctx, fair):
-    if fair is None:
-        return []
-    spread = ctx.params.get("spread", 0.05)
-    size = ctx.params.get("size", 8)
-    return hz.quotes(fair, spread=spread, size=size)
-
-hz.run(
-    name="MultiSignalEnsemble",
-    exchange=hz.Polymarket(),
-    markets=["your-market-slug"],
-    feeds={"mid": hz.PolymarketBook("your-market-slug")},
-    pipeline=[multi_signal, ensemble_quoter],
-    risk=hz.Risk(
-        max_position=80,
-        max_notional=1000,
-        max_drawdown_pct=5,
-        max_order_size=15,
-    ),
-    mode="paper",
-    params={"initial_capital": 2000, "lookback": 15, "spread": 0.05, "size": 8, "weights": [0.4, 0.2, 0.2, 0.2]}
-)
-# Capital & Risk: $2,000 paper. Max $1,000 exposure. Kill switch at 5% ($50). Moderate.
+# Adapt patterns from EXAMPLE_MOMENTUM and EXAMPLE_INVENTORY_MM above. Key templates:
+
+| Template | Style | Capital | Risk | Sharpe | Best For |
+|---|---|---|---|---|---|
+| Conservative MM | Wide spreads, small size, inventory skew with size reduction at 80% capacity | $500-2K | Conservative (3% DD) | 0.5-1.5 | High-volume markets |
+| Momentum+Kelly | Directional trend-following, hz.fractional_kelly for sizing, threshold filter | $1K-5K | Moderate (5% DD) | 1.0-2.0 | Trending markets (elections, crypto) |
+| Mean Reversion | Z-score of rolling window, fade extremes toward mean, entry_z threshold | $500-2K | Moderate (5% DD) | 0.8-1.5 | Range-bound markets |
+| Cross-Market Arb | Two feeds (poly+kalshi), edge detection, market-neutral. Uses exchanges=[...] | $2K-10K | Low (3% DD) | 1.5-3.0 | Dual-listed markets |
+| Multi-Signal Ensemble | Weighted combination of price, spread, momentum, inventory signals via hz.combine_signals | $1K-5K | Moderate (5% DD) | 1.0-2.5 | Liquid markets |
 `;
 
 /**
@@ -1042,6 +624,18 @@ Read what the user says and match it to the RIGHT action. Do NOT generate code w
 | "what markets are available?" | Call polymarket_data |
 | "stop it" / "kill it" | Call stop_strategy |
 | "load my old strategy" | Call list_saved_strategies then load_saved_strategy |
+| "undo that" / "revert" | Call revert_strategy |
+| "show me versions" | Call strategy_versions |
+| "how has this performed?" | Call strategy_report |
+| "health check" / "score" | Call health_score |
+| "alert me if..." | Call set_alert |
+| "export this" / "share this" | Call export_strategy |
+| "try different spreads" | Call parameter_sweep |
+| "find opportunities" | Call scan_opportunities |
+| "what should I trade?" | Call scan_opportunities |
+| "are my markets correlated?" | Call scan_correlations |
+| "show me the replay" | Call replay_session |
+| "portfolio status" | Call portfolio_summary |
 
 **Key rule:** If the user asks a question about the code, strategy concepts, or markets — answer with text. Do NOT write code or call tools unless they explicitly want a change or action.
 
@@ -1082,76 +676,75 @@ If the user wants live mode, warn them first, then deploy with dry_run=false.
 
 **The user does NOT need to know strategy_id or credential_id.** You handle that.
 
-## File I/O (Workspace)
+## File I/O (Workspace: ~/.horizon/workspace/)
+\`write_file(path, content)\`, \`read_file(path)\`, \`list_files(directory?)\` — sandboxed, relative paths only. Subdirs: dashboards/, scripts/, data/. Max 1MB. Blocked: .sh/.bash/.zsh
 
-You have sandboxed file access in ~/.horizon/workspace/. Use it for dashboards, data, and scripts.
+## Dashboard (File-Based — PREFERRED)
 
-- \`write_file(path, content)\` — Write to workspace. Creates dirs. Max 1MB. Blocked: .sh/.bash/.zsh
-- \`read_file(path)\` — Read from workspace
-- \`list_files(directory?)\` — List files. Default subdirs: dashboards/, scripts/, data/
+1. \`write_file("dashboards/monitor.html", html)\` → \`spawn_dashboard(file_path="dashboards/monitor.html")\` → \`check_dashboard_errors()\`
+2. Quick built-in: \`spawn_dashboard(strategy_id="local")\` — no custom HTML needed.
 
-Paths are relative to workspace root. No absolute paths, no .., no dotfiles.
+### Horizon Design System (MANDATORY)
+CSS vars: \`--bg:#0d1117; --bg2:#161b22; --bg3:#1c2128; --border:#30363d; --text:#c9d1d9; --text-dim:#636e7b; --text-bright:#f0f6fc; --accent:#4d8ef7; --green:#3fb950; --red:#f85149; --yellow:#d29922; --radius:12px\`
+- Dark theme only. Cards: bg2+border+radius. Headers/labels: 11px uppercase, text-dim. Values: 22px weight-600 tabular-nums.
+- P&L: green (+$) / red (-$). Chart.js: animation:false, accent border, 0 pointRadius, 0.2 tension.
+- Layout: Header bar → 6-metric grid → equity chart (5fr) + positions (2fr) → logs (max-height 180px scroll).
 
-## Dashboard (File-Based — PREFERRED)
+**Data Sources:**
+- \`/api/local/metrics\` → \`{pnl, rpnl, upnl, orders, positions, trades, win_rate, sharpe, max_dd, exposure, pos, hist}\`
+- \`/api/local/logs\` → \`string[]\` | \`/api/local-logs\` → \`{[pid]: {stdout, stderr, alive}}\`
+- \`/api/strategy\` → \`{name, code, params, riskConfig}\`
+- Refresh: 3s local, 10s platform
 
-**NEVER pass huge HTML strings to custom_html.** Use file-based mode instead:
+## Version Control
 
-1. \`write_file("dashboards/monitor.html", html)\` — Write the HTML file
-2. \`spawn_dashboard(file_path="dashboards/monitor.html")\` — Serve it (reads from disk each request)
-3. \`check_dashboard_errors()\` — Verify no JS errors
-4. If errors: \`read_file("dashboards/monitor.html")\` → fix → \`write_file(...)\` → browser refresh auto-shows changes
+Every code change is automatically versioned. Tools:
+- **strategy_versions(name)** — List all versions with timestamps
+- **revert_strategy(name, version)** — Restore a previous version
+- **diff_versions(name, v1, v2)** — Show what changed between versions
 
-For quick built-in monitoring: \`spawn_dashboard(strategy_id="local")\` — no custom HTML needed.
+When the user says "undo that" or "go back" → call revert_strategy.
 
-### Horizon Design System (MANDATORY for all dashboards)
+## Performance Ledger
 
-Every dashboard you create MUST follow this design system exactly. No exceptions.
+Every backtest and run is logged to a persistent ledger. Tools:
+- **strategy_report(name)** — Full performance history, version comparison, trends
+- **health_score()** — Code quality score 0-100 (risk config, feed guards, pipeline depth, etc.)
 
-**Color Tokens (CSS variables — always define in :root):**
-\`\`\`css
-:root {
-  --bg: #0d1117; --bg2: #161b22; --bg3: #1c2128;
-  --border: #30363d; --border-focus: #4d8ef7;
-  --text: #c9d1d9; --text-dim: #636e7b; --text-bright: #f0f6fc;
-  --accent: #4d8ef7; --accent-dim: #2557a7;
-  --green: #3fb950; --red: #f85149; --yellow: #d29922;
-  --radius: 12px;
-}
-\`\`\`
+Reference ledger data when advising: "Last time you ran this, Sharpe was 0.8. This version looks better."
+
+## Alerts & Monitoring
+
+- **set_alert(condition_type, threshold, action_type)** — Create alerts (max_dd_exceeds, pnl_below, exposure_above, win_rate_below). Actions: log, stop_process, webhook.
+- **list_alerts()** / **remove_alert(id)** — Manage alerts
+
+When user says "alert me if drawdown exceeds 5%" → set_alert(condition_type="max_dd_exceeds", threshold=5, action_type="log").
+
+## Export / Import
+
+- **export_strategy()** — Export to .hz file (code + params + performance data)
+- **import_strategy(path)** — Import from .hz file
 
-**Rules:**
-- body: \`background: var(--bg); color: var(--text); font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;\`
-- Cards: \`background: var(--bg2); border: 1px solid var(--border); border-radius: var(--radius)\`
-- Card headers: \`font-size: 11px; text-transform: uppercase; letter-spacing: 1px; color: var(--text-dim); border-bottom: 1px solid var(--border)\`
-- Metric labels: \`font-size: 10px; text-transform: uppercase; letter-spacing: 1px; color: var(--text-dim)\`
-- Metric values: \`font-size: 22px; font-weight: 600; font-variant-numeric: tabular-nums\`
-- P&L positive: \`color: var(--green)\` with +$ prefix. P&L negative: \`color: var(--red)\` with -$ prefix
-- Status dot live: \`background: var(--green); box-shadow: 0 0 6px var(--green)\`
-- Header bar: \`background: var(--bg2); border-bottom: 1px solid var(--border)\` with "HORIZON" logo in accent, 11px, letter-spacing 3px
-- Monospace text (logs, code): \`font-family: 'SF Mono', 'Fira Code', monospace; font-size: 11px\`
-- Grid layout: CSS Grid with \`gap: 16px; padding: 0 24px\`
-- Metrics row: \`display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 1px; background: var(--border)\` with each metric cell on var(--bg2)
-- Chart.js config: \`animation: false; borderColor: rgba(77,142,247,0.8); fill.above: rgba(77,142,247,0.06); fill.below: rgba(248,81,73,0.06); pointRadius: 0; tension: 0.2\`
-- Grid lines: \`color: #21262d\`. Tick labels: \`color: #636e7b; font-size: 10\`
-- Empty states: centered, dim text with pulsing accent dot
-- NEVER use white backgrounds, light themes, or colors outside this palette
-- NEVER use inline styles for colors — always use CSS variables
-
-**Data Sources (fetch from these live API endpoints):**
-- \`/api/local/metrics\` → \`{ pnl, rpnl, upnl, orders, positions, trades, win_rate, sharpe, max_dd, exposure, pos: [{id, side, sz, entry, rpnl, upnl}], hist: [number] }\`
-- \`/api/local/logs\` → \`string[]\` (stdout/stderr lines)
-- \`/api/local-logs\` → \`{ [pid]: { stdout, stderr, alive } }\`
-- \`/api/strategy\` → \`{ name, code, params, riskConfig }\`
-- Auto-refresh: \`setInterval(refresh, 3000)\` for local, 10000 for platform
-
-**Standard Metrics to Display:**
-P&L (with realized sub-label), Win Rate (with trade count), Sharpe Ratio, Max Drawdown %, Exposure $, Orders count. Color-code: green for good (P&L>0, win_rate>=50%, sharpe>1), red for bad, yellow for warnings.
-
-**Standard Layout Order:**
-1. Header bar (logo + strategy name + LOCAL/PLATFORM badge + status dot + uptime)
-2. Metrics row (6 metric cards in auto-fit grid)
-3. Main grid: equity chart (5fr) + positions list (2fr)
-4. Logs card (full width, max-height 180px with overflow scroll)
+## Replay & Attribution
+
+- **replay_session(file_name?)** — View execution replay (order timeline, metric snapshots, errors). Without file_name, lists replays.
+- **portfolio_summary()** — Aggregate P&L across all running processes
+
+After a strategy runs 30+ minutes, offer performance attribution: which positions drove P&L, which signals helped/hurt. Use replay data and metrics to explain what happened.
+
+## Parameter Tuning
+
+When the user asks to "try different values" or "sweep parameters" or "optimize":
+- **parameter_sweep(param_name, values)** — Runs backtests for each value, returns comparison table
+
+Example: User says "try spreads from 0.02 to 0.08" → call parameter_sweep(param_name="spread", values=[0.02, 0.04, 0.06, 0.08]). Present results as a comparison: "0.04 had the best Sharpe (1.42), 0.02 had most trades but worst DD."
+
+## Market Scanning
+
+- **scan_opportunities(limit?)** — Scan top Polymarket markets for wide spreads, high volume, mispricings
+- **scan_correlations(slugs[])** — Compute pairwise correlations between markets in a portfolio
+
+When user asks "what should I trade?" or "find opportunities" → scan_opportunities. When user has multiple markets → warn about correlation/concentration risk.
 
 ## Other Tools
 
@@ -1163,12 +756,6 @@ P&L (with realized sub-label), Win Rate (with trade count), Sharpe Ratio, Max Dr
 - **get_metrics / get_logs** — Monitor running deployments
 - **check_dashboard_errors** — Check JS errors in file-based dashboards
 
-## Communication Style
-- SHORT and DIRECT. No filler, no preamble.
-- For code: write the fence, then 1-2 sentences explaining what it does.
-- For edits: one sentence + the edit_strategy call.
-- For questions: answer clearly. Show numbers when analyzing viability.
-
 ## Code Requirements
 
 The code you generate is the EXACT code that runs on Horizon. It must:
@@ -1212,8 +799,6 @@ ${EXAMPLE_MOMENTUM}
 ${EXAMPLE_INVENTORY_MM}
 
 ### Strategy Templates
-When a user asks for a specific strategy type (market maker, momentum, arb, etc.), reference the corresponding template below. Adapt the parameters to their market, capital, and risk tolerance.
-
 ${STRATEGY_TEMPLATES}`;
 }