horizon-code 0.5.1 → 0.6.1

package/src/platform/auth.ts

@@ -1,7 +1,7 @@
 import { saveConfig, loadConfig, getApiKey } from "./config.ts";
 import { platform } from "./client.ts";
 
-export type AuthStatus = "authenticated" | "no_key" | "invalid_key";
+export type AuthStatus = "authenticated" | "no_key" | "invalid_key" | "network_error";
 
 export async function checkAuth(): Promise<AuthStatus> {
   const key = getApiKey();
@@ -13,8 +13,8 @@ export async function checkAuth(): Promise<AuthStatus> {
     return "authenticated";
   } catch (err: any) {
     if (err?.status === 401 || err?.status === 403) return "invalid_key";
-    // Network error or server down — assume key is fine
-    return "authenticated";
+    // Network error — can't verify, report as network error
+    return "network_error";
   }
 }
 

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/platform/session-sync.ts

@@ -84,7 +84,7 @@ export async function loadSessions(): Promise<void> {
         openTabIds: openIds,
       });
     }
-  } catch {}
+  } catch (e: any) { console.error("[session-sync] loadSessions failed:", e?.message ?? e); }
 }
 
 /**
@@ -132,7 +132,7 @@ export async function saveActiveSession(): Promise<void> {
 
     // Update session metadata
     await updateDbSession(dbId, { name: session.name }).catch(() => {});
-  } catch {}
+  } catch (e: any) { console.error("[session-sync] saveActiveSession failed:", e?.message ?? e); }
 }
 
 /**
@@ -140,7 +140,7 @@ export async function saveActiveSession(): Promise<void> {
  */
 export async function deleteSessionFromDb(sessionId: string): Promise<void> {
   if (!(await isLoggedIn())) return;
-  try { await deleteDbSession(sessionId); } catch {}
+  try { await deleteDbSession(sessionId); } catch (e: any) { console.error("[session-sync] deleteSessionFromDb failed:", e?.message ?? e); }
 }
 
 /**

package/src/platform/supabase.ts

@@ -34,7 +34,8 @@ export function getSupabase(): SupabaseClient {
             refresh_token: encryptEnvVar(session.refresh_token),
           };
           config.session_encrypted = true;
-        } catch {
+        } catch (e) {
+          console.error("[supabase] encryption failed, using plaintext:", e);
           // Fallback to plaintext if encryption fails
           config.supabase_session = {
             access_token: session.access_token,
@@ -67,7 +68,7 @@ function saveSessionTokens(config: ReturnType<typeof loadConfig>, accessToken: s
       config.supabase_session = { access_token: encryptEnvVar(accessToken), refresh_token: encryptEnvVar(refreshToken) };
       config.session_encrypted = true;
       return;
-    } catch {}
+    } catch (e) { console.error("[supabase] saveSessionTokens encryption failed:", e); }
   }
   config.supabase_session = { access_token: accessToken, refresh_token: refreshToken };
   config.session_encrypted = false;
@@ -125,7 +126,7 @@ export async function restoreSession(): Promise<boolean> {
         if (config.api_key) platform.setApiKey(config.api_key);
         return true;
       }
-    } catch {}
+    } catch (e) { console.error("[supabase] setSession failed:", e); }
 
     // Access token expired — try refreshing with just the refresh token
     try {
@@ -142,7 +143,7 @@ export async function restoreSession(): Promise<boolean> {
         if (config.api_key) platform.setApiKey(config.api_key);
         return true;
       }
-    } catch {}
+    } catch (e) { console.error("[supabase] refreshSession failed:", e); }
 
     // Both failed — don't delete the session, it might work next time
     // (network issue, Supabase outage, etc.). The API key still works for chat.
@@ -224,7 +225,7 @@ export async function loginWithBrowser(): Promise<{ success: boolean; error?: st
             try {
               const apiKey = await createApiKey();
               if (apiKey) { config.api_key = apiKey; platform.setApiKey(apiKey); }
-            } catch {}
+            } catch (e) { console.error("[supabase] createApiKey failed:", e); }
           } else {
             platform.setApiKey(config.api_key);
           }
@@ -235,10 +236,10 @@ export async function loginWithBrowser(): Promise<{ success: boolean; error?: st
       }
       if (res.status === 410) return { success: false, error: "Session expired. Type /login to sign in again." };
       if (res.status === 404) return { success: false, error: "Auth session not found." };
-    } catch {}
+    } catch (e) { console.error("[supabase] poll timeout:", e); }
   }
 
-  try { await sb.from("cli_auth_sessions").delete().eq("id", sessionId); } catch {}
+  try { await sb.from("cli_auth_sessions").delete().eq("id", sessionId); } catch (e) { console.error("[supabase] cleanup auth session failed:", e); }
   return { success: false, error: "Login timed out (90s). Try /login again." };
 }
 
@@ -260,7 +261,7 @@ export async function loginWithPassword(email: string, password: string): Promis
     try {
       const apiKey = await createApiKey();
       if (apiKey) { config.api_key = apiKey; platform.setApiKey(apiKey); }
-    } catch {}
+    } catch (e) { console.error("[supabase] createApiKey failed:", e); }
   } else {
     platform.setApiKey(config.api_key);
   }
@@ -295,7 +296,7 @@ async function createApiKey(): Promise<string | null> {
     });
     if (error) return null;
     return rawKey;
-  } catch { return null; }
+  } catch (e) { console.error("[supabase] createApiKey failed:", e); return null; }
 }
 
 // ── Logout ──

package/src/platform/sync.ts

@@ -8,8 +8,11 @@ const pnlHistories: Map<string, number[]> = new Map();
 
 export class PlatformSync {
   private timer: ReturnType<typeof setInterval> | null = null;
+  private _polling = false;
 
   async start(intervalMs = 30000): Promise<void> {
+    if (this.timer) return; // Prevent duplicate timers
+
     const loggedIn = await isLoggedIn();
     if (!loggedIn && !platform.authenticated) return;
 
@@ -22,6 +25,8 @@ export class PlatformSync {
   }
 
   private async poll(): Promise<void> {
+    if (this._polling) return;
+    this._polling = true;
     try {
       const strategies = await platform.listStrategies();
 
@@ -88,8 +93,11 @@ export class PlatformSync {
       });
 
       store.update({ deployments, connection: "connected" });
-    } catch {
+    } catch (e) {
+      console.error("[sync] poll failed:", e);
       store.update({ connection: "disconnected" });
+    } finally {
+      this._polling = false;
     }
   }
 }

package/src/research/apis.ts

@@ -111,7 +111,7 @@ export async function gammaEvents(opts: { query?: string; limit?: number } = {})
 }
 
 export async function gammaEventDetail(slug: string): Promise<any> {
-  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const events = await get(`${GAMMA}/events?slug=${encodeURIComponent(slug)}`);
   const event = events?.[0];
   if (!event) throw new Error(`Event not found: ${slug}`);
 
@@ -149,7 +149,7 @@ export async function gammaEventDetail(slug: string): Promise<any> {
 }
 
 export async function clobPriceHistory(slug: string, interval = "1w", fidelity = 60): Promise<any> {
-  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const events = await get(`${GAMMA}/events?slug=${encodeURIComponent(slug)}`);
   const market = events?.[0]?.markets?.[0];
   if (!market) throw new Error(`Market not found: ${slug}`);
 
@@ -174,7 +174,7 @@ export async function clobPriceHistory(slug: string, interval = "1w", fidelity =
 }
 
 export async function clobOrderBook(slug: string, marketIndex = 0, outcomeIndex = 0): Promise<any> {
-  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const events = await get(`${GAMMA}/events?slug=${encodeURIComponent(slug)}`);
   const market = events?.[0]?.markets?.[marketIndex];
   if (!market) throw new Error(`Market not found: ${slug}`);
 
@@ -198,7 +198,7 @@ export async function clobOrderBook(slug: string, marketIndex = 0, outcomeIndex
 }
 
 export async function polymarketTrades(slug: string): Promise<any> {
-  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const events = await get(`${GAMMA}/events?slug=${encodeURIComponent(slug)}`);
   const market = events?.[0]?.markets?.[0];
   if (!market) throw new Error(`Market not found: ${slug}`);
 
@@ -233,27 +233,27 @@ export async function polymarketTrades(slug: string): Promise<any> {
 
 /** Get recent trades for a market (up to 500) */
 export async function getMarketTrades(conditionId: string, limit = 200): Promise<any[]> {
-  const data = await get(`${DATA_API}/trades?market=${conditionId}&limit=${Math.min(limit, 500)}`).catch(() => []);
+  const data = await get(`${DATA_API}/trades?market=${encodeURIComponent(conditionId)}&limit=${Math.min(limit, 500)}`).catch(() => []);
   return data ?? [];
 }
 
 /** Get trades for a specific wallet (up to 500) */
 export async function getWalletTrades(address: string, limit = 200, conditionId?: string): Promise<any[]> {
-  let url = `${DATA_API}/trades?maker_address=${address}&limit=${Math.min(limit, 500)}`;
-  if (conditionId) url += `&market=${conditionId}`;
+  let url = `${DATA_API}/trades?maker_address=${encodeURIComponent(address)}&limit=${Math.min(limit, 500)}`;
+  if (conditionId) url += `&market=${encodeURIComponent(conditionId)}`;
   const data = await get(url).catch(() => []);
   return data ?? [];
 }
 
 /** Get open positions for a wallet */
 export async function getWalletPositions(address: string, limit = 100): Promise<any[]> {
-  const data = await get(`${DATA_API}/positions?user=${address}&limit=${Math.min(limit, 500)}&sort_by=TOKENS`).catch(() => []);
+  const data = await get(`${DATA_API}/positions?user=${encodeURIComponent(address)}&limit=${Math.min(limit, 500)}&sort_by=TOKENS`).catch(() => []);
   return data ?? [];
 }
 
 /** Get wallet profile from Gamma API */
 export async function getWalletProfile(address: string): Promise<any> {
-  const data = await get(`${GAMMA}/users?address=${address}`).catch(() => null);
+  const data = await get(`${GAMMA}/users?address=${encodeURIComponent(address)}`).catch(() => null);
   const user = Array.isArray(data) ? data[0] : data;
   return user ? {
     address, name: user.pseudonym ?? user.name ?? "Anonymous",
@@ -264,7 +264,7 @@ export async function getWalletProfile(address: string): Promise<any> {
 
 /** Resolve market slug → conditionId */
 export async function resolveConditionId(slug: string): Promise<{ conditionId: string; title: string; market: any }> {
-  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const events = await get(`${GAMMA}/events?slug=${encodeURIComponent(slug)}`);
   const market = events?.[0]?.markets?.[0];
   if (!market) throw new Error(`Market not found: ${slug}`);
   return { conditionId: market.conditionId, title: events[0].title, market };
@@ -443,7 +443,7 @@ function formatKalshiEvent(e: any): any {
 }
 
 export async function kalshiEventDetail(ticker: string): Promise<any> {
-  const data = await get(`${KALSHI}/events/${ticker}?with_nested_markets=true`);
+  const data = await get(`${KALSHI}/events/${encodeURIComponent(ticker)}?with_nested_markets=true`);
   const event = data?.event ?? data;
   if (!event) throw new Error(`Kalshi event not found: ${ticker}`);
 
@@ -457,7 +457,7 @@ export async function kalshiEventDetail(ticker: string): Promise<any> {
 }
 
 export async function kalshiOrderBook(ticker: string): Promise<any> {
-  const book = await get(`${KALSHI}/markets/${ticker}/orderbook`);
+  const book = await get(`${KALSHI}/markets/${encodeURIComponent(ticker)}/orderbook`);
   const ob = book?.orderbook ?? {};
   // yes array: [[price_cents, size], ...] — bids for YES outcome
   // no array: [[price_cents, size], ...] — asks (complement pricing)
@@ -489,7 +489,7 @@ export async function kalshiPriceHistory(ticker: string, period = "1w"): Promise
   const intervalMap: Record<string, number> = { "1h": 1, "6h": 1, "1d": 60, "1w": 60, "1m": 1440, "max": 1440 };
   const periodInterval = intervalMap[period] ?? 60;
 
-  const data = await get(`${KALSHI}/markets/${ticker}/candlesticks?period_interval=${periodInterval}`).catch(() => ({ candlesticks: [] }));
+  const data = await get(`${KALSHI}/markets/${encodeURIComponent(ticker)}/candlesticks?period_interval=${periodInterval}`).catch(() => ({ candlesticks: [] }));
   const candles = data?.candlesticks ?? [];
 
   // Prices can be dollar strings or cent integers — normalize to decimal

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");
+}