horizon-code 0.3.2 → 0.5.0

package/src/strategy/prompts.ts

@@ -15,11 +15,31 @@ Values clamp to [0.01, 0.99]. Invalid spreads return empty list.
 Always check feeds: \`if not feed or feed.is_stale(5): return []\`
 is_stale() returns True if no data in N seconds OR feed never connected.
 
-## Common Mistakes
-- Returning a dict/float from the LAST pipeline function — must return list[Quote] or []
-- Not guarding against None/stale feeds on first cycle
-- Using ctx.market.id as slug — both id and slug are set to the input string
-- Submitting identical orders rapidly — dedup risk check rejects them
+## Anti-Patterns (NEVER DO THESE)
+- NEVER return a raw float or dict from the last pipeline function — must return list[Quote] or []
+- NEVER use getattr() — it is blocked by the sandbox validator. Use ctx.params.get() instead
+- NEVER use time.sleep() — the engine handles timing via the interval parameter
+- NEVER hardcode market slugs — use ctx.market.slug or ctx.params["market"]
+- NEVER use Decimal — all values are plain float
+- NEVER call exec(), eval(), subprocess, or os — sandbox blocks them
+- NEVER do file I/O or network calls inside pipeline functions
+- NEVER access ctx.inventory as a dict — it's InventorySnapshot with .positions, .net, .net_for_market()
+- NEVER submit identical orders rapidly — the risk engine dedup check rejects them
+- NEVER use \`from horizon.context import ...\` — just use \`import horizon as hz\` and access via hz.*
+
+## Context Object Quick Reference
+ctx.feeds: dict[str, FeedData]      # Feed snapshots by name
+ctx.feed: FeedData                   # Shortcut to first feed
+ctx.inventory: InventorySnapshot     # Current positions (NOT a dict!)
+ctx.inventory.net: float             # Total net exposure
+ctx.inventory.net_for_market(id)     # Per-market net
+ctx.inventory.positions: list[Position]
+ctx.market: Market                   # Current market metadata
+ctx.market.slug: str                 # Market slug
+ctx.status: EngineStatus             # Engine state
+ctx.status.total_pnl(): float       # Total P&L
+ctx.status.kill_switch_active: bool
+ctx.params: dict                     # User-defined parameters (tunable)
 `;
 
 const RISK_CAPITAL_GUIDE = `
@@ -200,11 +220,22 @@ 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
 
-# ── Exchange Types (for hz.run exchange=...) ──
+# ── 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): ...
 
 # ── Built-in Pipeline Factories ──
 
@@ -376,7 +407,7 @@ hz.volatility(lookback=20, method="yang_zhang")  # Pipeline function
 def adaptive_quoter(ctx, fair):
     if fair is None:
         return []
-    vol = getattr(ctx, 'volatility', None)
+    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
@@ -436,8 +467,111 @@ Before deploying live, strategies should pass:
 - 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)
+
+### Information Theory
+hz.shannon_entropy(distribution)          # Bits of uncertainty
+hz.kl_divergence(p, q)                    # Distribution divergence
+hz.mutual_information(x, y)              # Shared information
+
+### 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
+
+### 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
+
+### 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
+
+### 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
+
+### 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
+
+### 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
+
+### 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
+
+### Stat Arb
+hz.cointegration_test(x, y)             # Engle-Granger test
+hz.spread_zscore(x, y, lookback=60)     # Mean-reversion z-score
+
+## 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
+)
+
+## 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
+)
 `;
 
