horizon-code 0.1.0

package/src/strategy/validator.ts

@@ -0,0 +1,216 @@
+// Strategy code validator — ported from deploy/platform validate-strategy.ts
+// Pure regex/string checks, no external dependencies
+
+export interface ValidationError {
+  line: number | null;
+  message: string;
+}
+
+const ALLOWED_IMPORTS = new Set([
+  "horizon", "hz", "datetime", "collections", "math",
+  "typing", "enum", "statistics", "pydantic", "abc", "json",
+]);
+
+const FORBIDDEN_PATTERNS: { pattern: RegExp; message: string }[] = [
+  { pattern: /\bos\.system\b/, message: "os.system() is not allowed" },
+  { pattern: /\bos\.popen\b/, message: "os.popen() is not allowed" },
+  { pattern: /\bos\.exec\w*\b/, message: "os.exec*() is not allowed" },
+  { pattern: /\bos\.spawn\w*\b/, message: "os.spawn*() is not allowed" },
+  { pattern: /\bos\.environ\b/, message: "os.environ access is not allowed" },
+  { pattern: /\bsubprocess\b/, message: "subprocess module is not allowed" },
+  { pattern: /\b__import__\b/, message: "__import__ is not allowed" },
+  { pattern: /\beval\s*\(/, message: "eval() is not allowed" },
+  { pattern: /\bexec\s*\(/, message: "exec() is not allowed" },
+  { pattern: /\bcompile\s*\(/, message: "compile() is not allowed" },
+  { pattern: /\bopen\s*\(/, message: "open() is not allowed — use SDK data providers" },
+  { 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" },
+  { 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" },
+  { pattern: /\b__subclasses__\b/, message: "__subclasses__() is not allowed" },
+  { pattern: /\b__class__\.__bases__/, message: "__class__.__bases__ is not allowed" },
+  { pattern: /\bbreakpoint\s*\(/, message: "breakpoint() is not allowed" },
+  { pattern: /\bpickle\b/, message: "pickle module is not allowed" },
+  { pattern: /\bshelve\b/, message: "shelve module is not allowed" },
+  { pattern: /\bsocket\b/, message: "socket module is not allowed" },
+  { pattern: /\bhttp\b/, message: "http module is not allowed — use SDK data providers" },
+  { pattern: /\burllib\b/, message: "urllib module is not allowed — use SDK data providers" },
+  { pattern: /\brequests\b/, message: "requests module is not allowed — use SDK data providers" },
+  { pattern: /\baiohttp\b/, message: "aiohttp module is not allowed — use SDK data providers" },
+  { pattern: /\bhttpx\b/, message: "httpx module is not allowed — use SDK data providers" },
+  { pattern: /\bctypes\b/, message: "ctypes module is not allowed" },
+  { pattern: /\bsys\./, message: "sys module access is not allowed" },
+  { pattern: /\bshutil\b/, message: "shutil module is not allowed" },
+  { pattern: /\btempfile\b/, message: "tempfile module is not allowed" },
+  { pattern: /\bthreading\b/, message: "threading module is not allowed" },
+  { pattern: /\bmultiprocessing\b/, message: "multiprocessing module is not allowed" },
+  { pattern: /\bimportlib\b/, message: "importlib module is not allowed" },
+  { pattern: /\b__loader__\b/, message: "__loader__ access is not allowed" },
+  { pattern: /\b__spec__\b/, message: "__spec__ access is not allowed" },
+  { pattern: /\b__traceback__\b/, message: "__traceback__ access is not allowed — potential sandbox escape" },
+  { pattern: /\btb_frame\b/, message: "tb_frame access is not allowed — potential sandbox escape" },
+  { pattern: /\bf_globals\b/, message: "f_globals access is not allowed — potential sandbox escape" },
+  { pattern: /\bf_locals\b/, message: "f_locals access is not allowed — potential sandbox escape" },
+  { pattern: /\bf_builtins\b/, message: "f_builtins access is not allowed — potential sandbox escape" },
+  { pattern: /\bf_code\b/, message: "f_code access is not allowed — potential sandbox escape" },
+  { pattern: /\bf_back\b/, message: "f_back access is not allowed — potential sandbox escape" },
+  { pattern: /\bgi_frame\b/, message: "gi_frame access is not allowed — potential sandbox escape" },
+  { pattern: /\bgi_code\b/, message: "gi_code access is not allowed — potential sandbox escape" },
+  { pattern: /\bcr_frame\b/, message: "cr_frame access is not allowed — potential sandbox escape" },
+  { pattern: /\bcr_code\b/, message: "cr_code access is not allowed — potential sandbox escape" },
+  { pattern: /\bco_consts\b/, message: "co_consts access is not allowed — code object manipulation" },
+  { pattern: /\bco_code\b/, message: "co_code access is not allowed — code object manipulation" },
+  { pattern: /\bco_names\b/, message: "co_names access is not allowed — code object manipulation" },
+  { pattern: /\b__class__\b/, message: "__class__ access is not allowed" },
+  { pattern: /\b__globals__\b/, message: "__globals__ access is not allowed" },
+  { pattern: /\b__dict__\b/, message: "__dict__ access is not allowed" },
+  { pattern: /\b__mro__\b/, message: "__mro__ access is not allowed" },
+  { pattern: /\b__bases__\b/, message: "__bases__ access is not allowed" },
+  { pattern: /\b__init_subclass__\b/, message: "__init_subclass__ is not allowed" },
+  { pattern: /\b__reduce__\b/, message: "__reduce__ is not allowed — prevents pickle exploits" },
+  { pattern: /\b__reduce_ex__\b/, message: "__reduce_ex__ is not allowed" },
+  { pattern: /\b__code__\b/, message: "__code__ access is not allowed" },
+  { pattern: /\b__closure__\b/, message: "__closure__ access is not allowed" },
+];
+
+/**
+ * Auto-fix common AI generation mistakes before validation.
+ */
+export function autoFixStrategyCode(code: string): string {
+  const lines = code.split("\n");
+  const fixed = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) return line;
+
+    // Fix hz.Quote(bid=X, ask=Y, size=Z) → hz.quotes(fair=(X+Y)/2, spread=Y-X, size=Z)
+    line = line.replace(
+      /\bhz\.Quote\s*\(\s*bid\s*=\s*([^,]+),\s*ask\s*=\s*([^,]+),\s*size\s*=\s*([^)]+)\)/g,
+      (_match, bid, ask, size) => {
+        const b = bid.trim();
+        const a = ask.trim();
+        const s = size.trim();
+        const bNum = parseFloat(b);
+        const aNum = parseFloat(a);
+        if (!isNaN(bNum) && !isNaN(aNum)) {
+          const fair = ((bNum + aNum) / 2).toFixed(4).replace(/0+$/, "").replace(/\.$/, ".0");
+          const spread = (aNum - bNum).toFixed(4).replace(/0+$/, "").replace(/\.$/, ".0");
+          return `hz.quotes(fair=${fair}, spread=${spread}, size=${s})`;
+        }
+        return `hz.quotes(fair=(${b} + ${a}) / 2, spread=${a} - ${b}, size=${s})`;
+      },
+    );
+
+    // Catch remaining hz.Quote( calls
+    line = line.replace(/\bhz\.Quote\s*\(/g, "hz.quotes(");
+
+    // Fix import decimal / from decimal import Decimal → comment out
+    if (/^\s*import\s+decimal\s*$/.test(line) || /^\s*from\s+decimal\s+import\s+/.test(line)) {
+      return "# " + trimmed + "  # REMOVED: SDK uses plain float, not Decimal";
+    }
+
+    // Fix Decimal(...) → float(...)
+    line = line.replace(/\bDecimal\s*\(/g, "float(");
+
+    return line;
+  });
+  return fixed.join("\n");
+}
+
+/**
+ * Validate strategy Python code against the SDK sandbox rules.
+ */
+export function validateStrategyCode(code: string): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  if (!code.trim()) {
+    errors.push({ line: null, message: "Code is empty" });
+    return errors;
+  }
+
+  // Block backslash line continuations
+  if (/\\\s*\n/.test(code)) {
+    errors.push({ line: null, message: "Backslash line continuations (\\) are not allowed. Use parentheses for multi-line expressions instead." });
+    return errors;
+  }
+
+  // Require at least one pipeline function (def ...(ctx...))
+  if (!/def\s+\w+\s*\(\s*ctx/.test(code)) {
+    errors.push({ line: null, message: "Missing pipeline function — at least one function accepting `ctx` is required" });
+  }
+
+  // Require SDK usage
+  if (!/\bhz\.(quotes|run)\b|\bhorizon\b/.test(code)) {
+    errors.push({ line: null, message: "Missing SDK usage — code must use hz.quotes(), hz.run(), or import horizon" });
+  }
+
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("#") || !trimmed) continue;
+
+    // Validate imports
+    const importMatch = trimmed.match(/^import\s+([\w.]+)/);
+    if (importMatch) {
+      const mod = importMatch[1]!;
+      if (!ALLOWED_IMPORTS.has(mod)) {
+        errors.push({ line: i + 1, message: `Import "${mod}" is not allowed. Allowed: horizon, hz, datetime, collections, math, typing, enum, statistics, pydantic, abc` });
+      }
+      continue;
+    }
+
+    const fromImportMatch = trimmed.match(/^from\s+([\w.]+)\s+import\b/);
+    if (fromImportMatch) {
+      const mod = fromImportMatch[1]!;
+      if (!ALLOWED_IMPORTS.has(mod)) {
+        errors.push({ line: i + 1, message: `Import from "${mod}" is not allowed. Use only allowed modules (horizon, hz, datetime, collections, etc.)` });
+      }
+      continue;
+    }
+
+    // Check forbidden patterns
+    for (const { pattern, message } of FORBIDDEN_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        errors.push({ line: i + 1, message });
+      }
+    }
+
+    // SDK misuse: inventory is InventorySnapshot, not a dict
+    if (/\.inventory\.(items|keys|values|get)\s*\(/.test(trimmed) || /for\s+.+\s+in\s+.*\.inventory\s*:/.test(trimmed)) {
+      errors.push({ line: i + 1, message: "ctx.inventory is an InventorySnapshot, not a dict. Use .positions for the list, .net for total exposure, or .net_for_market(id) for per-market exposure." });
+    }
+
+    // SDK misuse: Market has no pricing fields
+    if (/\.market\.(mid_price|best_bid|best_ask|spread)\b/.test(trimmed)) {
+      errors.push({ line: i + 1, message: "ctx.market has no pricing fields (mid_price, best_bid, best_ask, spread). Use ctx.feeds.get(\"mid\").price for pricing data." });
+    }
+
+    // SDK misuse: hz.Quote() constructor
+    if (/hz\.Quote\s*\(/.test(trimmed)) {
+      errors.push({ line: i + 1, message: "hz.Quote() is not constructible directly. Use hz.quotes(fair, spread=..., size=...) to generate quotes." });
+    }
+
+    // SDK misuse: Decimal passed to SDK functions
+    if (/hz\.(quotes|Quote|Risk)\s*\(/.test(trimmed) && /Decimal/.test(trimmed)) {
+      errors.push({ line: i + 1, message: "Do not pass Decimal to SDK functions. hz.quotes(), hz.Quote, and hz.Risk expect plain float values." });
+    }
+  }
+
+  // exchange and exchanges mutually exclusive in hz.run()
+  const usesExchange = /\bhz\.run\b[\s\S]*?\bexchange\s*=/.test(code);
+  const usesExchanges = /\bhz\.run\b[\s\S]*?\bexchanges\s*=/.test(code);
+  if (usesExchange && usesExchanges) {
+    errors.push({ line: null, message: "hz.run() cannot use both exchange= and exchanges= — they are mutually exclusive." });
+  }
+
+  // Block Decimal import entirely
+  if (/from decimal import Decimal|import decimal/.test(code)) {
+    errors.push({ line: null, message: "Decimal is not allowed. The Horizon SDK uses plain float everywhere. Remove all Decimal usage." });
+  }
+
+  return errors;
+}

package/src/strategy/widgets.ts

@@ -0,0 +1,270 @@
+// CLI widgets for strategy tool results
+
+import { BoxRenderable, TextRenderable, type CliRenderer } from "@opentui/core";
+import { COLORS } from "../theme/colors.ts";
+import { renderAsciiChart } from "./ascii-chart.ts";
+
+let widgetCounter = 0;
+function uid(): string { return `sw-${Date.now()}-${widgetCounter++}`; }
+
+function addRow(parent: BoxRenderable, renderer: CliRenderer, label: string, value: string, valueColor?: string): void {
+  const row = new BoxRenderable(renderer, { id: uid(), flexDirection: "row" });
+  row.add(new TextRenderable(renderer, { id: uid(), content: label.padEnd(18), fg: COLORS.textMuted }));
+  row.add(new TextRenderable(renderer, { id: uid(), content: value, fg: valueColor ?? COLORS.text }));
+  parent.add(row);
+}
+
+function addSeparator(parent: BoxRenderable, renderer: CliRenderer, width = 40): void {
+  parent.add(new TextRenderable(renderer, { id: uid(), content: "─".repeat(width), fg: COLORS.borderDim }));
+}
+
+// ── Strategy Proposal ──
+
+export function renderStrategyProposal(data: any, renderer: CliRenderer): BoxRenderable {
+  const box = new BoxRenderable(renderer, { id: uid(), flexDirection: "column", marginBottom: 1 });
+
+  // Header
+  box.add(new TextRenderable(renderer, {
+    id: uid(), content: `${data.strategy_name ?? "Strategy"}`, fg: COLORS.accent, attributes: 1,
+  }));
+
+  // Explanation
+  if (data.explanation) {
+    box.add(new TextRenderable(renderer, { id: uid(), content: data.explanation, fg: COLORS.text }));
+  }
+
+  addSeparator(box, renderer);
+
+  // Strategy breakdown
+  const breakdown = data.strategy_breakdown;
+  if (breakdown) {
+    addRow(box, renderer, "Class", breakdown.strategy_class ?? "—");
+    if (breakdown.how_it_makes_money) {
+      addRow(box, renderer, "Profit Mechanism", breakdown.how_it_makes_money);
+    }
+    if (breakdown.entry_rules?.length) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: "  Entry Rules:", fg: COLORS.textMuted }));
+      for (const rule of breakdown.entry_rules.slice(0, 3)) {
+        box.add(new TextRenderable(renderer, { id: uid(), content: `    - ${rule}`, fg: COLORS.text }));
+      }
+    }
+    if (breakdown.exit_rules?.length) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: "  Exit Rules:", fg: COLORS.textMuted }));
+      for (const rule of breakdown.exit_rules.slice(0, 3)) {
+        box.add(new TextRenderable(renderer, { id: uid(), content: `    - ${rule}`, fg: COLORS.text }));
+      }
+    }
+    addSeparator(box, renderer);
+  }
+
+  // Estimated metrics
+  const metrics = data.estimated_metrics;
+  if (metrics) {
+    box.add(new TextRenderable(renderer, { id: uid(), content: "  Estimated Performance", fg: COLORS.textMuted }));
+    if (metrics.expected_monthly_return_range) {
+      const [lo, hi] = metrics.expected_monthly_return_range;
+      const color = lo >= 0 ? COLORS.success : COLORS.warning;
+      addRow(box, renderer, "Monthly Return", `${lo}% to ${hi}%`, color);
+    }
+    if (metrics.expected_win_rate_range) {
+      const [lo, hi] = metrics.expected_win_rate_range;
+      addRow(box, renderer, "Win Rate", `${lo}% – ${hi}%`);
+    }
+    if (metrics.expected_max_drawdown_range) {
+      const [lo, hi] = metrics.expected_max_drawdown_range;
+      addRow(box, renderer, "Max Drawdown", `${lo}% – ${hi}%`, COLORS.error);
+    }
+    if (metrics.estimated_trades_per_day) {
+      addRow(box, renderer, "Trades/Day", `~${metrics.estimated_trades_per_day}`);
+    }
+    if (metrics.risk_level) {
+      const riskColor = metrics.risk_level === "high" ? COLORS.error : metrics.risk_level === "low" ? COLORS.success : COLORS.warning;
+      addRow(box, renderer, "Risk Level", metrics.risk_level.toUpperCase(), riskColor);
+    }
+    addSeparator(box, renderer);
+  }
+
+  // Risk config
+  const risk = data.risk_config;
+  if (risk) {
+    box.add(new TextRenderable(renderer, { id: uid(), content: "  Risk Config", fg: COLORS.textMuted }));
+    if (risk.max_position) addRow(box, renderer, "Max Position", `${risk.max_position}`);
+    if (risk.max_notional) addRow(box, renderer, "Max Notional", `$${risk.max_notional}`);
+    if (risk.max_drawdown_pct) addRow(box, renderer, "Max Drawdown", `${risk.max_drawdown_pct}%`);
+  }
+
+  // Target market
+  if (data.target_market?.query_hint) {
+    addSeparator(box, renderer);
+    addRow(box, renderer, "Target Market", data.target_market.query_hint);
+    if (data.target_market.reasoning) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: `  ${data.target_market.reasoning}`, fg: COLORS.textMuted }));
+    }
+  }
+
+  return box;
+}
+
+// ── Validation Result ──
+
+export function renderValidationResult(data: any, renderer: CliRenderer): BoxRenderable {
+  const box = new BoxRenderable(renderer, { id: uid(), flexDirection: "column", marginBottom: 1 });
+  const errors = data.errors ?? [];
+  const valid = errors.length === 0;
+
+  if (valid) {
+    box.add(new TextRenderable(renderer, {
+      id: uid(), content: "Validation passed -- code is valid", fg: COLORS.success,
+    }));
+  } else {
+    box.add(new TextRenderable(renderer, {
+      id: uid(), content: `${errors.length} validation error${errors.length > 1 ? "s" : ""}`, fg: COLORS.error, attributes: 1,
+    }));
+    for (const err of errors.slice(0, 10)) {
+      const lineStr = err.line ? `L${err.line}: ` : "";
+      box.add(new TextRenderable(renderer, {
+        id: uid(), content: `  ${lineStr}${err.message}`, fg: COLORS.error,
+      }));
+    }
+  }
+
+  return box;
+}
+
+// ── Backtest Result ──
+
+export function renderBacktestResult(data: any, renderer: CliRenderer): BoxRenderable {
+  const box = new BoxRenderable(renderer, { id: uid(), flexDirection: "column", marginBottom: 1 });
+
+  // Error state
+  if (data.error) {
+    box.add(new TextRenderable(renderer, {
+      id: uid(), content: `Backtest Error`, fg: COLORS.error, attributes: 1,
+    }));
+    box.add(new TextRenderable(renderer, {
+      id: uid(), content: data.error, fg: COLORS.error,
+    }));
+    if (data.hint) {
+      box.add(new TextRenderable(renderer, {
+        id: uid(), content: data.hint, fg: COLORS.textMuted,
+      }));
+    }
+    return box;
+  }
+
+  box.add(new TextRenderable(renderer, {
+    id: uid(), content: `Backtest -- ${data.strategy_name ?? "Strategy"}`, fg: COLORS.accent, attributes: 1,
+  }));
+
+  // ASCII dashboard from hz.dashboard() — the real SDK output
+  if (data.ascii_dashboard) {
+    for (const line of data.ascii_dashboard.split("\n")) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: line, fg: COLORS.text }));
+    }
+    addSeparator(box, renderer);
+  }
+
+  // Equity curve fallback (when SDK dashboard not available)
+  const curve = data.equity_curve ?? data.equityCurve ?? [];
+  if (!data.ascii_dashboard && curve.length > 2) {
+    const chartLines = renderAsciiChart(curve, 44, 6);
+    const finalVal = curve[curve.length - 1] ?? 0;
+    const startVal = curve[0] ?? 0;
+    const chartColor = finalVal >= startVal ? COLORS.success : COLORS.error;
+
+    for (const line of chartLines) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: line, fg: chartColor }));
+    }
+    addSeparator(box, renderer);
+  }
+
+  // Metrics grid (from hz.backtest().metrics)
+  const m = data.metrics ?? data;
+  const pnlColor = (m.total_return ?? 0) >= 0 ? COLORS.success : COLORS.error;
+
+  if (m.total_return !== undefined) addRow(box, renderer, "Total Return", `${(m.total_return * 100).toFixed(1)}%`, pnlColor);
+  if (m.max_drawdown !== undefined) addRow(box, renderer, "Max Drawdown", `${(m.max_drawdown * 100).toFixed(1)}%`, COLORS.error);
+  if (m.sharpe_ratio !== undefined) addRow(box, renderer, "Sharpe Ratio", m.sharpe_ratio.toFixed(2), m.sharpe_ratio >= 1 ? COLORS.success : COLORS.warning);
+  if (m.sortino_ratio !== undefined) addRow(box, renderer, "Sortino Ratio", m.sortino_ratio.toFixed(2));
+  if (m.win_rate !== undefined) addRow(box, renderer, "Win Rate", `${(m.win_rate * 100).toFixed(1)}%`);
+  if (m.total_trades !== undefined) addRow(box, renderer, "Total Trades", `${m.total_trades}`);
+  if (m.profit_factor !== undefined) addRow(box, renderer, "Profit Factor", m.profit_factor.toFixed(2), m.profit_factor >= 1.5 ? COLORS.success : COLORS.warning);
+  if (m.expectancy !== undefined) addRow(box, renderer, "Expectancy", `$${m.expectancy.toFixed(4)}`);
+  if (m.total_fees !== undefined) addRow(box, renderer, "Total Fees", `$${m.total_fees.toFixed(4)}`);
+
+  // Per-market P&L
+  if (data.pnl_by_market && Object.keys(data.pnl_by_market).length > 0) {
+    addSeparator(box, renderer);
+    box.add(new TextRenderable(renderer, { id: uid(), content: "  P&L by Market", fg: COLORS.textMuted }));
+    for (const [market, pnl] of Object.entries(data.pnl_by_market)) {
+      const val = pnl as number;
+      addRow(box, renderer, `  ${market}`, `$${val >= 0 ? "+" : ""}${val.toFixed(2)}`, val >= 0 ? COLORS.success : COLORS.error);
+    }
+  }
+
+  // SDK summary text (from result.summary())
+  if (data.summary) {
+    addSeparator(box, renderer);
+    for (const line of (data.summary as string).split("\n").slice(0, 15)) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: line, fg: COLORS.textMuted }));
+    }
+  }
+
+  // Duration / trade count
+  if (data.duration || data.trade_count !== undefined) {
+    addSeparator(box, renderer);
+    if (data.duration) addRow(box, renderer, "Period", data.duration);
+    if (data.trade_count !== undefined) addRow(box, renderer, "Fills", `${data.trade_count}`);
+  }
+
+  return box;
+}
+
+// ── Market Resolution (resolve_markets result) ──
+
+export function renderMarketResolution(data: any, renderer: CliRenderer): BoxRenderable {
+  const box = new BoxRenderable(renderer, { id: uid(), flexDirection: "column", marginBottom: 1 });
+  const markets = data.markets ?? [];
+
+  if (markets.length === 0) {
+    box.add(new TextRenderable(renderer, { id: uid(), content: "No matching markets found", fg: COLORS.textMuted }));
+    return box;
+  }
+
+  box.add(new TextRenderable(renderer, {
+    id: uid(), content: `Found ${markets.length} market${markets.length > 1 ? "s" : ""}`, fg: COLORS.textMuted,
+  }));
+
+  for (let i = 0; i < Math.min(markets.length, 5); i++) {
+    const m = markets[i];
+    const price = m.yesPrice ? `${(parseFloat(m.yesPrice) * 100).toFixed(0)}¢` : "—";
+    const title = (m.title ?? "").length > 50 ? m.title.slice(0, 50) + "…" : m.title;
+    const row = new BoxRenderable(renderer, { id: uid(), flexDirection: "row" });
+    row.add(new TextRenderable(renderer, { id: uid(), content: `${i + 1}. `, fg: COLORS.textMuted }));
+    row.add(new TextRenderable(renderer, { id: uid(), content: title, fg: COLORS.text }));
+    row.add(new TextRenderable(renderer, { id: uid(), content: `  ${price}`, fg: COLORS.success }));
+    box.add(row);
+    if (m.slug) {
+      box.add(new TextRenderable(renderer, { id: uid(), content: `   ${m.slug}`, fg: COLORS.textMuted }));
+    }
+  }
+
+  return box;
+}
+
+// ── Public dispatcher ──
+
+export function renderStrategyWidget(
+  toolName: string,
+  data: any,
+  renderer: CliRenderer,
+): BoxRenderable | null {
+  switch (toolName) {
+    case "edit_strategy": return renderStrategyProposal(data, renderer);
+    case "load_saved_strategy": return renderStrategyProposal(data, renderer);
+    case "validate_strategy": return renderValidationResult(data, renderer);
+    case "backtest_strategy": return renderBacktestResult(data, renderer);
+    case "polymarket_data": return renderMarketResolution(data, renderer);
+    default: return null;
+  }
+}

