horizon-code 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "horizon-code",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "AI-powered trading strategy terminal for Polymarket",
   "type": "module",
   "bin": {

package/src/ai/system-prompt.ts

@@ -1,5 +1,6 @@
 import type { Mode } from "../components/mode-bar.ts";
 import { buildGeneratePrompt } from "../strategy/prompts.ts";
+import { store } from "../state/store.ts";
 
 const BASE = `You are Horizon, an AI trading research assistant running in a CLI terminal.
 
@@ -123,7 +124,25 @@ const VERBOSITY_PREFIX: Record<string, string> = {
 
 export function getSystemPrompt(mode: Mode, verbosity: string = "normal"): string {
   // Strategy mode has its own verbosity rules — don't override
-  if (mode === "strategy") return buildGeneratePrompt();
+  if (mode === "strategy") {
+    let prompt = buildGeneratePrompt();
+    // Inject user profile context if available
+    try {
+      const { buildProfileContext } = require("../platform/profile.ts");
+      const profileCtx = buildProfileContext();
+      if (profileCtx) prompt += "\n\n" + profileCtx;
+    } catch {}
+    // Inject active strategy context so research tools auto-scope
+    const draft = store.getActiveSession()?.strategyDraft;
+    if (draft?.code) {
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      const slugs = marketsMatch ? [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!) : [];
+      if (slugs.length > 0) {
+        prompt += `\n\n## Active Strategy Context\nThe user is working on "${draft.name}" trading these markets: ${slugs.join(", ")}. When they ask about "the market" or "what's happening", scope to these markets first. Use these slugs for polymarket_data, scan_correlations, etc.`;
+      }
+    }
+    return prompt;
+  }
   const prefix = VERBOSITY_PREFIX[verbosity] ?? "";
   return MODE_PROMPTS[mode] + prefix;
 }

package/src/app.ts