+
 const EXAMPLE_MOMENTUM = `
 import horizon as hz
 from collections import deque
@@ -903,7 +1037,7 @@ Read what the user says and match it to the RIGHT action. Do NOT generate code w
 | "run it" / "start it" | Call run_strategy |
 | "deploy it" / "put it live" | Run the deploy flow (see below) |
 | "show me BTC markets" | Call polymarket_data |
-| "build me a dashboard" | Call spawn_dashboard with custom HTML |
+| "build me a dashboard" | write_file the HTML, then spawn_dashboard(file_path=...) |
 | "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 |
@@ -947,12 +1081,76 @@ 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.
 
-## Dashboard
+## File I/O (Workspace)
+
+You have sandboxed file access in ~/.horizon/workspace/. Use it for dashboards, data, and scripts.
+
+- \`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/
+
+Paths are relative to workspace root. No absolute paths, no .., no dotfiles.
+
+## Dashboard (File-Based — PREFERRED)
+
+**NEVER pass huge HTML strings to custom_html.** Use file-based mode instead:
+
+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
+
+For quick built-in monitoring: \`spawn_dashboard(strategy_id="local")\` — no custom HTML needed.
+
+### Horizon Design System (MANDATORY for all dashboards)
+
+Every dashboard you create MUST follow this design system exactly. No exceptions.
+
+**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;
+}
+\`\`\`
 
-\`spawn_dashboard\` serves a local web page. You write the HTML/CSS/JS from scratch:
-- Dark theme, Chart.js from CDN for charts
-- Auto-refresh every 3-5 seconds
-- The user can ask you to modify it — just call spawn_dashboard again
+**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)
 
 ## Other Tools
 
@@ -962,6 +1160,7 @@ If the user wants live mode, warn them first, then deploy with dry_run=false.
 - **load_saved_strategy / list_saved_strategies** — Resume work on saved strategies
 - **list_strategies** — See what's on the platform
 - **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.

package/src/strategy/tools.ts

@@ -11,6 +11,7 @@ import { dashboard } from "./dashboard.ts";
 import { runInSandbox, spawnInSandbox } from "./sandbox.ts";
 import { saveStrategy, loadStrategy, listSavedStrategies } from "./persistence.ts";
 import { hyperlink } from "../util/hyperlink.ts";
+import { writeWorkspaceFile, readWorkspaceFile, listWorkspaceFiles } from "./workspace.ts";
 import type { StrategyDraft } from "../state/types.ts";
 
 const t = tool as any;
@@ -44,8 +45,8 @@ function startCapturing(pid: number, managed: ManagedProcess): void {
         for (const line of text.split("\n")) {
           if (line) buffer.push(line);
         }
-        // Rolling buffer — keep last 200 lines
-        while (buffer.length > 200) buffer.shift();
+        // Rolling buffer — keep last 1000 lines
+        while (buffer.length > 1000) buffer.shift();
       }
     } catch {}
   };
@@ -129,21 +130,75 @@ const METRICS_REPORTER = `
 import json as _json, sys as _sys, time as _time
 _hz_last_report = [0.0]
 _hz_pnl_history = []
+_hz_peak_equity = [0.0]
+_hz_start_time = [0.0]
+_hz_trade_count = [0]
+_hz_win_count = [0]
+_hz_prev_positions = [{}]
 def _hz_report(ctx, quotes):
     _now = _time.time()
+    if _hz_start_time[0] == 0.0:
+        _hz_start_time[0] = _now
     if _now - _hz_last_report[0] >= 5.0:
         _hz_last_report[0] = _now
         _s = ctx.status
         _inv = ctx.inventory
         if _s:
-            _m = {"__hz__": 1, "pnl": _s.total_pnl(), "rpnl": _s.total_realized_pnl, "upnl": _s.total_unrealized_pnl, "orders": _s.open_orders, "positions": _s.active_positions, "uptime": _s.uptime_secs, "kill": _s.kill_switch_active}
-            if _inv:
-                _m["pos"] = [{"id": _p.market_id, "side": str(_p.side), "sz": _p.size, "entry": _p.avg_entry_price, "rpnl": _p.realized_pnl, "upnl": _p.unrealized_pnl} for _p in _inv.positions]
-            _hz_pnl_history.append(_s.total_pnl())
-            if len(_hz_pnl_history) > 60:
-                _hz_pnl_history.pop(0)
-            _m["hist"] = list(_hz_pnl_history)
-            print("__HZ_METRICS__" + _json.dumps(_m), file=_sys.stderr, flush=True)
+            try:
+                _pnl = _s.total_pnl()
+                # Track peak equity for drawdown calculation
+                if _pnl > _hz_peak_equity[0]:
+                    _hz_peak_equity[0] = _pnl
+                _max_dd = 0.0
+                if _hz_peak_equity[0] > 0:
+                    _max_dd = (_hz_peak_equity[0] - _pnl) / _hz_peak_equity[0] * 100
+                # Track trades by detecting position changes
+                if _inv:
+                    _curr_pos = {_p.market_id: _p.size for _p in _inv.positions}
+                    for _mid, _sz in _curr_pos.items():
+                        _prev_sz = _hz_prev_positions[0].get(_mid, 0)
+                        if _sz != _prev_sz and _prev_sz != 0:
+                            _hz_trade_count[0] += 1
+                            if _sz == 0 and hasattr(_inv, 'positions'):
+                                for _p in _inv.positions:
+                                    if _p.market_id == _mid and _p.realized_pnl > 0:
+                                        _hz_win_count[0] += 1
+                    for _mid in _hz_prev_positions[0]:
+                        if _mid not in _curr_pos:
+                            _hz_trade_count[0] += 1
+                    _hz_prev_positions[0] = dict(_curr_pos)
+                # Compute exposure
+                _exposure = 0.0
+                if _inv:
+                    for _p in _inv.positions:
+                        _exposure += abs(_p.size * _p.avg_entry_price)
+                _wr = _hz_win_count[0] / max(_hz_trade_count[0], 1)
+                # Sharpe approximation from PnL history
+                _sharpe = 0.0
+                if len(_hz_pnl_history) > 5:
+                    _returns = [_hz_pnl_history[i] - _hz_pnl_history[i-1] for i in range(1, len(_hz_pnl_history))]
+                    _mean_r = sum(_returns) / len(_returns)
+                    _var_r = sum((r - _mean_r)**2 for r in _returns) / len(_returns)
+                    if _var_r > 0:
+                        _sharpe = round(_mean_r / _var_r**0.5, 4)
+                _m = {
+                    "__hz__": 1,
+                    "pnl": _pnl, "rpnl": _s.total_realized_pnl, "upnl": _s.total_unrealized_pnl,
+                    "orders": _s.open_orders, "positions": _s.active_positions,
+                    "uptime": _s.uptime_secs, "kill": _s.kill_switch_active,
+                    "trades": _hz_trade_count[0], "wins": _hz_win_count[0],
+                    "win_rate": round(_wr, 4), "max_dd": round(_max_dd, 2),
+                    "sharpe": _sharpe, "exposure": round(_exposure, 2),
+                }
+                if _inv:
+                    _m["pos"] = [{"id": _p.market_id, "side": str(_p.side), "sz": _p.size, "entry": _p.avg_entry_price, "rpnl": _p.realized_pnl, "upnl": _p.unrealized_pnl} for _p in _inv.positions]
+                _hz_pnl_history.append(_pnl)
+                if len(_hz_pnl_history) > 120:
+                    _hz_pnl_history.pop(0)
+                _m["hist"] = list(_hz_pnl_history)
+                print("__HZ_METRICS__" + _json.dumps(_m), file=_sys.stderr, flush=True)
+            except Exception:
+                pass
     return quotes if quotes is not None else []
 `;
 
@@ -186,6 +241,8 @@ function injectMetricsReporter(code: string): string {
 export function parseLocalMetrics(managed: ManagedProcess): {
   pnl: number; rpnl: number; upnl: number;
   orders: number; positions: number; uptime: number; kill: boolean;
+  trades: number; wins: number; win_rate: number; max_dd: number;
+  sharpe: number; exposure: number;
   pos: Array<{ id: string; side: string; sz: number; entry: number; rpnl: number; upnl: number }>;
   hist: number[];
 } | null {
@@ -702,6 +759,7 @@ except Exception as e:
     description: "Run the current strategy code locally as a background Python process. Returns PID. Use read_logs(pid) to monitor. Must use mode='paper'. Process shows in the status bar as 'N running'.",
     parameters: z.object({
       timeout_secs: z.number().optional().describe("Max runtime seconds (default 3600 = 1 hour)"),
+      auto_restart: z.boolean().optional().describe("Auto-restart on crash (max 3 retries with exponential backoff). Default false."),
     }),
     execute: async (args: any) => {
       const draft = store.getActiveSession()?.strategyDraft;
@@ -716,10 +774,13 @@ except Exception as e:
       }
 
       const timeout = args.timeout_secs ?? 3600;
-      try {
+      const autoRestart = args.auto_restart ?? false;
+      const maxRetries = 3;
+      const backoffMs = [1000, 2000, 4000];
+
+      const launchProcess = (): { pid: number; managed: ManagedProcess } => {
         const instrumentedCode = injectMetricsReporter(draft.code);
         const { proc, cleanup } = spawnInSandbox(instrumentedCode);
-
         const pid = proc.pid;
         const managed: ManagedProcess = { proc, stdout: [], stderr: [], startedAt: Date.now(), cleanup };
         runningProcesses.set(pid, managed);
@@ -731,19 +792,52 @@ except Exception as e:
           if (m) { m.cleanup?.(); runningProcesses.delete(pid); }
         }, timeout * 1000);
 
+        return { pid, managed };
+      };
+
+      try {
+        let { pid, managed } = launchProcess();
+
         // Wait a beat to check for immediate crash
         await new Promise((r) => setTimeout(r, 500));
-        const exitCode = proc.exitCode;
+        const exitCode = managed.proc.exitCode;
         if (exitCode !== null && exitCode !== 0) {
           const err = managed.stderr.join("\n");
           runningProcesses.delete(pid);
           return { error: `Process crashed immediately (exit ${exitCode})`, stderr: err.slice(0, 1000) };
         }
 
+        // Set up auto-restart watcher if enabled
+        if (autoRestart) {
+          let retries = 0;
+          const watchForCrash = () => {
+            managed.proc.exited.then(async () => {
+              const code = managed.proc.exitCode;
+              if (code !== null && code !== 0 && retries < maxRetries) {
+                retries++;
+                const delay = backoffMs[retries - 1] ?? 4000;
+                managed.stderr.push(`[RESTART] Process exited with code ${code}. Retrying (${retries}/${maxRetries}) in ${delay}ms...`);
+                await new Promise((r) => setTimeout(r, delay));
+                try {
+                  const next = launchProcess();
+                  pid = next.pid;
+                  managed = next.managed;
+                  managed.stdout.push(`[RESTART] Attempt ${retries}/${maxRetries} started (PID ${pid})`);
+                  watchForCrash();
+                } catch (e: any) {
+                  managed.stderr.push(`[RESTART] Failed to restart: ${e.message}`);
+                }
+              }
+            });
+          };
+          watchForCrash();
+        }
+
         return {
           success: true, pid, status: "running", timeout_secs: timeout,
+          auto_restart: autoRestart,
           initial_output: managed.stdout.slice(0, 5).join("\n"),
-          message: `Strategy running (PID ${pid}). Use read_logs(${pid}) to see output. Auto-stops after ${Math.round(timeout / 60)}min.`,
+          message: `Strategy running (PID ${pid}). Use read_logs(${pid}) to see output. Auto-stops after ${Math.round(timeout / 60)}min.${autoRestart ? " Auto-restart enabled (max 3 retries)." : ""}`,
         };
       } catch (err) {
         return { error: `Failed to start: ${err instanceof Error ? err.message : String(err)}` };
@@ -935,28 +1029,46 @@ except Exception as e:
   // ── Dashboard ──
 
   spawn_dashboard: t({
-    description: `Serve a local web dashboard. Two modes:
+    description: `Serve a local web dashboard. Three modes:
 
 1. **Built-in monitor** — pass strategy_id. Auto-connects to live platform metrics.
-2. **Custom HTML** — pass custom_html you write from scratch.
+2. **File-based** (PREFERRED) — pass file_path pointing to an HTML file in the workspace. Reads from disk on every request so edits auto-reload. Error-catching JS is auto-injected.
+3. **Custom HTML** — pass custom_html as inline string (legacy, avoid for large dashboards).
 
-Custom dashboards get a FREE live API:
+All modes get a live API:
 - GET /api/metrics → platform metrics (if strategy_id provided)
 - GET /api/logs → platform deployment logs
-- GET /api/strategy → current strategy draft (code, name, params, risk)
+- GET /api/strategy → current strategy draft
 - GET /api/local-logs → stdout/stderr from local run_strategy processes
+- GET /api/local/metrics → parsed local process metrics
+- GET /api/errors → captured JS errors (file-based mode)
 
-Your HTML can fetch("/api/metrics").then(r => r.json()) to get live data. Auto-refresh with setInterval.`,
+Your HTML can fetch("/api/local/metrics").then(r => r.json()) to get live data. Auto-refresh with setInterval.`,
     parameters: z.object({
       strategy_id: z.string().optional().describe("Strategy UUID — enables /api/metrics and /api/logs from the platform"),
-      custom_html: z.string().optional().describe("Complete HTML page you write from scratch (dark theme, Chart.js, etc.)"),
+      file_path: z.string().optional().describe("Path to HTML file in workspace (e.g. 'dashboards/monitor.html'). PREFERRED over custom_html."),
+      custom_html: z.string().optional().describe("Complete HTML page as inline string (legacy — use file_path instead)"),
       port: z.number().optional().describe("Port (default: random)"),
     }),
     execute: async (args: any) => {
       try {
-        if (args.strategy_id && !args.custom_html) {
-          const url = dashboard.start(args.strategy_id, args.port);
-          return { success: true, url, message: `Monitor at ${hyperlink(url)}` };
+        // Auto-detect: if local processes are running, use local mode
+        const hasLocal = [...runningProcesses.values()].some(m => m.proc.exitCode === null);
+
+        // Mode 1: File-based dashboard (preferred)
+        if (args.file_path) {
+          const url = dashboard.startFromFile(args.file_path, args.strategy_id, args.port);
+          return {
+            success: true, url, isLocal: hasLocal, mode: "file",
+            message: `File-based dashboard at ${hyperlink(url)}. Edit the file and refresh to see changes. Use check_dashboard_errors() to verify.`,
+          };
+        }
+
+        // Mode 2: Built-in monitor
+        if (!args.custom_html) {
+          const sid = args.strategy_id ?? "local";
+          const url = dashboard.start(sid, args.port, hasLocal);
+          return { success: true, url, isLocal: hasLocal, message: `Dashboard at ${hyperlink(url)}` };
         }
 
         // Custom HTML with live API backend
@@ -1018,4 +1130,80 @@ Your HTML can fetch("/api/metrics").then(r => r.json()) to get live data. Auto-r
       }
     },
   }),
+
+  // ── Dashboard Error Check ──
+
+  check_dashboard_errors: t({
+    description: "Check for JavaScript errors captured from a file-based dashboard. Call this after spawn_dashboard(file_path=...) to verify the dashboard loaded without errors.",
+    parameters: z.object({}),
+    execute: async () => {
+      if (!dashboard.running) {
+        return { error: "No dashboard is running. Call spawn_dashboard first." };
+      }
+      const errors = dashboard.capturedErrors;
+      if (errors.length === 0) {
+        return { success: true, errors: [], message: "No JavaScript errors detected." };
+      }
+      return {
+        success: false,
+        error_count: errors.length,
+        errors: errors.slice(-10).map((e: any) => ({
+          type: e.type,
+          message: e.message,
+          source: e.source,
+          line: e.line,
+          col: e.col,
+        })),
+        message: `${errors.length} JS error(s) detected. Fix the HTML and refresh — file-based dashboards auto-reload.`,
+      };
+    },
+  }),
+
+  // ── Workspace File I/O ──
+
+  write_file: t({
+    description: "Write a file to the workspace (~/.horizon/workspace/). Use for dashboards, scripts, data files. Max 1MB. Blocked: .sh, .bash, .zsh files.",
+    parameters: z.object({
+      path: z.string().describe("Relative path within workspace (e.g. 'dashboards/monitor.html', 'data/config.json')"),
+      content: z.string().describe("File content to write"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const result = await writeWorkspaceFile(args.path, args.content);
+        return { success: true, path: result.path, size: result.size, message: `Written ${result.size} bytes to ${result.path}` };
+      } catch (err) {
+        return { error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  read_file: t({
+    description: "Read a file from the workspace (~/.horizon/workspace/). Returns the file content as a string.",
+    parameters: z.object({
+      path: z.string().describe("Relative path within workspace"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const content = await readWorkspaceFile(args.path);
+        return { success: true, path: args.path, content, size: content.length };
+      } catch (err) {
+        return { error: `Read failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  list_files: t({
+    description: "List files in a workspace directory. Returns name, size, and modification date.",
+    parameters: z.object({
+      directory: z.string().optional().describe("Subdirectory to list (e.g. 'dashboards'). Omit for workspace root."),
+    }),
+    execute: async (args: any) => {
+      try {
+        const files = listWorkspaceFiles(args.directory);
+        return { success: true, directory: args.directory ?? "/", files, count: files.length };
+      } catch (err) {
+        return { error: `List failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
 };

package/src/strategy/validator.ts

@@ -9,6 +9,9 @@ export interface ValidationError {
 const ALLOWED_IMPORTS = new Set([
   "horizon", "hz", "datetime", "collections", "math",
   "typing", "enum", "statistics", "pydantic", "abc", "json",
+  // Horizon submodules (legitimate SDK imports)
+  "horizon.context", "horizon.feeds", "horizon.walkforward",
+  "horizon.strategy", "horizon.signals", "horizon.risk",
 ]);
 
 const FORBIDDEN_PATTERNS: { pattern: RegExp; message: string }[] = [
@@ -26,7 +29,7 @@ const FORBIDDEN_PATTERNS: { pattern: RegExp; message: string }[] = [
   { pattern: /\bglobals\s*\(/, message: "globals() is not allowed" },
   { pattern: /\blocals\s*\(/, message: "locals() is not allowed" },
   { pattern: /\bvars\s*\(/, message: "vars() is not allowed" },
-  { pattern: /\bgetattr\s*\(/, message: "getattr() is not allowed — access attributes directly" },
+  // getattr() is allowed — needed for optional ctx attributes from SDK pipeline injectors
   { pattern: /\bsetattr\s*\(/, message: "setattr() is not allowed" },
   { pattern: /\bdelattr\s*\(/, message: "delattr() is not allowed" },
   { pattern: /\b__builtins__\b/, message: "__builtins__ access is not allowed" },
@@ -310,5 +313,26 @@ export function getStrategyWarnings(code: string): ValidationWarning[] {
     warnings.push({ line: null, message: "No is_stale() check — strategy may act on stale/disconnected feeds", severity: "info" });
   }
 
+  // 8. Last pipeline function should return quotes
+  if (pipelineFns.length > 0) {
+    const lastFn = pipelineFns[pipelineFns.length - 1]!;
+    // Check if the function's body returns hz.quotes or []
+    const fnDef = code.match(new RegExp(`def\\s+${lastFn}\\s*\\([^)]*\\)[^:]*:[\\s\\S]*?(?=\\ndef\\s|\\nhz\\.|$)`));
+    if (fnDef && !fnDef[0].includes("hz.quotes") && !fnDef[0].includes("return []") && !fnDef[0].includes("Quote")) {
+      warnings.push({ line: null, message: `Last pipeline function "${lastFn}" may not return list[Quote] — check return type`, severity: "warning" });
+    }
+  }
+
+  // 9. time.sleep usage
+  if (code.includes("time.sleep")) {
+    const lineNum = lines.findIndex(l => l.includes("time.sleep"));
+    warnings.push({ line: lineNum >= 0 ? lineNum + 1 : null, message: "time.sleep() in pipeline — use hz.run(interval=X) instead", severity: "warning" });
+  }
+
+  // 10. Decimal usage
+  if (code.includes("Decimal(") || code.includes("from decimal")) {
+    warnings.push({ line: null, message: "Decimal detected — SDK uses plain float, Decimal causes type errors", severity: "warning" });
+  }
+
   return warnings;
 }