package/src/syntax/setup.ts

@@ -0,0 +1,54 @@
+// Python syntax highlighting setup for the code panel
+// Loads tree-sitter-python WASM and registers it for markdown code blocks
+
+import { resolve } from "path";
+
+const assetsDir = resolve(import.meta.dir, "../../assets/python");
+const wasmPath = resolve(assetsDir, "tree-sitter-python.wasm");
+const highlightsPath = resolve(assetsDir, "highlights.scm");
+
+let client: any = null;
+
+/**
+ * Get or create a shared TreeSitterClient with Python support.
+ * Returns null if tree-sitter is not available.
+ */
+export async function getTreeSitterClient(): Promise<any> {
+  if (client) return client;
+
+  try {
+    const { TreeSitterClient, addDefaultParsers } = await import("@opentui/core");
+
+    // Register Python parser globally
+    addDefaultParsers([{
+      filetype: "python",
+      wasm: wasmPath,
+      queries: { highlights: [highlightsPath] },
+    }]);
+
+    const dataPath = resolve(import.meta.dir, "../../node_modules/@opentui/core/assets");
+    client = new TreeSitterClient({ dataPath });
+
+    // Also register directly on the client instance
+    if (client.addFiletypeParser) {
+      client.addFiletypeParser({
+        filetype: "python",
+        wasm: wasmPath,
+        queries: { highlights: [highlightsPath] },
+      });
+    }
+
+    await client.initialize();
+    return client;
+  } catch (e) {
+    // Tree-sitter init failed — code panel will work without highlighting
+    return null;
+  }
+}
+
+export function destroyTreeSitterClient(): void {
+  if (client) {
+    try { client.destroy(); } catch {}
+    client = null;
+  }
+}

