horizon-code 0.1.1 → 0.2.0

package/src/strategy/tools.ts

@@ -3,8 +3,8 @@
 
 import { tool } from "ai";
 import { z } from "zod";
-import { validateStrategyCode, autoFixStrategyCode } from "./validator.ts";
-import { gammaEvents } from "../research/apis.ts";
+import { validateStrategyCode, autoFixStrategyCode, getStrategyWarnings } from "./validator.ts";
+import { gammaEvents, clobPriceHistory } from "../research/apis.ts";
 import { platform } from "../platform/client.ts";
 import { store } from "../state/store.ts";
 import { dashboard } from "./dashboard.ts";
@@ -16,10 +16,11 @@ import type { StrategyDraft } from "../state/types.ts";
 const t = tool as any;
 
 const docsCache = new Map<string, string>();
+let _lastFetchedData: { slug: string; path: string; points: number } | null = null;
 
 // ── Process management ──
 
-interface ManagedProcess {
+export interface ManagedProcess {
   proc: ReturnType<typeof Bun.spawn>;
   stdout: string[];
   stderr: string[];
@@ -120,6 +121,124 @@ function commandEnv(): Record<string, string> {
   return env;
 }
 
+// ── Metrics reporter injection for local execution ──
+// Emits structured JSON to stderr every 5 seconds with a __HZ_METRICS__ prefix.
+// Returns quotes unchanged so it doesn't affect the strategy pipeline.
+
+const METRICS_REPORTER = `
+import json as _json, sys as _sys, time as _time
+_hz_last_report = [0.0]
+_hz_pnl_history = []
+def _hz_report(ctx, quotes):
+    _now = _time.time()
+    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)
+    return quotes if quotes is not None else []
+`;
+
+/** Inject the metrics reporter into strategy code for local execution */
+function injectMetricsReporter(code: string): string {
+  // Find pipeline=[...] and append _hz_report
+  const pipelineMatch = code.match(/pipeline\s*=\s*\[([^\]]*)\]/);
+  if (!pipelineMatch) return METRICS_REPORTER + "\n" + code; // Can't find pipeline, just prepend
+
+  const pipelineContent = pipelineMatch[1]!.trim();
+  // Remove trailing comma if present
+  const cleaned = pipelineContent.replace(/,\s*$/, "");
+  const newPipeline = `pipeline=[${cleaned}, _hz_report]`;
+
+  // Replace the pipeline in the code
+  let modified = code.replace(pipelineMatch[0], newPipeline);
+
+  // Prepend the reporter function after existing imports
+  const lines = modified.split("\n");
+  let lastImportIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!.trim();
+    if (line.startsWith("import ") || line.startsWith("from ")) {
+      lastImportIdx = i;
+    }
+    // Stop at first non-import, non-empty, non-comment line after we've seen imports
+    if (line && !line.startsWith("import ") && !line.startsWith("from ") && !line.startsWith("#") && lastImportIdx >= 0) {
+      break;
+    }
+  }
+
+  // Insert reporter after imports
+  const insertIdx = lastImportIdx >= 0 ? lastImportIdx + 1 : 0;
+  lines.splice(insertIdx, 0, METRICS_REPORTER);
+
+  return lines.join("\n");
+}
+
+/** Parse the latest metrics from a process's stderr buffer */
+export function parseLocalMetrics(managed: ManagedProcess): {
+  pnl: number; rpnl: number; upnl: number;
+  orders: number; positions: number; uptime: number; kill: boolean;
+  pos: Array<{ id: string; side: string; sz: number; entry: number; rpnl: number; upnl: number }>;
+  hist: number[];
+} | null {
+  // Scan stderr from the end for the latest __HZ_METRICS__ line
+  for (let i = managed.stderr.length - 1; i >= 0; i--) {
+    const line = managed.stderr[i]!;
+    if (line.startsWith("__HZ_METRICS__")) {
+      try {
+        return JSON.parse(line.slice(14));
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+// ── HTML → text extraction ──
+
+/** Extract readable text from HTML, stripping tags but keeping structure */
+function extractTextFromHtml(html: string, maxLen: number): string {
+  // Remove script/style blocks
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<nav[\s\S]*?<\/nav>/gi, "");
+  text = text.replace(/<header[\s\S]*?<\/header>/gi, "");
+  text = text.replace(/<footer[\s\S]*?<\/footer>/gi, "");
+
+  // Convert meaningful tags to text markers
+  text = text.replace(/<h[1-6][^>]*>/gi, "\n## ");
+  text = text.replace(/<\/h[1-6]>/gi, "\n");
+  text = text.replace(/<li[^>]*>/gi, "\n- ");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<p[^>]*>/gi, "\n");
+  text = text.replace(/<\/p>/gi, "\n");
+  text = text.replace(/<pre[^>]*>/gi, "\n```\n");
+  text = text.replace(/<\/pre>/gi, "\n```\n");
+  text = text.replace(/<code[^>]*>/gi, "`");
+  text = text.replace(/<\/code>/gi, "`");
+
+  // Strip all remaining HTML tags
+  text = text.replace(/<[^>]+>/g, "");
+
+  // Decode common HTML entities
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+
+  // Clean up whitespace
+  text = text.replace(/\n{3,}/g, "\n\n").trim();
+
+  return text.slice(0, maxLen);
+}
+
 // ── Tools ──
 // Code generation uses text streaming (```python fences) detected by app.ts.
 // These tools handle editing, validation, execution, and deployment.
@@ -144,11 +263,13 @@ export const strategyTools: Record<string, any> = {
       const newCode = draft.code.replace(args.find, args.replace);
       const fixedCode = autoFixStrategyCode(newCode);
       const errors = validateStrategyCode(fixedCode);
+      const warnings = getStrategyWarnings(fixedCode);
 
       store.updateStrategyDraft({
         code: fixedCode,
         validationStatus: errors.length === 0 ? "valid" : "invalid",
         validationErrors: errors,
+        validationWarnings: warnings,
         phase: "iterated",
       });
 
@@ -175,32 +296,98 @@ export const strategyTools: Record<string, any> = {
       if (!code) return { valid: false, errors: [{ line: null, message: "No strategy code to validate" }] };
 
       const errors = validateStrategyCode(code);
+      const warnings = getStrategyWarnings(code);
 
       if (!args.code && store.getActiveSession()?.strategyDraft) {
         store.updateStrategyDraft({
           validationStatus: errors.length === 0 ? "valid" : "invalid",
           validationErrors: errors,
+          validationWarnings: warnings,
         });
       }
-      return { valid: errors.length === 0, errors };
+      return { valid: errors.length === 0, errors, warnings };
     },
   }),
 
   lookup_sdk_docs: t({
-    description: "Look up advanced Horizon SDK docs (arbitrage, copy-trading, wallet-intelligence, stealth, sentinel, oracle). Do NOT call for basic SDK usage — types, feeds, pipeline, risk, backtesting are in the system prompt.",
+    description: "Look up Horizon SDK documentation for a specific topic. Returns focused, relevant docs. Available topics: types, feeds, context, pipeline, exchanges, risk, backtesting, plotting, ascii-plotting, signals, arbitrage, kelly, volatility, execution-algos, portfolio, sentinel, oracle, copy-trading, wallet-intelligence, stealth, whale-galaxy, market-discovery, swarm, fund-manager",
     parameters: z.object({
-      topic: z.string().describe("SDK topic: types, feeds, context, pipeline, hz.run, risk, backtesting, plotting, ascii-plotting, exchanges, arbitrage, signals, etc."),
+      topic: z.string().describe("SDK topic to look up"),
     }),
     execute: async (args: any) => {
-      const topic = args.topic.toLowerCase().replace(/\s+/g, "-");
+      const topic = args.topic.toLowerCase().replace(/\s+/g, "-").replace(/_/g, "-");
+
+      // Check memory cache first (30 min TTL)
       const cached = docsCache.get(topic);
-      if (cached) return { topic: args.topic, content: cached };
+      if (cached) return { topic: args.topic, content: cached, cached: true };
+
+      // Topic → URL mapping (specific pages for focused results)
+      const TOPIC_URLS: Record<string, string> = {
+        "types": "/core/types",
+        "feeds": "/core/feeds",
+        "context": "/core/context",
+        "pipeline": "/core/pipeline",
+        "exchanges": "/core/exchanges",
+        "risk": "/core/risk",
+        "backtesting": "/core/backtesting",
+        "backtest": "/core/backtesting",
+        "plotting": "/core/plotting",
+        "ascii-plotting": "/core/ascii-plotting",
+        "ascii": "/core/ascii-plotting",
+        "signals": "/core/signals",
+        "market-making": "/core/market-making",
+        "mm": "/core/market-making",
+        "arbitrage": "/advanced/arbitrage",
+        "arb": "/advanced/arbitrage",
+        "kelly": "/core/kelly",
+        "volatility": "/core/volatility",
+        "vol": "/core/volatility",
+        "execution-algos": "/advanced/execution-algos",
+        "execution": "/advanced/execution-algos",
+        "twap": "/advanced/execution-algos",
+        "vwap": "/advanced/execution-algos",
+        "iceberg": "/advanced/execution-algos",
+        "portfolio": "/advanced/portfolio",
+        "sentinel": "/advanced/sentinel",
+        "oracle": "/advanced/oracle",
+        "copy-trading": "/advanced/copy-trading",
+        "wallet-intelligence": "/advanced/wallet-intelligence",
+        "stealth": "/advanced/stealth",
+        "whale-galaxy": "/advanced/whale-galaxy",
+        "market-discovery": "/core/market-discovery",
+        "discovery": "/core/market-discovery",
+        "swarm": "/examples/quant-swarm",
+        "fund-manager": "/examples/quant-swarm",
+        "fund": "/examples/quant-swarm",
+      };
 
-      // Fetch the full markdown docs index (llms-full.txt) and extract the relevant section
+      const baseDomain = "https://mathematicalcompany.mintlify.app";
+
+      // Try topic-specific URL first
+      const urlPath = TOPIC_URLS[topic];
+      if (urlPath) {
+        try {
+          const res = await fetch(`${baseDomain}${urlPath}`, {
+            signal: AbortSignal.timeout(8000),
+            headers: { "Accept": "text/html" },
+          });
+          if (res.ok) {
+            const html = await res.text();
+            // Extract main content — strip HTML tags, keep text
+            const content = extractTextFromHtml(html, 6000);
+            if (content.length > 100) {
+              docsCache.set(topic, content);
+              return { topic: args.topic, content };
+            }
+          }
+        } catch {}
+      }
+
+      // Fallback: fetch llms-full.txt and extract section (existing approach)
       try {
         if (!docsCache.has("__full__")) {
-          const res = await fetch("https://mathematicalcompany.mintlify.app/llms-full.txt", {
-            signal: AbortSignal.timeout(8000),
+          const res = await fetch(`${baseDomain}/llms-full.txt`, {
+            signal: AbortSignal.timeout(10000),
           });
           if (res.ok) {
             docsCache.set("__full__", await res.text());
@@ -209,53 +396,55 @@ export const strategyTools: Record<string, any> = {
 
         const fullDocs = docsCache.get("__full__");
         if (fullDocs) {
-          // Find the section matching the topic — look for markdown headers
           const topicVariants = [topic, topic.replace(/-/g, " "), args.topic];
-          let bestMatch = "";
           for (const variant of topicVariants) {
-            // Find a heading containing the topic
             const headingPattern = new RegExp(`^#+\\s+.*${variant.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*$`, "im");
             const headingMatch = fullDocs.match(headingPattern);
             if (headingMatch?.index !== undefined) {
-              // Extract from this heading to the next same-level heading (or 4000 chars)
               const level = headingMatch[0].match(/^#+/)![0].length;
               const rest = fullDocs.slice(headingMatch.index);
               const nextHeading = rest.slice(1).search(new RegExp(`^#{1,${level}}\\s`, "m"));
               const section = nextHeading !== -1 ? rest.slice(0, nextHeading + 1) : rest;
-              bestMatch = section.slice(0, 4000);
-              break;
-            }
-          }
-
-          if (bestMatch) {
-            docsCache.set(topic, bestMatch);
-            return { topic: args.topic, content: bestMatch };
-          }
-
-          // Fallback: keyword search in the full doc
-          const lines = fullDocs.split("\n");
-          const relevant: string[] = [];
-          const keywords = topic.split("-").filter((w: string) => w.length > 2);
-          for (let i = 0; i < lines.length && relevant.length < 80; i++) {
-            const line = lines[i]!.toLowerCase();
-            if (keywords.some((kw: string) => line.includes(kw))) {
-              // Include surrounding context
-              const start = Math.max(0, i - 2);
-              const end = Math.min(lines.length, i + 5);
-              for (let j = start; j < end; j++) {
-                if (!relevant.includes(lines[j]!)) relevant.push(lines[j]!);
-              }
+              const content = section.slice(0, 6000);
+              docsCache.set(topic, content);
+              return { topic: args.topic, content };
             }
           }
-          if (relevant.length > 0) {
-            const content = relevant.join("\n").slice(0, 4000);
-            docsCache.set(topic, content);
-            return { topic: args.topic, content };
-          }
         }
       } catch {}
 
-      return { topic: args.topic, content: `SDK docs for "${args.topic}" not found. Use the embedded reference in your system prompt.` };
+      return { topic: args.topic, content: `No docs found for "${args.topic}". Available topics: types, feeds, context, pipeline, exchanges, risk, backtesting, plotting, ascii-plotting, signals, arbitrage, kelly, volatility, execution-algos, portfolio, sentinel, oracle, copy-trading, wallet-intelligence, stealth, whale-galaxy, market-discovery, swarm` };
+    },
+  }),
+
+  list_sdk_topics: t({
+    description: "List all available Horizon SDK documentation topics. Call this if unsure what docs are available.",
+    parameters: z.object({}),
+    execute: async () => {
+      return {
+        topics: [
+          { name: "types", description: "Core types: Quote, Market, Position, Order, Context, EngineStatus, Risk" },
+          { name: "feeds", description: "11 feed types: PolymarketBook, KalshiBook, BinanceWS, RESTFeed, etc." },
+          { name: "pipeline", description: "Pipeline composition, function chaining, signature introspection" },
+          { name: "exchanges", description: "8 supported exchanges: Polymarket, Kalshi, Alpaca, etc." },
+          { name: "risk", description: "8-check risk pipeline, RiskConfig, kill switch, rate limits" },
+          { name: "backtesting", description: "hz.backtest(), fill models, walk-forward optimization" },
+          { name: "signals", description: "Signal system, combiners, alpha extractors" },
+          { name: "market-making", description: "Avellaneda-Stoikov, reservation pricing, optimal spreads" },
+          { name: "kelly", description: "Kelly criterion, fractional Kelly, liquidity-adjusted sizing" },
+          { name: "volatility", description: "6 estimators: Yang-Zhang, Parkinson, EWMA, etc." },
+          { name: "arbitrage", description: "Parity arb, event arb, stat arb, composite scanner" },
+          { name: "execution-algos", description: "TWAP, VWAP, Iceberg execution algorithms" },
+          { name: "portfolio", description: "Portfolio optimization, risk parity, Monte Carlo VaR" },
+          { name: "sentinel", description: "Continuous risk monitoring, drawdown response, hedging" },
+          { name: "oracle", description: "AI-driven market forecasting, edge scanning" },
+          { name: "market-discovery", description: "discover_markets(), top_markets(), discover_events()" },
+          { name: "swarm", description: "FundManager, autonomous fund operations, agent swarm" },
+          { name: "ascii-plotting", description: "Terminal-native charts: line, bar, heatmap, scatter" },
+          { name: "plotting", description: "Chart data extraction from backtest results" },
+        ],
+        hint: "Call lookup_sdk_docs(topic) with any of these topic names for full documentation.",
+      };
     },
   }),
 
@@ -281,6 +470,55 @@ export const strategyTools: Record<string, any> = {
     },
   }),
 
+  fetch_market_data: t({
+    description: "Fetch real Polymarket price history for backtesting. Returns timestamped price data ready for hz.backtest(data=...). Use this before backtest_strategy to test with real market data instead of synthetic.",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+      interval: z.enum(["1d", "1w", "1m", "max"]).optional().describe("Time range (default 1m)"),
+      fidelity: z.number().optional().describe("Resolution in minutes: 1, 5, 15, 60 (default 5)"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const data = await clobPriceHistory(args.slug, args.interval ?? "1m", args.fidelity ?? 5);
+        const points = data.priceHistory ?? [];
+
+        if (points.length < 10) {
+          return { error: `Only ${points.length} data points found. Try a longer interval or different market.` };
+        }
+
+        // Format for hz.backtest(data=...)
+        const backtestData = points.map((p: any) => ({
+          timestamp: typeof p.t === "number" ? p.t : new Date(p.t).getTime() / 1000,
+          price: typeof p.p === "number" ? p.p : parseFloat(p.p),
+        }));
+
+        // Store in a temp location so backtest_strategy can use it
+        const { mkdtemp } = await import("fs/promises");
+        const { join } = await import("path");
+        const { tmpdir } = await import("os");
+        const dir = await mkdtemp(join(tmpdir(), "horizon-data-"));
+        const dataPath = join(dir, "market_data.json");
+        await Bun.write(dataPath, JSON.stringify(backtestData));
+
+        // Store reference for backtest_strategy to pick up
+        _lastFetchedData = { slug: args.slug, path: dataPath, points: backtestData.length };
+
+        return {
+          slug: args.slug,
+          title: data.title,
+          data_points: backtestData.length,
+          time_range: args.interval ?? "1m",
+          price_range: { low: data.low, high: data.high, current: data.current },
+          change: data.change,
+          data_path: dataPath,
+          hint: "Now call backtest_strategy(use_real_data=true) to backtest with this data.",
+        };
+      } catch (err) {
+        return { error: `Failed to fetch data: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
   // ── Backtest (real hz.backtest()) ──
 
   backtest_strategy: t({
@@ -290,6 +528,7 @@ export const strategyTools: Record<string, any> = {
       initial_capital: z.number().optional().describe("Starting capital USD (default 1000)"),
       base_price: z.number().optional().describe("Base price (default 0.50)"),
       fill_model: z.enum(["deterministic", "probabilistic", "glft"]).optional().describe("Fill model (default deterministic)"),
+      use_real_data: z.boolean().optional().describe("Use real market data from fetch_market_data (default false — uses synthetic)"),
     }),
     execute: async (args: any) => {
       const draft = store.getActiveSession()?.strategyDraft;
@@ -325,6 +564,28 @@ export const strategyTools: Record<string, any> = {
         pipeline_fns: pipelineFns,
       };
 
+      // Determine data source
+      let dataLoadCode: string;
+      if (args.use_real_data && _lastFetchedData) {
+        // Use real market data
+        dataLoadCode = `
+with open("${_lastFetchedData.path.replace(/\\/g, "/")}") as f:
+    data = json.load(f)
+print(f"Using real data: {len(data)} points from ${_lastFetchedData.slug}", file=sys.stderr)
+`;
+      } else {
+        // Synthetic random-walk data
+        dataLoadCode = `
+data = []
+price = _cfg["base_price"]
+for i in range(_cfg["data_points"]):
+    noise = (((i * 7 + 13) % 100) / 100 - 0.5) * 0.05
+    revert = (_cfg["base_price"] - price) * 0.05
+    price = max(0.01, min(0.99, price + noise + revert))
+    data.append({"timestamp": float(i), "price": round(price, 4)})
+`;
+      }
+
       const script = `
 import horizon as hz
 from horizon.context import FeedData
@@ -335,14 +596,7 @@ ${pipelineCode}
 # Load config from JSON file (no string interpolation)
 with open("backtest_config.json") as f:
     _cfg = json.load(f)
-
-data = []
-price = _cfg["base_price"]
-for i in range(_cfg["data_points"]):
-    noise = (((i * 7 + 13) % 100) / 100 - 0.5) * 0.05
-    revert = (_cfg["base_price"] - price) * 0.05
-    price = max(0.01, min(0.99, price + noise + revert))
-    data.append({"timestamp": float(i), "price": round(price, 4)})
+${dataLoadCode}
 
 try:
     result = hz.backtest(
@@ -435,7 +689,7 @@ except Exception as e:
         }
 
         const result = JSON.parse(jsonMatch[1]!.trim());
-        return { ...result, ascii_dashboard: dashMatch ? dashMatch[1]!.trim() : null, duration: `${dataPoints} ticks` };
+        return { ...result, ascii_dashboard: dashMatch ? dashMatch[1]!.trim() : null, data_source: args.use_real_data && _lastFetchedData ? `real (${_lastFetchedData.slug}, ${_lastFetchedData.points} points)` : `synthetic (${dataPoints} ticks)` };
       } catch (err) {
         return { error: `Backtest execution failed: ${err instanceof Error ? err.message : String(err)}`, hint: "Ensure Horizon SDK is installed: pip install horizon" };
       }
@@ -463,7 +717,8 @@ except Exception as e:
 
       const timeout = args.timeout_secs ?? 3600;
       try {
-        const { proc, cleanup } = spawnInSandbox(draft.code);
+        const instrumentedCode = injectMetricsReporter(draft.code);
+        const { proc, cleanup } = spawnInSandbox(instrumentedCode);
 
         const pid = proc.pid;
         const managed: ManagedProcess = { proc, stdout: [], stderr: [], startedAt: Date.now(), cleanup };
@@ -637,6 +892,7 @@ except Exception as e:
 
       const fixedCode = autoFixStrategyCode(result.code);
       const errors = validateStrategyCode(fixedCode);
+      const warnings = getStrategyWarnings(fixedCode);
 
       const draft: StrategyDraft = {
         name: args.name,
@@ -646,6 +902,7 @@ except Exception as e:
         riskConfig: null,
         validationStatus: errors.length === 0 ? "valid" : "invalid",
         validationErrors: errors,
+        validationWarnings: warnings,
         phase: "generated",
       };
       store.setStrategyDraft(draft);

package/src/strategy/validator.ts

@@ -214,3 +214,101 @@ export function validateStrategyCode(code: string): ValidationError[] {
 
   return errors;
 }
+
+// ── Semantic warnings (non-blocking) ──
+
+export interface ValidationWarning {
+  line: number | null;
+  message: string;
+  severity: "warning" | "info";
+}
+
+export function getStrategyWarnings(code: string): ValidationWarning[] {
+  const warnings: ValidationWarning[] = [];
+  const lines = code.split("\n");
+
+  // 1. Risk config completeness
+  const riskMatch = code.match(/hz\.Risk\(([\s\S]*?)\)/);
+  if (!riskMatch) {
+    warnings.push({ line: null, message: "No hz.Risk() found — strategy has no risk limits", severity: "warning" });
+  } else {
+    const riskBody = riskMatch[1] ?? "";
+    if (!riskBody.includes("max_drawdown_pct")) {
+      warnings.push({ line: null, message: "hz.Risk() missing max_drawdown_pct — no kill switch protection", severity: "warning" });
+    }
+    if (!riskBody.includes("max_notional")) {
+      warnings.push({ line: null, message: "hz.Risk() missing max_notional — no portfolio exposure limit", severity: "warning" });
+    }
+    if (!riskBody.includes("max_order_size")) {
+      warnings.push({ line: null, message: "hz.Risk() missing max_order_size — no single order cap", severity: "info" });
+    }
+    // Check for dangerously high values
+    const notionalMatch = riskBody.match(/max_notional\s*=\s*(\d+)/);
+    if (notionalMatch && parseInt(notionalMatch[1]!) > 10000) {
+      warnings.push({ line: null, message: `max_notional=$${notionalMatch[1]} is very high — ensure this is intentional`, severity: "warning" });
+    }
+    const ddMatch = riskBody.match(/max_drawdown_pct\s*=\s*(\d+)/);
+    if (ddMatch && parseInt(ddMatch[1]!) > 15) {
+      warnings.push({ line: null, message: `max_drawdown_pct=${ddMatch[1]}% is aggressive — typical range is 3-10%`, severity: "warning" });
+    }
+  }
+
+  // 2. Mode check
+  const modeMatch = code.match(/mode\s*=\s*["'](\w+)["']/);
+  if (modeMatch && modeMatch[1] === "live") {
+    const lineNum = lines.findIndex(l => /mode\s*=\s*["']live["']/.test(l));
+    warnings.push({ line: lineNum >= 0 ? lineNum + 1 : null, message: "mode=\"live\" — this will trade with REAL money. Use mode=\"paper\" for testing.", severity: "warning" });
+  }
+  if (!modeMatch) {
+    warnings.push({ line: null, message: "No mode= specified — default behavior may vary", severity: "info" });
+  }
+
+  // 3. Market slug validation
+  const marketsMatch = code.match(/markets\s*=\s*\[([^\]]*)\]/);
+  if (marketsMatch) {
+    const slugs = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+    for (const slug of slugs) {
+      if (slug === "market-slug" || slug === "your-market-slug" || slug === "test-market") {
+        const lineNum = lines.findIndex(l => l.includes(slug));
+        warnings.push({ line: lineNum >= 0 ? lineNum + 1 : null, message: `"${slug}" is a placeholder — replace with a real Polymarket slug`, severity: "warning" });
+      }
+      // Suspicious slugs (too short, no hyphens)
+      if (slug.length < 5 && !slug.includes("-")) {
+        const lineNum = lines.findIndex(l => l.includes(slug));
+        warnings.push({ line: lineNum >= 0 ? lineNum + 1 : null, message: `"${slug}" doesn't look like a valid market slug`, severity: "info" });
+      }
+    }
+  }
+
+  // 4. Feed-pipeline alignment
+  const feedsMatch = code.match(/feeds\s*=\s*\{([^}]*)\}/);
+  if (feedsMatch) {
+    const feedNames = [...feedsMatch[1]!.matchAll(/["'](\w+)["']/g)].map(m => m[1]!);
+    for (const name of feedNames) {
+      // Check if any pipeline function references this feed
+      const feedUsed = code.includes(`ctx.feeds.get("${name}")`) || code.includes(`ctx.feeds.get('${name}')`);
+      if (!feedUsed) {
+        warnings.push({ line: null, message: `Feed "${name}" is declared but never accessed in pipeline functions`, severity: "info" });
+      }
+    }
+  }
+
+  // 5. No pipeline found
+  if (!code.match(/pipeline\s*=\s*\[/)) {
+    warnings.push({ line: null, message: "No pipeline=[...] found — strategy won't execute any logic", severity: "warning" });
+  }
+
+  // 6. Empty pipeline
+  const pipelineMatch = code.match(/pipeline\s*=\s*\[([\s\S]*?)\]/);
+  if (pipelineMatch && pipelineMatch[1]!.trim() === "") {
+    warnings.push({ line: null, message: "Pipeline is empty — add at least a fair_value and quoter function", severity: "warning" });
+  }
+
+  // 7. Stale feed guard check
+  const pipelineFns = pipelineMatch ? pipelineMatch[1]!.split(",").map(s => s.trim()).filter(s => s && !s.startsWith("#")) : [];
+  if (pipelineFns.length > 0 && !code.includes("is_stale")) {
+    warnings.push({ line: null, message: "No is_stale() check — strategy may act on stale/disconnected feeds", severity: "info" });
+  }
+
+  return warnings;
+}