@@ -76,6 +76,17 @@ const SLASH_COMMANDS: Record<string, { description: string; usage: string }> = {
   "/exchanges": { description: "Show exchange connection status", usage: "/exchanges" },
   "/quit":    { description: "Exit Horizon", usage: "/quit" },
   "/exit":    { description: "Exit Horizon", usage: "/exit" },
+  "/bt":      { description: "Backtest current strategy", usage: "/bt" },
+  "/backtest": { description: "Backtest current strategy", usage: "/backtest" },
+  "/run":     { description: "Run current strategy", usage: "/run" },
+  "/dash":    { description: "Open strategy dashboard", usage: "/dash" },
+  "/dashboard": { description: "Open strategy dashboard", usage: "/dashboard" },
+  "/save":    { description: "Save current strategy", usage: "/save [name]" },
+  "/health":  { description: "Check strategy health score", usage: "/health" },
+  "/versions": { description: "List strategy versions", usage: "/versions [name]" },
+  "/export":  { description: "Export strategy to file", usage: "/export" },
+  "/report":  { description: "Generate strategy ledger report", usage: "/report [name]" },
+  "/session-export": { description: "Export chat session to markdown", usage: "/session-export" },
 };
 
 export class App {
@@ -304,6 +315,18 @@ export class App {
     this.keyHandler.onClear(() => {});
     this.keyHandler.onSessions(() => this.togglePanel("sessions"));
     this.keyHandler.onDeployments(() => this.togglePanel("deployments"));
+    this.keyHandler.onOpenDashboard(() => {
+      if (dashboard.running) {
+        Bun.spawn(["open", dashboard.url]);
+      } else {
+        // Auto-start built-in dashboard if processes running
+        const hasLocal = [...runningProcesses.values()].some(m => m.proc.exitCode === null);
+        if (hasLocal) {
+          const url = dashboard.start("local", 0, true);
+          Bun.spawn(["open", url]);
+        }
+      }
+    });
     this.keyHandler.onTabNext(() => { store.nextTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabPrev(() => { store.prevTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabClose(() => { store.closeTab(store.get().activeSessionId); this.switchToActiveTab(); });
@@ -527,6 +550,49 @@ export class App {
           startedAt: localProcessStartedAt,
         });
         this._hasLocalMetrics = true;
+
+        // Check alerts against current local metrics (fire-and-forget — setInterval is not async)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { checkAlerts } = await import("./strategy/alerts.ts");
+              const draft = store.getActiveSession()?.strategyDraft;
+              const alertResults = await checkAlerts(
+                draft?.name ?? "local",
+                {
+                  pnl: metrics.pnl,
+                  max_dd: metrics.max_dd ?? 0,
+                  exposure: metrics.exposure ?? 0,
+                  win_rate: metrics.win_rate ?? 0,
+                  trades: metrics.trades ?? 0,
+                },
+                () => {
+                  // Stop all running processes
+                  for (const [pid, m] of runningProcesses) {
+                    if (m.proc.exitCode === null) m.cleanup?.();
+                  }
+                },
+              );
+              for (const r of alertResults) {
+                if (r.triggered && r.actionTaken) {
+                  this.codePanel.appendLog(r.actionTaken);
+                }
+              }
+            } catch {}
+          })();
+        })(localMetricsData);
+
+        // Record replay metrics (fire-and-forget)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { recordMetrics, isRecording } = await import("./strategy/replay.ts");
+              for (const [pid] of runningProcesses) {
+                if (isRecording(pid)) recordMetrics(pid, metrics as any);
+              }
+            } catch {}
+          })();
+        })(localMetricsData);
       } else if (this._hasLocalMetrics && alive === 0) {
         // Local process stopped — clear local metrics, let platform data take over
         this._hasLocalMetrics = false;
@@ -845,6 +911,81 @@ export class App {
       case "/exit":
         this.quit();
         break;
+      case "/bt":
+      case "/backtest": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.backtest_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/run": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.run_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/dash":
+      case "/dashboard": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.spawn_dashboard;
+        const result = await tool.execute({ strategy_id: "local" });
+        if (result?.url) Bun.spawn(["open", result.url]);
+        break;
+      }
+      case "/save": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.save_strategy;
+        const draft = store.getActiveSession()?.strategyDraft;
+        const result = await tool.execute({ name: draft?.name ?? arg ?? "untitled" });
+        this.codePanel.appendLog(`Saved: ${JSON.stringify(result)}`);
+        break;
+      }
+      case "/health": {
+        const { computeHealthScore } = await import("./strategy/health.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const report = computeHealthScore(draft.code);
+        this.codePanel.appendLog(`Health: ${report.score}/${report.maxScore} (${report.grade}) — ${report.summary}`);
+        break;
+      }
+      case "/versions": {
+        const { listVersions } = await import("./strategy/versioning.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const versions = await listVersions(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(versions.length === 0 ? "No versions found" : versions.map(v => `v${v.version} [${v.hash}] ${v.label} — ${v.timestamp}`).join("\n"));
+        break;
+      }
+      case "/export": {
+        const { exportStrategy } = await import("./strategy/export.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const result = await exportStrategy(draft.name, draft.code, draft.params ?? {}, null);
+        this.codePanel.appendLog(`Exported to ${result.path} (${result.size} bytes)`);
+        break;
+      }
+      case "/report": {
+        const { generateReport } = await import("./strategy/ledger.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const report = generateReport(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(report.summary);
+        break;
+      }
+      case "/session-export": {
+        const session = store.getActiveSession();
+        if (!session) break;
+        const { writeWorkspaceFile } = await import("./strategy/workspace.ts");
+        const lines: string[] = [];
+        lines.push(`# ${session.id} — ${new Date().toISOString()}\n`);
+        for (const msg of session.messages) {
+          const role = msg.role === "user" ? "**User**" : "**Horizon**";
+          const text = msg.content.map((b: any) => b.text ?? b.markdown ?? "").join("\n");
+          lines.push(`### ${role}\n${text}\n`);
+        }
+        const fileName = `session_${Date.now()}.md`;
+        await writeWorkspaceFile(`exports/${fileName}`, lines.join("\n"));
+        this.codePanel.appendLog(`Session exported to exports/${fileName}`);
+        break;
+      }
       default: {
         // Unknown command — show as system message
         const msg: Message = {
@@ -1158,6 +1299,23 @@ export class App {
       contextParts.push(`Active strategy: ${draft.name} (${draft.phase}, ${draft.validationStatus})`);
     }
 
+    // Preserve strategy context through compaction
+    if (draft?.code) {
+      contextParts.push(`\nActive strategy code hash: ${draft.code.length} chars`);
+      // Preserve active market slugs
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      if (marketsMatch) {
+        const slugs2 = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+        contextParts.push(`Active markets: ${slugs2.join(", ")}`);
+      }
+    }
+
+    // Preserve running process info
+    const pids = [...runningProcesses.keys()].filter(pid => runningProcesses.get(pid)?.proc.exitCode === null);
+    if (pids.length > 0) {
+      contextParts.push(`Running processes: PIDs ${pids.join(", ")}`);
+    }
+
     contextParts.push("");
     contextParts.push("Conversation summary:");
     contextParts.push(...summaryParts.slice(-15)); // last 15 exchanges max

package/src/components/footer.ts

@@ -33,7 +33,7 @@ export class Footer {
 
     this.hintsText = new TextRenderable(renderer, {
       id: "footer-hints",
-      content: "esc stop  ^N new chat  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  / cmd",
+      content: "esc stop  ^N new  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  ^O dash  / cmd",
       fg: COLORS.borderDim,
     });
     this.container.add(this.hintsText);

package/src/keys/handler.ts

@@ -20,6 +20,7 @@ export class KeyHandler {
   private tabCloseCallback: (() => void) | null = null;
   private tabNewCallback: (() => void) | null = null;
   private acNavCallback: ((dir: "up" | "down" | "accept" | "dismiss") => void) | null = null;
+  private openDashboardCallback: (() => void) | null = null;
   acActive = false; // set by app when autocomplete is visible
 
   // Panel navigation (shared by session & strategy panels)
@@ -56,6 +57,7 @@ export class KeyHandler {
   onTabClose(cb: () => void): void { this.tabCloseCallback = cb; }
   onTabNew(cb: () => void): void { this.tabNewCallback = cb; }
   onAcNav(cb: (dir: "up" | "down" | "accept" | "dismiss") => void): void { this.acNavCallback = cb; }
+  onOpenDashboard(cb: () => void): void { this.openDashboardCallback = cb; }
 
   onPanelNav(cb: (delta: number) => void): void { this.panelNavCallback = cb; }
   onPanelSelect(cb: () => void): void { this.panelSelectCallback = cb; }
@@ -123,6 +125,12 @@ export class KeyHandler {
       return;
     }
 
+    // Ctrl+O — open dashboard in browser
+    if (key.ctrl && key.name === "o") {
+      this.openDashboardCallback?.();
+      return;
+    }
+
     // Ctrl+L — next tab (was clear, now tab navigation)
     if (key.ctrl && key.name === "l") {
       if (this.panelActive === "sessions") { this.panelNewCallback?.(); return; }

package/src/platform/profile.ts

@@ -0,0 +1,202 @@
+// Cumulative user profile — learns preferences over time
+// Storage: ~/.horizon/profile.json
+
+import { homedir } from "os";
+import { resolve } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+const PROFILE_PATH = resolve(homedir(), ".horizon", "profile.json");
+
+export interface UserProfile {
+  // Trading preferences
+  preferred_markets: string[];          // most-used market slugs
+  preferred_exchanges: string[];        // polymarket, kalshi, etc.
+  risk_tolerance: "conservative" | "moderate" | "aggressive";
+  typical_spread: number;               // average spread parameter used
+  typical_position_size: number;        // average max_position used
+  always_paper_first: boolean;          // always tests in paper before live
+
+  // Workflow patterns
+  strategies_created: number;
+  strategies_deployed: number;
+  backtests_run: number;
+  total_sessions: number;
+  preferred_strategy_types: string[];   // mm, momentum, arb, etc.
+  avg_pipeline_depth: number;           // average number of pipeline functions
+
+  // Usage stats
+  first_seen: string;
+  last_seen: string;
+  total_interactions: number;
+}
+
+const DEFAULT_PROFILE: UserProfile = {
+  preferred_markets: [],
+  preferred_exchanges: [],
+  risk_tolerance: "moderate",
+  typical_spread: 0.04,
+  typical_position_size: 100,
+  always_paper_first: true,
+  strategies_created: 0,
+  strategies_deployed: 0,
+  backtests_run: 0,
+  total_sessions: 0,
+  preferred_strategy_types: [],
+  avg_pipeline_depth: 2,
+  first_seen: new Date().toISOString(),
+  last_seen: new Date().toISOString(),
+  total_interactions: 0,
+};
+
+/** Load profile from disk */
+export function loadProfile(): UserProfile {
+  if (!existsSync(PROFILE_PATH)) return { ...DEFAULT_PROFILE };
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_PATH, "utf-8"));
+    return { ...DEFAULT_PROFILE, ...data };
+  } catch {
+    return { ...DEFAULT_PROFILE };
+  }
+}
+
+/** Save profile to disk */
+export function saveProfile(profile: UserProfile): void {
+  profile.last_seen = new Date().toISOString();
+  writeFileSync(PROFILE_PATH, JSON.stringify(profile, null, 2));
+}
+
+/** Update profile based on strategy code analysis */
+export function learnFromStrategy(code: string): void {
+  const profile = loadProfile();
+
+  // Extract market slugs
+  const marketsMatch = code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+  if (marketsMatch) {
+    const slugs = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+    for (const slug of slugs) {
+      if (!profile.preferred_markets.includes(slug)) {
+        profile.preferred_markets.push(slug);
+        if (profile.preferred_markets.length > 20) profile.preferred_markets.shift();
+      }
+    }
+  }
+
+  // Extract exchange
+  const exchangeMatch = code.match(/exchange\s*=\s*hz\.(\w+)/);
+  if (exchangeMatch) {
+    const exchange = exchangeMatch[1]!.toLowerCase();
+    if (!profile.preferred_exchanges.includes(exchange)) {
+      profile.preferred_exchanges.push(exchange);
+    }
+  }
+
+  // Extract spread
+  const spreadMatch = code.match(/spread\s*[=:]\s*([\d.]+)/);
+  if (spreadMatch) {
+    const spread = parseFloat(spreadMatch[1]!);
+    if (spread > 0 && spread < 1) {
+      profile.typical_spread = (profile.typical_spread + spread) / 2;
+    }
+  }
+
+  // Extract max_position
+  const posMatch = code.match(/max_position\s*=\s*(\d+)/);
+  if (posMatch) {
+    const pos = parseInt(posMatch[1]!);
+    profile.typical_position_size = Math.round((profile.typical_position_size + pos) / 2);
+  }
+
+  // Detect risk tolerance from risk config
+  const ddMatch = code.match(/max_drawdown_pct\s*=\s*([\d.]+)/);
+  if (ddMatch) {
+    const dd = parseFloat(ddMatch[1]!);
+    if (dd <= 5) profile.risk_tolerance = "conservative";
+    else if (dd <= 15) profile.risk_tolerance = "moderate";
+    else profile.risk_tolerance = "aggressive";
+  }
+
+  // Detect strategy type
+  const codeLC = code.toLowerCase();
+  const types: string[] = [];
+  if (/market.?mak|mm_|spread/.test(codeLC)) types.push("market_making");
+  if (/momentum|trend|signal/.test(codeLC)) types.push("momentum");
+  if (/arb|arbitrage/.test(codeLC)) types.push("arbitrage");
+  if (/mean.?rev|revert/.test(codeLC)) types.push("mean_reversion");
+  if (/scalp/.test(codeLC)) types.push("scalper");
+
+  for (const t of types) {
+    if (!profile.preferred_strategy_types.includes(t)) {
+      profile.preferred_strategy_types.push(t);
+      if (profile.preferred_strategy_types.length > 10) profile.preferred_strategy_types.shift();
+    }
+  }
+
+  // Pipeline depth
+  const pipelineMatch = code.match(/pipeline\s*=\s*\[([\s\S]*?)\]/);
+  if (pipelineMatch) {
+    const fns = pipelineMatch[1]!.split(",").filter(s => s.trim() && !s.trim().startsWith("#"));
+    if (fns.length > 0) {
+      profile.avg_pipeline_depth = Math.round((profile.avg_pipeline_depth + fns.length) / 2);
+    }
+  }
+
+  // Paper mode preference
+  if (/mode\s*=\s*["']paper["']/.test(code)) {
+    profile.always_paper_first = true;
+  }
+
+  profile.strategies_created++;
+  profile.total_interactions++;
+
+  saveProfile(profile);
+}
+
+/** Record a backtest run */
+export function recordBacktest(): void {
+  const profile = loadProfile();
+  profile.backtests_run++;
+  profile.total_interactions++;
+  saveProfile(profile);
+}
+
+/** Record a deployment */
+export function recordDeploy(): void {
+  const profile = loadProfile();
+  profile.strategies_deployed++;
+  profile.total_interactions++;
+  saveProfile(profile);
+}
+
+/** Record a session start */
+export function recordSession(): void {
+  const profile = loadProfile();
+  profile.total_sessions++;
+  saveProfile(profile);
+}
+
+/** Build a context string for the LLM system prompt */
+export function buildProfileContext(): string {
+  const p = loadProfile();
+  if (p.total_interactions === 0) return "";
+
+  const parts: string[] = [];
+  parts.push("## User Profile (learned from usage)");
+
+  if (p.preferred_markets.length > 0) {
+    parts.push(`- Frequently traded markets: ${p.preferred_markets.slice(-5).join(", ")}`);
+  }
+  if (p.preferred_exchanges.length > 0) {
+    parts.push(`- Preferred exchanges: ${p.preferred_exchanges.join(", ")}`);
+  }
+  if (p.preferred_strategy_types.length > 0) {
+    parts.push(`- Strategy style: ${p.preferred_strategy_types.join(", ")}`);
+  }
+  parts.push(`- Risk tolerance: ${p.risk_tolerance} (typical spread: ${p.typical_spread.toFixed(3)}, typical max_position: ${p.typical_position_size})`);
+  parts.push(`- Experience: ${p.strategies_created} strategies created, ${p.backtests_run} backtests, ${p.strategies_deployed} deployments`);
+
+  if (p.always_paper_first) {
+    parts.push("- Always uses paper mode first (respect this preference)");
+  }
+
+  return parts.join("\n");
+}

package/src/research/scanner.ts

@@ -0,0 +1,212 @@
+// Market scanner + correlation analysis
+// Scans for trading opportunities across Polymarket markets
+
+import { gammaEvents } from "./apis.ts";
+
+export interface MarketOpportunity {
+  slug: string;
+  title: string;
+  type: "wide_spread" | "high_volume" | "mispricing" | "volatile";
+  score: number; // 0-100
+  spread?: number;
+  volume?: number;
+  price?: number;
+  detail: string;
+}
+
+export interface CorrelationResult {
+  marketA: string;
+  marketB: string;
+  correlation: number;   // -1 to 1
+  direction: string;     // "positive", "negative", "neutral"
+  strength: string;      // "strong", "moderate", "weak"
+}
+
+export interface CorrelationMatrix {
+  markets: string[];
+  matrix: number[][];
+  pairs: CorrelationResult[];
+  high_correlation_warning: string | null;
+}
+
+/**
+ * Scan top Polymarket markets for trading opportunities.
+ * Returns ranked list of opportunities for market making, edge trading, or arbitrage.
+ */
+export async function scanOpportunities(limit: number = 30): Promise<{
+  opportunities: MarketOpportunity[];
+  total_scanned: number;
+  summary: string;
+}> {
+  // Fetch active events
+  const events = await gammaEvents({ query: "", limit: limit * 2 });
+  if (!events || events.length === 0) {
+    return { opportunities: [], total_scanned: 0, summary: "No markets available." };
+  }
+
+  const opportunities: MarketOpportunity[] = [];
+
+  for (const event of events) {
+    const markets = event.markets ?? [event];
+
+    for (const market of markets) {
+      const slug = market.slug ?? market.conditionId ?? "";
+      const title = market.question ?? market.title ?? slug;
+      const spread = market.spread ?? (market.bestAsk && market.bestBid ? market.bestAsk - market.bestBid : null);
+      const volume = market.volume ?? market.volumeNum ?? 0;
+      const price = market.lastTradePrice ?? market.outcomePrices?.[0] ?? 0.5;
+      const priceNum = typeof price === "string" ? parseFloat(price) : price;
+
+      // Wide spread opportunity (market making)
+      if (spread && spread > 0.04) {
+        const score = Math.min(100, Math.round(spread * 500));
+        opportunities.push({
+          slug, title, type: "wide_spread", score, spread, volume: volume,
+          detail: `Spread ${(spread * 100).toFixed(1)}c — room for market making`,
+        });
+      }
+
+      // High volume but price near 50% (uncertain market = good for MM)
+      if (volume > 50000 && priceNum > 0.3 && priceNum < 0.7) {
+        const uncertainty = 1 - Math.abs(priceNum - 0.5) * 2;
+        const score = Math.min(100, Math.round(uncertainty * 60 + (volume / 100000) * 40));
+        opportunities.push({
+          slug, title, type: "high_volume", score, volume, price: priceNum,
+          detail: `$${(volume / 1000).toFixed(0)}K vol, price ${(priceNum * 100).toFixed(0)}c — high uncertainty`,
+        });
+      }
+
+      // Extreme prices that might indicate mispricing
+      if (priceNum > 0.02 && priceNum < 0.08) {
+        opportunities.push({
+          slug, title, type: "mispricing", score: 65, price: priceNum,
+          detail: `Low price ${(priceNum * 100).toFixed(1)}c — potential long tail value`,
+        });
+      }
+      if (priceNum > 0.92 && priceNum < 0.98) {
+        opportunities.push({
+          slug, title, type: "mispricing", score: 55, price: priceNum,
+          detail: `High price ${(priceNum * 100).toFixed(1)}c — potential short opportunity`,
+        });
+      }
+    }
+  }
+
+  // Sort by score descending and deduplicate by slug
+  const seen = new Set<string>();
+  const unique = opportunities
+    .sort((a, b) => b.score - a.score)
+    .filter(o => {
+      if (seen.has(o.slug)) return false;
+      seen.add(o.slug);
+      return true;
+    })
+    .slice(0, limit);
+
+  const byType = {
+    wide_spread: unique.filter(o => o.type === "wide_spread").length,
+    high_volume: unique.filter(o => o.type === "high_volume").length,
+    mispricing: unique.filter(o => o.type === "mispricing").length,
+  };
+
+  const summary = `Scanned ${events.length} markets. Found ${unique.length} opportunities: ` +
+    `${byType.wide_spread} wide spreads, ${byType.high_volume} high volume, ${byType.mispricing} mispricings.`;
+
+  return { opportunities: unique, total_scanned: events.length, summary };
+}
+
+/**
+ * Compute pairwise correlations between a set of markets.
+ * Uses simple price-based correlation from available data.
+ */
+export function computeCorrelations(
+  marketPrices: { slug: string; prices: number[] }[],
+): CorrelationMatrix {
+  const n = marketPrices.length;
+  const matrix: number[][] = Array.from({ length: n }, () => Array(n).fill(0));
+  const pairs: CorrelationResult[] = [];
+
+  for (let i = 0; i < n; i++) {
+    matrix[i]![i] = 1.0;
+    for (let j = i + 1; j < n; j++) {
+      const corr = pearsonCorrelation(marketPrices[i]!.prices, marketPrices[j]!.prices);
+      matrix[i]![j] = corr;
+      matrix[j]![i] = corr;
+
+      const absCorr = Math.abs(corr);
+      pairs.push({
+        marketA: marketPrices[i]!.slug,
+        marketB: marketPrices[j]!.slug,
+        correlation: Math.round(corr * 100) / 100,
+        direction: corr > 0.1 ? "positive" : corr < -0.1 ? "negative" : "neutral",
+        strength: absCorr > 0.7 ? "strong" : absCorr > 0.4 ? "moderate" : "weak",
+      });
+    }
+  }
+
+  // Find high correlations that indicate concentration risk
+  const highCorr = pairs.filter(p => Math.abs(p.correlation) > 0.7);
+  const warning = highCorr.length > 0
+    ? `WARNING: ${highCorr.length} pair(s) with >0.7 correlation — portfolio is concentrated: ${highCorr.map(p => `${p.marketA}/${p.marketB} (${p.correlation})`).join(", ")}`
+    : null;
+
+  return {
+    markets: marketPrices.map(m => m.slug),
+    matrix,
+    pairs: pairs.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation)),
+    high_correlation_warning: warning,
+  };
+}
+
+/** Pearson correlation between two arrays */
+function pearsonCorrelation(x: number[], y: number[]): number {
+  const n = Math.min(x.length, y.length);
+  if (n < 3) return 0;
+
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += x[i]!;
+    sumY += y[i]!;
+    sumXY += x[i]! * y[i]!;
+    sumX2 += x[i]! * x[i]!;
+    sumY2 += y[i]! * y[i]!;
+  }
+
+  const numerator = n * sumXY - sumX * sumY;
+  const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+
+  if (denominator === 0) return 0;
+  return numerator / denominator;
+}
+
+/** Build ASCII correlation matrix for terminal display */
+export function formatCorrelationMatrix(result: CorrelationMatrix): string {
+  const { markets, matrix } = result;
+  const n = markets.length;
+  const maxSlugLen = Math.min(12, Math.max(...markets.map(m => m.length)));
+
+  const lines: string[] = [];
+
+  // Header
+  const header = " ".repeat(maxSlugLen + 2) + markets.map(m => m.slice(0, 6).padStart(7)).join("");
+  lines.push(header);
+  lines.push("-".repeat(header.length));
+
+  // Rows
+  for (let i = 0; i < n; i++) {
+    const slug = markets[i]!.slice(0, maxSlugLen).padEnd(maxSlugLen);
+    const vals = matrix[i]!.map((v, j) => {
+      if (i === j) return "  1.00";
+      const str = v.toFixed(2);
+      return (v >= 0 ? " " : "") + str;
+    }).map(s => s.padStart(7)).join("");
+    lines.push(`${slug}  ${vals}`);
+  }
+
+  if (result.high_correlation_warning) {
+    lines.push("");
+    lines.push(result.high_correlation_warning);
+  }
+
+  return lines.join("\n");
+}