package/src/theme/colors.ts

@@ -0,0 +1,107 @@
+// Theme system — mutable color object, setTheme overwrites in place
+
+export type ThemeName =
+  | "dark" | "midnight" | "nord" | "solarized"  // Free
+  | "light"                                       // Free
+  | "poly" | "poly-dark"                          // Ultra
+  | "limitless"                                   // Ultra
+  | "apple-1984";                                 // Ultra
+
+export const ULTRA_THEMES = new Set<ThemeName>(["poly", "poly-dark", "limitless", "apple-1984"]);
+
+interface Colors {
+  bg: string; bgSecondary: string; bgDarker: string; selection: string;
+  text: string; textMuted: string; textEmphasized: string;
+  border: string; borderDim: string; borderFocus: string;
+  primary: string; primaryDim: string; secondary: string; accent: string;
+  success: string; error: string; warning: string; info: string;
+}
+
+const THEMES: Record<ThemeName, Colors> = {
+  dark: {
+    bg: "#212121", bgSecondary: "#252525", bgDarker: "#1a1a1a", selection: "#303030",
+    text: "#e0e0e0", textMuted: "#6a6a6a", textEmphasized: "#ffffff",
+    border: "#4b4c5c", borderDim: "#333333", borderFocus: "#fab283",
+    primary: "#fab283", primaryDim: "#c48a62", secondary: "#5c9cf5", accent: "#9d7cd8",
+    success: "#7fd88f", error: "#e06c75", warning: "#f5a742", info: "#56b6c2",
+  },
+  midnight: {
+    bg: "#0d1117", bgSecondary: "#161b22", bgDarker: "#080c12", selection: "#1c2333",
+    text: "#c9d1d9", textMuted: "#484f58", textEmphasized: "#f0f6fc",
+    border: "#30363d", borderDim: "#21262d", borderFocus: "#8be9fd",
+    primary: "#ff79c6", primaryDim: "#cc5f9e", secondary: "#8be9fd", accent: "#bd93f9",
+    success: "#50fa7b", error: "#ff5555", warning: "#f1fa8c", info: "#8be9fd",
+  },
+  nord: {
+    bg: "#2e3440", bgSecondary: "#3b4252", bgDarker: "#272c36", selection: "#434c5e",
+    text: "#d8dee9", textMuted: "#616e88", textEmphasized: "#eceff4",
+    border: "#4c566a", borderDim: "#3b4252", borderFocus: "#81a1c1",
+    primary: "#d08770", primaryDim: "#a5654f", secondary: "#81a1c1", accent: "#b48ead",
+    success: "#a3be8c", error: "#bf616a", warning: "#ebcb8b", info: "#88c0d0",
+  },
+  solarized: {
+    bg: "#002b36", bgSecondary: "#073642", bgDarker: "#001f27", selection: "#0a4050",
+    text: "#839496", textMuted: "#586e75", textEmphasized: "#fdf6e3",
+    border: "#2aa198", borderDim: "#073642", borderFocus: "#268bd2",
+    primary: "#cb4b16", primaryDim: "#a33a0e", secondary: "#268bd2", accent: "#6c71c4",
+    success: "#859900", error: "#dc322f", warning: "#b58900", info: "#2aa198",
+  },
+
+  // ── Light ──
+  light: {
+    bg: "#ffffff", bgSecondary: "#f5f5f5", bgDarker: "#e8e8e8", selection: "#d0d7de",
+    text: "#24292f", textMuted: "#656d76", textEmphasized: "#000000",
+    border: "#d0d7de", borderDim: "#e1e4e8", borderFocus: "#0969da",
+    primary: "#0969da", primaryDim: "#0550ae", secondary: "#8250df", accent: "#bf3989",
+    success: "#1a7f37", error: "#cf222e", warning: "#9a6700", info: "#0969da",
+  },
+
+  // ── Ultra: Poly (Polymarket brand — white and blue) ──
+  poly: {
+    bg: "#f8f9fb", bgSecondary: "#eef1f6", bgDarker: "#e2e7ef", selection: "#d4dbe8",
+    text: "#1a1f36", textMuted: "#6b7394", textEmphasized: "#0a0f24",
+    border: "#d4dbe8", borderDim: "#e2e7ef", borderFocus: "#3b82f6",
+    primary: "#3b82f6", primaryDim: "#2563eb", secondary: "#6366f1", accent: "#8b5cf6",
+    success: "#10b981", error: "#ef4444", warning: "#f59e0b", info: "#3b82f6",
+  },
+
+  // ── Ultra: Poly Dark (black and blue) ──
+  "poly-dark": {
+    bg: "#0f1120", bgSecondary: "#151830", bgDarker: "#0a0c18", selection: "#1e2240",
+    text: "#c8cee0", textMuted: "#5b6080", textEmphasized: "#f0f2ff",
+    border: "#2a2f50", borderDim: "#1e2240", borderFocus: "#3b82f6",
+    primary: "#3b82f6", primaryDim: "#2563eb", secondary: "#6366f1", accent: "#818cf8",
+    success: "#34d399", error: "#f87171", warning: "#fbbf24", info: "#60a5fa",
+  },
+
+  // ── Ultra: Limitless (black and neon green) ──
+  limitless: {
+    bg: "#0a0a0a", bgSecondary: "#111111", bgDarker: "#050505", selection: "#1a2a1a",
+    text: "#b0b0b0", textMuted: "#505050", textEmphasized: "#00ff41",
+    border: "#1a3a1a", borderDim: "#151515", borderFocus: "#00ff41",
+    primary: "#00ff41", primaryDim: "#00cc33", secondary: "#00e5ff", accent: "#00ff41",
+    success: "#00ff41", error: "#ff1744", warning: "#ffea00", info: "#00e5ff",
+  },
+
+  // ── Ultra: Apple 1984 (phosphor green on black CRT) ──
+  "apple-1984": {
+    bg: "#000000", bgSecondary: "#0a0f0a", bgDarker: "#000000", selection: "#0d1f0d",
+    text: "#33ff33", textMuted: "#1a8c1a", textEmphasized: "#66ff66",
+    border: "#1a5c1a", borderDim: "#0d2e0d", borderFocus: "#33ff33",
+    primary: "#33ff33", primaryDim: "#1aaa1a", secondary: "#33ff33", accent: "#66ff66",
+    success: "#33ff33", error: "#ff3333", warning: "#ffff33", info: "#33ff33",
+  },
+};
+
+// Mutable — setTheme overwrites properties so existing references stay valid
+export const COLORS: Colors = { ...THEMES.dark };
+
+export function setTheme(name: ThemeName): void {
+  const theme = THEMES[name];
+  if (!theme) return;
+  Object.assign(COLORS, theme);
+}
+
+export function getThemeNames(): ThemeName[] {
+  return Object.keys(THEMES) as ThemeName[];
+}

package/src/theme/icons.ts

@@ -0,0 +1,27 @@
+export const ICONS = {
+  // App
+  logo: "\u2B2C",          // ⬬
+
+  // Status
+  check: "\u2713",         // ✓
+  error: "\u2716",         // ✖
+  warning: "\u26A0",       // ⚠
+  info: "i",
+  spinner: "\u27F3",       // ⟳
+
+  // States
+  running: "\u25CF",       // ●
+  paused: "\u25CB",        // ○
+  stopped: "\u25A0",       // ■
+
+  // Navigation
+  pointer: "\u25B8",       // ▸
+  dot: "\u00B7",           // ·
+
+  // Sparkline blocks
+  spark: ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"] as const,
+
+  // Progress
+  barFull: "\u2588",       // █
+  barEmpty: "\u2591",      // ░
+} as const;