@exagent/agent 0.3.3 → 0.3.4

package/dist/chunk-FOQYP3IB.js

@@ -1,2950 +0,0 @@
-// src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
-import { z } from "zod";
-var configSchema = z.object({
-  agentId: z.string(),
-  apiUrl: z.string().url(),
-  apiToken: z.string(),
-  wallet: z.object({
-    privateKey: z.string()
-  }).optional(),
-  llm: z.object({
-    provider: z.enum(["openai", "anthropic", "google", "deepseek", "mistral", "groq", "together", "ollama"]),
-    model: z.string().optional(),
-    apiKey: z.string().optional(),
-    endpoint: z.string().optional(),
-    temperature: z.number().min(0).max(2).optional(),
-    maxTokens: z.number().optional()
-  }),
-  strategy: z.object({
-    file: z.string().optional(),
-    template: z.string().optional()
-  }),
-  trading: z.object({
-    mode: z.enum(["live", "paper"]).default("paper"),
-    timeHorizon: z.enum(["intraday", "swing", "position"]).default("swing"),
-    maxPositionSizeBps: z.number().min(100).max(1e4).default(2e3),
-    maxDailyLossBps: z.number().min(0).max(1e4).default(500),
-    maxConcurrentPositions: z.number().min(1).max(100).default(5),
-    tradingIntervalMs: z.number().min(1e3).default(6e4),
-    maxSlippageBps: z.number().min(10).max(1e3).default(100),
-    minTradeValueUSD: z.number().min(0).default(10),
-    initialCapitalUSD: z.number().optional()
-  }),
-  venues: z.object({
-    hyperliquid_perp: z.object({
-      enabled: z.boolean().default(false),
-      apiUrl: z.string().default("https://api.hyperliquid.xyz"),
-      wsUrl: z.string().default("wss://api.hyperliquid.xyz/ws"),
-      maxLeverage: z.number().min(1).max(50).default(10),
-      maxNotionalUSD: z.number().default(5e4),
-      allowedInstruments: z.array(z.string()).optional()
-    }).optional(),
-    polymarket: z.object({
-      enabled: z.boolean().default(false),
-      clobApiUrl: z.string().default("https://clob.polymarket.com"),
-      gammaApiUrl: z.string().default("https://gamma-api.polymarket.com"),
-      maxNotionalUSD: z.number().default(1e3),
-      maxTotalExposureUSD: z.number().default(5e3),
-      allowedCategories: z.array(z.string()).optional()
-    }).optional()
-  }).optional(),
-  relay: z.object({
-    url: z.string(),
-    heartbeatIntervalMs: z.number().default(3e4),
-    reconnectMaxAttempts: z.number().default(50)
-  })
-});
-function loadConfig(path = "agent-config.json") {
-  if (!existsSync(path)) {
-    throw new Error(`Config file not found: ${path}. Run 'exagent init' first.`);
-  }
-  const raw = readFileSync(path, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${path}`);
-  }
-  const config = parsed;
-  const llm = config.llm || {};
-  if (process.env.EXAGENT_LLM_PROVIDER) llm.provider = process.env.EXAGENT_LLM_PROVIDER;
-  if (process.env.EXAGENT_LLM_MODEL) llm.model = process.env.EXAGENT_LLM_MODEL;
-  if (process.env.EXAGENT_LLM_API_KEY) llm.apiKey = process.env.EXAGENT_LLM_API_KEY;
-  if (process.env.EXAGENT_API_URL) config.apiUrl = process.env.EXAGENT_API_URL;
-  if (process.env.EXAGENT_API_TOKEN) config.apiToken = process.env.EXAGENT_API_TOKEN;
-  if (process.env.EXAGENT_WALLET_PRIVATE_KEY) {
-    config.wallet = { privateKey: process.env.EXAGENT_WALLET_PRIVATE_KEY };
-  }
-  config.llm = llm;
-  const result = configSchema.safeParse(config);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw new Error(`Invalid config:
-${issues}`);
-  }
-  return result.data;
-}
-function generateSampleConfig(agentId, apiUrl) {
-  const config = {
-    agentId,
-    apiUrl,
-    apiToken: "<your-jwt-token>",
-    wallet: {
-      privateKey: "<your-hex-private-key>"
-    },
-    llm: {
-      provider: "openai",
-      model: "gpt-4o",
-      apiKey: "<your-api-key>"
-    },
-    strategy: {
-      template: "momentum"
-    },
-    trading: {
-      mode: "paper",
-      timeHorizon: "swing",
-      maxPositionSizeBps: 2e3,
-      maxDailyLossBps: 500,
-      maxConcurrentPositions: 5,
-      tradingIntervalMs: 6e4,
-      maxSlippageBps: 100,
-      minTradeValueUSD: 10,
-      initialCapitalUSD: 1e4
-    },
-    venues: {
-      hyperliquid_perp: {
-        enabled: false,
-        apiUrl: "https://api.hyperliquid.xyz",
-        wsUrl: "wss://api.hyperliquid.xyz/ws",
-        maxLeverage: 10,
-        maxNotionalUSD: 5e4
-      },
-      polymarket: {
-        enabled: false,
-        clobApiUrl: "https://clob.polymarket.com",
-        gammaApiUrl: "https://gamma-api.polymarket.com",
-        maxNotionalUSD: 1e3,
-        maxTotalExposureUSD: 5e3
-      }
-    },
-    relay: {
-      url: apiUrl.replace(/^http/, "ws") + "/ws/agent",
-      heartbeatIntervalMs: 3e4,
-      reconnectMaxAttempts: 50
-    }
-  };
-  return JSON.stringify(config, null, 2);
-}
-function writeSampleConfig(agentId, apiUrl, path = "agent-config.json") {
-  writeFileSync(path, generateSampleConfig(agentId, apiUrl));
-}
-
-// src/relay.ts
-import WebSocket from "ws";
-var RelayClient = class {
-  ws = null;
-  config;
-  heartbeatTimer = null;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  intentionalClose = false;
-  authenticated = false;
-  lastStatus = null;
-  onCommand;
-  onConnected;
-  onDisconnected;
-  constructor(config) {
-    this.config = {
-      url: config.url,
-      agentId: config.agentId,
-      token: config.token,
-      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 3e4,
-      reconnectMaxAttempts: config.reconnectMaxAttempts ?? 50
-    };
-    this.onCommand = config.onCommand;
-    this.onConnected = config.onConnected;
-    this.onDisconnected = config.onDisconnected;
-  }
-  get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN && this.authenticated;
-  }
-  async connect() {
-    return new Promise((resolve2, reject) => {
-      try {
-        this.intentionalClose = false;
-        this.ws = new WebSocket(this.config.url);
-        const timeout = setTimeout(() => {
-          if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
-            this.ws.terminate();
-            reject(new Error("Connection timeout (15s)"));
-          }
-        }, 15e3);
-        this.ws.on("open", () => {
-          clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.authenticate();
-        });
-        this.ws.on("message", (data) => {
-          try {
-            const msg = JSON.parse(data.toString());
-            this.handleMessage(msg, resolve2);
-          } catch {
-            console.error("[relay] Failed to parse message");
-          }
-        });
-        this.ws.on("close", () => {
-          this.cleanup();
-          this.onDisconnected?.();
-          if (!this.intentionalClose) {
-            this.scheduleReconnect();
-          }
-        });
-        this.ws.on("error", (err) => {
-          console.error("[relay] WebSocket error:", err.message);
-          if (!this.authenticated) {
-            clearTimeout(timeout);
-            reject(err);
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-  disconnect() {
-    this.intentionalClose = true;
-    this.cleanup();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  authenticate() {
-    this.send({
-      type: "auth",
-      agentId: this.config.agentId,
-      token: this.config.token
-    });
-  }
-  handleMessage(msg, onAuth) {
-    switch (msg.type) {
-      case "auth_success":
-        this.authenticated = true;
-        this.startHeartbeat();
-        this.onConnected?.();
-        onAuth?.();
-        console.log(`[relay] Authenticated as agent ${this.config.agentId}`);
-        break;
-      case "auth_error":
-        console.error("[relay] Auth failed:", msg.error);
-        this.disconnect();
-        break;
-      case "command":
-        this.onCommand?.(msg.command);
-        break;
-      case "pong":
-        break;
-    }
-  }
-  send(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-  sendHeartbeat(status) {
-    this.lastStatus = status;
-    this.send({
-      type: "heartbeat",
-      agentId: this.config.agentId,
-      status,
-      timestamp: Date.now()
-    });
-  }
-  sendMessage(messageType, level, title, body, data) {
-    this.send({
-      type: "message",
-      agentId: this.config.agentId,
-      messageType,
-      level,
-      title,
-      body,
-      data,
-      timestamp: Date.now()
-    });
-  }
-  sendTradeSignal(signal) {
-    this.send({
-      type: "trade_signal",
-      agentId: this.config.agentId,
-      signal,
-      timestamp: Date.now()
-    });
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.lastStatus) {
-        this.sendHeartbeat(this.lastStatus);
-      }
-    }, this.config.heartbeatIntervalMs);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  cleanup() {
-    this.stopHeartbeat();
-    this.authenticated = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
-      console.error(`[relay] Max reconnect attempts (${this.config.reconnectMaxAttempts}) reached`);
-      return;
-    }
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-    this.reconnectAttempts++;
-    console.log(`[relay] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(async () => {
-      try {
-        await this.connect();
-      } catch (err) {
-        console.error("[relay] Reconnect failed:", err.message);
-      }
-    }, delay);
-  }
-};
-
-// src/signal.ts
-var SignalReporter = class {
-  relay;
-  constructor(relay) {
-    this.relay = relay;
-  }
-  reportTrade(signal) {
-    if (!this.relay.isConnected) {
-      console.warn("[signal] Not connected to relay \u2014 trade signal queued locally");
-      return;
-    }
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "trade_executed",
-      "success",
-      `${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} on ${signal.venue}`,
-      { signal }
-    );
-  }
-  reportPerpFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "perp_fill",
-      "success",
-      `Perp ${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} (${signal.leverage ?? 1}x)`,
-      { signal }
-    );
-  }
-  reportPredictionFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "prediction_fill",
-      "success",
-      `Prediction ${signal.side.toUpperCase()}`,
-      `${signal.side} $${signal.size.toFixed(2)} on ${signal.symbol} @ ${signal.price.toFixed(4)}`,
-      { signal }
-    );
-  }
-  reportError(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("error", "error", title, body, data);
-  }
-  reportInfo(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("info", "info", title, body, data);
-  }
-};
-
-// src/store.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
-import { dirname } from "path";
-var FileStore = class {
-  data = {};
-  filePath;
-  constructor(filePath = "data/strategy-store.json") {
-    this.filePath = filePath;
-    this.load();
-  }
-  load() {
-    try {
-      if (existsSync2(this.filePath)) {
-        const raw = readFileSync2(this.filePath, "utf-8");
-        this.data = JSON.parse(raw);
-      }
-    } catch {
-      this.data = {};
-    }
-  }
-  flush() {
-    const dir = dirname(this.filePath);
-    if (!existsSync2(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync2(this.filePath, JSON.stringify(this.data, null, 2));
-  }
-  get(key) {
-    return this.data[key];
-  }
-  set(key, value) {
-    this.data[key] = value;
-    this.flush();
-  }
-  delete(key) {
-    delete this.data[key];
-    this.flush();
-  }
-  keys() {
-    return Object.keys(this.data);
-  }
-};
-
-// src/position-tracker.ts
-var QUOTE_ASSETS = /* @__PURE__ */ new Set(["USDC", "USDbC", "DAI", "USDT", "EURC"]);
-var PERP_VENUES = /* @__PURE__ */ new Set(["hyperliquid_perp"]);
-var PREDICTION_VENUES = /* @__PURE__ */ new Set(["polymarket"]);
-var PositionTracker = class {
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  realizedPnL = 0;
-  store;
-  constructor(store) {
-    this.store = store;
-    this.load();
-  }
-  /** Build a unique position key: venue-scoped when venue is provided */
-  positionKey(token, venue) {
-    return venue ? `${venue}:${token}` : token;
-  }
-  load() {
-    const saved = this.store.get("position_tracker");
-    if (saved) {
-      this.positions = new Map(saved.positions);
-      this.trades = saved.trades;
-      this.realizedPnL = saved.realizedPnL;
-    }
-  }
-  save() {
-    this.store.set("position_tracker", {
-      positions: Array.from(this.positions.entries()),
-      trades: this.trades.slice(-1e3),
-      realizedPnL: this.realizedPnL
-    });
-  }
-  recordBuy(token, quantity, price, fee, venue, chain, venueFillId) {
-    const isPerp = venue ? PERP_VENUES.has(venue) : false;
-    const isPrediction = venue ? PREDICTION_VENUES.has(venue) : false;
-    if (!isPerp && !isPrediction && QUOTE_ASSETS.has(token)) return;
-    const key = this.positionKey(token, venue);
-    const existing = this.positions.get(key);
-    if (existing) {
-      if (isPerp && existing.quantity < 0) {
-        const closedQty = Math.min(quantity, Math.abs(existing.quantity));
-        const pnl = (existing.costBasisPerUnit - price) * closedQty - fee;
-        this.realizedPnL += pnl;
-        existing.quantity += quantity;
-        if (Math.abs(existing.quantity) <= 1e-6) {
-          this.positions.delete(key);
-        } else if (existing.quantity > 0) {
-          existing.costBasisPerUnit = price;
-        }
-      } else {
-        const totalQty = existing.quantity + quantity;
-        const totalCost = existing.costBasisPerUnit * existing.quantity + price * quantity;
-        existing.costBasisPerUnit = totalCost / totalQty;
-        existing.quantity = totalQty;
-      }
-    } else {
-      this.positions.set(key, {
-        token,
-        quantity,
-        costBasisPerUnit: price,
-        entryTimestamp: Date.now(),
-        venue,
-        chain
-      });
-    }
-    this.trades.push({
-      token,
-      action: "buy",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-  }
-  recordSell(token, quantity, price, fee, venue, chain, venueFillId) {
-    const isPerp = venue ? PERP_VENUES.has(venue) : false;
-    const isPrediction = venue ? PREDICTION_VENUES.has(venue) : false;
-    if (!isPerp && !isPrediction && QUOTE_ASSETS.has(token)) return;
-    const key = this.positionKey(token, venue);
-    const existing = this.positions.get(key);
-    if (existing) {
-      if (isPerp && existing.quantity > 0) {
-        const closedQty = Math.min(quantity, existing.quantity);
-        const pnl = (price - existing.costBasisPerUnit) * closedQty - fee;
-        this.realizedPnL += pnl;
-        existing.quantity -= quantity;
-        if (Math.abs(existing.quantity) <= 1e-6) {
-          this.positions.delete(key);
-        } else if (existing.quantity < 0) {
-          existing.costBasisPerUnit = price;
-        }
-      } else if (isPerp && existing.quantity <= 0) {
-        const totalQty = Math.abs(existing.quantity) + quantity;
-        const totalCost = existing.costBasisPerUnit * Math.abs(existing.quantity) + price * quantity;
-        existing.costBasisPerUnit = totalCost / totalQty;
-        existing.quantity -= quantity;
-      } else {
-        const pnl = (price - existing.costBasisPerUnit) * quantity - fee;
-        this.realizedPnL += pnl;
-        existing.quantity -= quantity;
-        if (existing.quantity <= 1e-6) {
-          this.positions.delete(key);
-        }
-      }
-    } else if (isPerp) {
-      this.positions.set(key, {
-        token,
-        quantity: -quantity,
-        costBasisPerUnit: price,
-        entryTimestamp: Date.now(),
-        venue,
-        chain
-      });
-    }
-    this.trades.push({
-      token,
-      action: "sell",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-  }
-  getSummary(prices) {
-    let totalUnrealizedPnL = 0;
-    const openPositions = Array.from(this.positions.values());
-    for (const pos of openPositions) {
-      const currentPrice = prices[pos.token];
-      if (currentPrice) {
-        if (pos.quantity >= 0) {
-          totalUnrealizedPnL += (currentPrice - pos.costBasisPerUnit) * pos.quantity;
-        } else {
-          totalUnrealizedPnL += (pos.costBasisPerUnit - currentPrice) * Math.abs(pos.quantity);
-        }
-      }
-    }
-    return {
-      openPositions,
-      totalUnrealizedPnL,
-      totalRealizedPnL: this.realizedPnL
-    };
-  }
-  getPositions() {
-    return Array.from(this.positions.values());
-  }
-  getTrades(limit) {
-    if (limit) return this.trades.slice(-limit);
-    return [...this.trades];
-  }
-  getRealizedPnL() {
-    return this.realizedPnL;
-  }
-  reset() {
-    this.positions.clear();
-    this.trades = [];
-    this.realizedPnL = 0;
-    this.save();
-  }
-};
-
-// src/llm/base.ts
-var BaseLLMAdapter = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  getTemperature() {
-    return this.config.temperature ?? 0.7;
-  }
-  getMaxTokens() {
-    return this.config.maxTokens ?? 4096;
-  }
-};
-
-// src/llm/openai.ts
-var OpenAIAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.openai.com/v1";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "gpt-4o",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`OpenAI API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "openai",
-      model: this.config.model || "gpt-4o"
-    };
-  }
-};
-
-// src/llm/anthropic.ts
-var AnthropicAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.anthropic.com";
-  }
-  async chat(messages) {
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      model: this.config.model || "claude-sonnet-4-20250514",
-      messages: nonSystemMessages.map((m) => ({ role: m.role, content: m.content })),
-      max_tokens: this.getMaxTokens(),
-      temperature: this.getTemperature()
-    };
-    if (systemMessage) {
-      body.system = systemMessage.content;
-    }
-    const res = await fetch(`${this.endpoint}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.config.apiKey || "",
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Anthropic API error ${res.status}: ${text}`);
-    }
-    const data = await res.json();
-    const textContent = data.content.find((c) => c.type === "text");
-    return {
-      content: textContent?.text || "",
-      tokens: data.usage ? { input: data.usage.input_tokens, output: data.usage.output_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "anthropic",
-      model: this.config.model || "claude-sonnet-4-20250514"
-    };
-  }
-};
-
-// src/llm/google.ts
-var GoogleAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const model = this.config.model || "gemini-2.5-flash";
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${this.config.apiKey}`;
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      contents: nonSystemMessages.map((m) => ({
-        role: m.role === "assistant" ? "model" : "user",
-        parts: [{ text: m.content }]
-      })),
-      generationConfig: {
-        temperature: this.getTemperature(),
-        maxOutputTokens: this.getMaxTokens()
-      }
-    };
-    if (systemMessage) {
-      body.systemInstruction = { parts: [{ text: systemMessage.content }] };
-    }
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`Google AI error ${res.status}: ${text2}`);
-    }
-    const data = await res.json();
-    const text = data.candidates[0]?.content?.parts[0]?.text || "";
-    return {
-      content: text,
-      tokens: data.usageMetadata ? { input: data.usageMetadata.promptTokenCount, output: data.usageMetadata.candidatesTokenCount } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "google",
-      model: this.config.model || "gemini-2.5-flash"
-    };
-  }
-};
-
-// src/llm/deepseek.ts
-var DeepSeekAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.deepseek.com/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "deepseek-chat",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`DeepSeek API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "deepseek",
-      model: this.config.model || "deepseek-chat"
-    };
-  }
-};
-
-// src/llm/mistral.ts
-var MistralAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.mistral.ai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "mistral-large-latest",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Mistral API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "mistral",
-      model: this.config.model || "mistral-large-latest"
-    };
-  }
-};
-
-// src/llm/groq.ts
-var GroqAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "llama-3.3-70b-versatile",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Groq API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "groq",
-      model: this.config.model || "llama-3.3-70b-versatile"
-    };
-  }
-};
-
-// src/llm/together.ts
-var TogetherAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.together.xyz/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Together API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "together",
-      model: this.config.model || "meta-llama/Llama-3.3-70B-Instruct-Turbo"
-    };
-  }
-};
-
-// src/llm/ollama.ts
-var OllamaAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "http://localhost:11434";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: this.config.model || "llama3.3",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        stream: false,
-        options: {
-          temperature: this.getTemperature(),
-          num_predict: this.getMaxTokens()
-        }
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Ollama error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.message?.content || "",
-      tokens: data.prompt_eval_count ? { input: data.prompt_eval_count, output: data.eval_count || 0 } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "ollama",
-      model: this.config.model || "llama3.3"
-    };
-  }
-};
-
-// src/llm/index.ts
-function createLLMAdapter(config) {
-  switch (config.provider) {
-    case "openai":
-      return new OpenAIAdapter(config);
-    case "anthropic":
-      return new AnthropicAdapter(config);
-    case "google":
-      return new GoogleAdapter(config);
-    case "deepseek":
-      return new DeepSeekAdapter(config);
-    case "mistral":
-      return new MistralAdapter(config);
-    case "groq":
-      return new GroqAdapter(config);
-    case "together":
-      return new TogetherAdapter(config);
-    case "ollama":
-      return new OllamaAdapter(config);
-    default:
-      throw new Error(`Unknown LLM provider: ${config.provider}`);
-  }
-}
-
-// src/strategy/templates.ts
-var templates = [
-  {
-    id: "momentum",
-    name: "Momentum Trader",
-    description: "Identifies tokens with strong upward price momentum and rides the trend. Uses LLM to analyze price action and market sentiment.",
-    category: "momentum",
-    venues: ["hyperliquid_perp", "hyperliquid_spot"],
-    riskLevel: "moderate",
-    systemPrompt: `You are a momentum trading agent. Analyze the provided market data and identify tokens with strong upward momentum.
-
-Rules:
-- Only trade tokens with clear directional momentum (avoid choppy markets)
-- Use trailing stops to protect gains
-- Size positions based on conviction (higher confidence = larger position)
-- Cut losses quickly if momentum reverses
-- Consider volume as confirmation of momentum
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a momentum trading agent. Analyze market data and return trade signals as a JSON array. Each signal: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if no opportunities.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nOpen positions: ' + JSON.stringify(positions.map(p => p.token)) + '\\nAnalyze for momentum opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "value",
-    name: "Value Investor",
-    description: "Identifies undervalued tokens based on fundamental analysis. Buys dips and holds for mean reversion.",
-    category: "value",
-    venues: ["hyperliquid_spot"],
-    riskLevel: "conservative",
-    systemPrompt: `You are a value investing agent. Identify tokens trading below their intrinsic value.
-
-Rules:
-- Focus on established tokens with strong fundamentals
-- Buy on significant dips (>10% from recent highs)
-- Hold positions longer (swing/position timeframe)
-- Avoid chasing pumps
-- Diversify across sectors
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a value investing agent. Identify undervalued tokens. Return trade signals as JSON array: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if nothing is compelling.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nPositions: ' + JSON.stringify(positions.map(p => ({ token: p.token, entry: p.costBasisPerUnit }))) + '\\nLook for value opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "arbitrage",
-    name: "Arbitrage Hunter",
-    description: "Scans for price discrepancies across venues and chains. Executes quickly to capture spreads.",
-    category: "arbitrage",
-    venues: ["hyperliquid_perp", "hyperliquid_spot", "uniswap", "aerodrome"],
-    riskLevel: "aggressive",
-    systemPrompt: `You are an arbitrage agent. Find price discrepancies between venues.
-
-Rules:
-- Speed is critical \u2014 execute quickly before spreads close
-- Account for fees and slippage in profitability calculations
-- Only trade when net profit > 0.5% after all costs
-- Monitor cross-chain opportunities (CEX vs DEX spreads)
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-
-const messages = [
-  { role: 'system', content: 'You are an arbitrage agent. Find price discrepancies. Return trade signals as JSON array: { symbol, side: "buy"|"sell", venue, confidence: 0-1, reasoning }. Return [] if no arb opportunities.' },
-  { role: 'user', content: 'Market prices: ' + JSON.stringify(prices) + '\\nScan for cross-venue arbitrage opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "hold",
-    name: "Hold (No Trading)",
-    description: "Passive strategy that makes no trades. Useful for monitoring only.",
-    category: "custom",
-    venues: [],
-    riskLevel: "conservative",
-    systemPrompt: "",
-    code: `return [];`
-  }
-];
-function getTemplate(id) {
-  return templates.find((t) => t.id === id);
-}
-function listTemplates() {
-  return [...templates];
-}
-
-// src/strategy/loader.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-async function loadStrategy(config) {
-  if (config.file) {
-    return loadFromFile(config.file);
-  }
-  if (config.template) {
-    const template = getTemplate(config.template);
-    if (!template) {
-      throw new Error(`Unknown strategy template: ${config.template}. Available: momentum, value, arbitrage, hold`);
-    }
-    return loadFromCode(template.code);
-  }
-  return holdStrategy;
-}
-async function loadFromFile(filePath) {
-  const resolved = resolve(filePath);
-  if (!existsSync3(resolved)) {
-    throw new Error(`Strategy file not found: ${resolved}`);
-  }
-  try {
-    const mod = await import(resolved);
-    const fn = mod.default || mod.strategy;
-    if (typeof fn !== "function") {
-      throw new Error(`Strategy file must export a default function or 'strategy' function`);
-    }
-    return fn;
-  } catch (err) {
-    throw new Error(`Failed to load strategy from ${resolved}: ${err.message}`);
-  }
-}
-async function loadFromCode(code) {
-  const AsyncFunction = Object.getPrototypeOf(async function() {
-  }).constructor;
-  const fn = new AsyncFunction("context", code);
-  return fn;
-}
-var holdStrategy = async (_context) => {
-  return [];
-};
-
-// src/trading/risk.ts
-var RiskManager = class {
-  params;
-  dailyPnL = 0;
-  dailyFees = 0;
-  lastResetDate = "";
-  initialCapitalUSD;
-  constructor(params, initialCapitalUSD = 1e4) {
-    this.params = params;
-    this.initialCapitalUSD = initialCapitalUSD;
-    this.resetIfNewDay();
-  }
-  filterSignals(signals, market, openPositionCount) {
-    this.resetIfNewDay();
-    if (this.isDailyLossLimitHit()) {
-      console.log("[risk] Daily loss limit hit \u2014 blocking all trades");
-      return [];
-    }
-    return signals.filter((signal) => this.validateSignal(signal, market, openPositionCount));
-  }
-  validateSignal(signal, market, openPositionCount) {
-    const threshold = this.params.confidenceThreshold ?? 0.5;
-    if (signal.confidence !== void 0 && signal.confidence < threshold) {
-      console.log(`[risk] Blocked ${signal.symbol}: confidence ${signal.confidence} < ${threshold}`);
-      return false;
-    }
-    const tradeValue = signal.size * signal.price;
-    const maxPositionValue = this.params.maxPositionSizeBps / 1e4 * this.initialCapitalUSD;
-    if (tradeValue > maxPositionValue) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(0)} > max $${maxPositionValue.toFixed(0)}`);
-      return false;
-    }
-    if (tradeValue < this.params.minTradeValueUSD) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(2)} < min $${this.params.minTradeValueUSD}`);
-      return false;
-    }
-    if ((signal.side === "buy" || signal.side === "long") && openPositionCount >= this.params.maxConcurrentPositions) {
-      console.log(`[risk] Blocked ${signal.symbol}: ${openPositionCount} positions >= max ${this.params.maxConcurrentPositions}`);
-      return false;
-    }
-    if (signal.orderType === "market") {
-      const currentPrice = market.getPrice(signal.symbol);
-      if (currentPrice) {
-        const slippageBps = Math.abs(signal.price - currentPrice) / currentPrice * 1e4;
-        if (slippageBps > this.params.maxSlippageBps) {
-          console.log(`[risk] Blocked ${signal.symbol}: slippage ${slippageBps.toFixed(0)}bps > max ${this.params.maxSlippageBps}bps`);
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  recordTrade(pnl, fee) {
-    this.dailyPnL += pnl;
-    this.dailyFees += fee;
-  }
-  isDailyLossLimitHit() {
-    const limit = this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-    return this.dailyPnL < -limit;
-  }
-  getDailyPnL() {
-    return this.dailyPnL;
-  }
-  getDailyLossLimit() {
-    return this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-  }
-  resetIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (today !== this.lastResetDate) {
-      this.dailyPnL = 0;
-      this.dailyFees = 0;
-      this.lastResetDate = today;
-    }
-  }
-};
-
-// src/trading/market.ts
-var MarketDataService = class {
-  prices = {};
-  lastFetch = 0;
-  cacheTTL;
-  constructor(cacheTTLMs = 3e4) {
-    this.cacheTTL = cacheTTLMs;
-  }
-  async refreshPrices(symbols) {
-    if (symbols.length === 0) return this.prices;
-    const now = Date.now();
-    if (now - this.lastFetch < this.cacheTTL && Object.keys(this.prices).length > 0) {
-      return this.prices;
-    }
-    try {
-      const ids = symbols.map((s) => s.toLowerCase()).join(",");
-      const res = await fetch(
-        `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd`
-      );
-      if (res.ok) {
-        const data = await res.json();
-        for (const [id, price] of Object.entries(data)) {
-          this.prices[id.toUpperCase()] = price.usd;
-        }
-        this.lastFetch = now;
-      }
-    } catch (err) {
-      console.warn("[market] Price fetch failed:", err.message);
-    }
-    return this.prices;
-  }
-  getPrice(symbol) {
-    return this.prices[symbol.toUpperCase()];
-  }
-  getPrices() {
-    return { ...this.prices };
-  }
-  setPrice(symbol, price) {
-    this.prices[symbol.toUpperCase()] = price;
-  }
-  setPrices(prices) {
-    for (const [symbol, price] of Object.entries(prices)) {
-      this.prices[symbol.toUpperCase()] = price;
-    }
-  }
-  getOHLCV(_symbol, _timeframe) {
-    return [];
-  }
-};
-
-// src/paper/executor.ts
-import { randomUUID } from "crypto";
-var PaperExecutor = class {
-  cash;
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  equityCurve = [];
-  slippageBps;
-  feeRate;
-  peakEquity;
-  maxDrawdown = 0;
-  constructor(initialCash = 1e4, slippageBps = 50, feeRate = 2e-3) {
-    this.cash = initialCash;
-    this.slippageBps = slippageBps;
-    this.feeRate = feeRate;
-    this.peakEquity = initialCash;
-    this.recordEquity();
-  }
-  execute(signal, market) {
-    const marketPrice = market.getPrice(signal.symbol);
-    if (!marketPrice) {
-      console.warn(`[paper] No price for ${signal.symbol}`);
-      return null;
-    }
-    const isBuy = signal.side === "buy" || signal.side === "long";
-    const slippage = this.slippageBps / 1e4 * marketPrice;
-    const executedPrice = isBuy ? marketPrice + slippage : marketPrice - slippage;
-    const fee = signal.size * executedPrice * this.feeRate;
-    if (isBuy) {
-      const totalCost = signal.size * executedPrice + fee;
-      if (totalCost > this.cash) {
-        console.warn(`[paper] Insufficient funds: need $${totalCost.toFixed(2)}, have $${this.cash.toFixed(2)}`);
-        return null;
-      }
-      this.cash -= totalCost;
-      const existing = this.positions.get(signal.symbol);
-      if (existing) {
-        const totalQty = existing.quantity + signal.size;
-        existing.avgPrice = (existing.avgPrice * existing.quantity + executedPrice * signal.size) / totalQty;
-        existing.quantity = totalQty;
-      } else {
-        this.positions.set(signal.symbol, { quantity: signal.size, avgPrice: executedPrice });
-      }
-    } else {
-      const existing = this.positions.get(signal.symbol);
-      if (!existing || existing.quantity < signal.size) {
-        console.warn(`[paper] No position to sell: ${signal.symbol}`);
-        return null;
-      }
-      const proceeds = signal.size * executedPrice - fee;
-      this.cash += proceeds;
-      existing.quantity -= signal.size;
-      if (existing.quantity <= 1e-6) {
-        this.positions.delete(signal.symbol);
-      }
-    }
-    const trade = {
-      id: randomUUID(),
-      symbol: signal.symbol,
-      side: isBuy ? "buy" : "sell",
-      size: signal.size,
-      entryPrice: executedPrice,
-      fee,
-      timestamp: Date.now(),
-      venue: `paper_${signal.venue}`
-    };
-    this.trades.push(trade);
-    this.recordEquity();
-    return trade;
-  }
-  recordEquity() {
-    const equity = this.getEquity();
-    this.equityCurve.push({ timestamp: Date.now(), equity });
-    if (equity > this.peakEquity) this.peakEquity = equity;
-    const drawdown = (this.peakEquity - equity) / this.peakEquity;
-    if (drawdown > this.maxDrawdown) this.maxDrawdown = drawdown;
-  }
-  getEquity() {
-    let positionValue = 0;
-    for (const [, pos] of this.positions) {
-      positionValue += pos.quantity * pos.avgPrice;
-    }
-    return this.cash + positionValue;
-  }
-  getCash() {
-    return this.cash;
-  }
-  getPositions() {
-    return new Map(this.positions);
-  }
-  getTrades() {
-    return [...this.trades];
-  }
-  getEquityCurve() {
-    return [...this.equityCurve];
-  }
-  getMetrics() {
-    const initialEquity = this.equityCurve[0]?.equity || 0;
-    const currentEquity = this.getEquity();
-    const totalReturn = initialEquity > 0 ? (currentEquity - initialEquity) / initialEquity : 0;
-    const dailyReturns = this.calculateDailyReturns();
-    const sharpeRatio = this.calculateSharpe(dailyReturns);
-    let wins = 0;
-    let losses = 0;
-    let grossProfit = 0;
-    let grossLoss = 0;
-    const sellTrades = this.trades.filter((t) => t.side === "sell");
-    for (const sell of sellTrades) {
-      const buyTrades = this.trades.filter((t) => t.side === "buy" && t.symbol === sell.symbol);
-      const avgEntry = buyTrades.reduce((sum, t) => sum + t.entryPrice, 0) / (buyTrades.length || 1);
-      const pnl = (sell.entryPrice - avgEntry) * sell.size - sell.fee;
-      if (pnl > 0) {
-        wins++;
-        grossProfit += pnl;
-      } else {
-        losses++;
-        grossLoss += Math.abs(pnl);
-      }
-    }
-    return {
-      totalReturn,
-      sharpeRatio,
-      maxDrawdown: this.maxDrawdown,
-      winRate: wins + losses > 0 ? wins / (wins + losses) : 0,
-      profitFactor: grossLoss > 0 ? grossProfit / grossLoss : grossProfit > 0 ? Infinity : 0,
-      totalTrades: this.trades.length
-    };
-  }
-  calculateDailyReturns() {
-    if (this.equityCurve.length < 2) return [];
-    const dailyEquity = /* @__PURE__ */ new Map();
-    for (const point of this.equityCurve) {
-      const date = new Date(point.timestamp).toISOString().slice(0, 10);
-      dailyEquity.set(date, point.equity);
-    }
-    const dates = Array.from(dailyEquity.keys()).sort();
-    const returns = [];
-    for (let i = 1; i < dates.length; i++) {
-      const prev = dailyEquity.get(dates[i - 1]);
-      const curr = dailyEquity.get(dates[i]);
-      if (prev > 0) returns.push((curr - prev) / prev);
-    }
-    return returns;
-  }
-  calculateSharpe(returns) {
-    if (returns.length < 2) return 0;
-    const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
-    const variance = returns.reduce((sum, r) => sum + (r - mean) ** 2, 0) / (returns.length - 1);
-    const std = Math.sqrt(variance);
-    if (std === 0) return 0;
-    return mean / std * Math.sqrt(365);
-  }
-};
-
-// src/perp/client.ts
-var HyperliquidClient = class {
-  apiUrl;
-  meta = null;
-  assetIndexCache = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.apiUrl = config.apiUrl;
-  }
-  // ── INFO API (read-only) ───────────────────────────────────
-  async getMeta() {
-    if (this.meta) return this.meta;
-    const resp = await this.infoRequest({ type: "meta" });
-    this.meta = resp.universe;
-    this.meta.forEach((asset, idx) => {
-      this.assetIndexCache.set(asset.name, idx);
-    });
-    return this.meta;
-  }
-  async getAssetIndex(coin) {
-    if (this.assetIndexCache.has(coin)) return this.assetIndexCache.get(coin);
-    await this.getMeta();
-    const idx = this.assetIndexCache.get(coin);
-    if (idx === void 0) throw new Error(`Unknown instrument: ${coin}`);
-    return idx;
-  }
-  async getAllMids() {
-    return this.infoRequest({ type: "allMids" });
-  }
-  async getClearinghouseState(user) {
-    return this.infoRequest({ type: "clearinghouseState", user });
-  }
-  async getUserFills(user, startTime) {
-    return this.infoRequest({
-      type: "userFills",
-      user,
-      ...startTime !== void 0 && { startTime }
-    });
-  }
-  async getUserFillsByTime(user, startTime, endTime) {
-    return this.infoRequest({
-      type: "userFillsByTime",
-      user,
-      startTime,
-      ...endTime !== void 0 && { endTime }
-    });
-  }
-  async getOpenOrders(user) {
-    return this.infoRequest({ type: "openOrders", user });
-  }
-  async getL2Book(coin, depth) {
-    return this.infoRequest({
-      type: "l2Book",
-      coin,
-      ...depth !== void 0 && { nSigFigs: depth }
-    });
-  }
-  // ── HIGH-LEVEL HELPERS ─────────────────────────────────────
-  async getPositions(user) {
-    const state = await this.getClearinghouseState(user);
-    return state.assetPositions.filter((p) => parseFloat(p.position.szi) !== 0).map((p) => this.parsePosition(p));
-  }
-  async getAccountSummary(user) {
-    const state = await this.getClearinghouseState(user);
-    const cms = state.crossMarginSummary;
-    const totalEquity = parseFloat(cms.accountValue);
-    const totalNotional = parseFloat(cms.totalNtlPos);
-    const totalMarginUsed = parseFloat(cms.totalMarginUsed);
-    return {
-      totalEquity,
-      availableMargin: totalEquity - totalMarginUsed,
-      totalMarginUsed,
-      totalUnrealizedPnl: parseFloat(cms.totalRawUsd) - totalEquity,
-      totalNotional,
-      maintenanceMargin: totalMarginUsed * 0.5,
-      effectiveLeverage: totalEquity > 0 ? totalNotional / totalEquity : 0,
-      cashBalance: parseFloat(cms.accountValue) - state.assetPositions.reduce(
-        (sum, p) => sum + parseFloat(p.position.unrealizedPnl),
-        0
-      )
-    };
-  }
-  async getMarketData(instruments) {
-    const mids = await this.getAllMids();
-    return instruments.filter((inst) => mids[inst] !== void 0).map((inst) => ({
-      instrument: inst,
-      midPrice: parseFloat(mids[inst]),
-      bestBid: parseFloat(mids[inst]),
-      bestAsk: parseFloat(mids[inst]),
-      funding8h: 0,
-      openInterest: 0,
-      volume24h: 0,
-      priceChange24h: 0
-    }));
-  }
-  parseFill(fill) {
-    return {
-      oid: fill.oid,
-      coin: fill.coin,
-      side: fill.side,
-      px: fill.px,
-      sz: fill.sz,
-      fee: fill.fee,
-      time: fill.time,
-      hash: fill.hash,
-      isMaker: fill.startPosition !== fill.px,
-      builderFee: fill.builderFee,
-      liquidation: fill.liquidation
-    };
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  parsePosition(ap) {
-    const pos = ap.position;
-    const size = parseFloat(pos.szi);
-    const entryPrice = parseFloat(pos.entryPx || "0");
-    const markPrice = parseFloat(pos.positionValue || "0") / Math.abs(size || 1);
-    return {
-      instrument: pos.coin,
-      assetIndex: this.assetIndexCache.get(pos.coin) ?? -1,
-      size,
-      entryPrice,
-      markPrice,
-      unrealizedPnl: parseFloat(pos.unrealizedPnl),
-      leverage: parseFloat(pos.leverage?.value || "1"),
-      marginType: pos.leverage?.type === "isolated" ? "isolated" : "cross",
-      liquidationPrice: parseFloat(pos.liquidationPx || "0"),
-      notionalUSD: Math.abs(size) * markPrice,
-      marginUsed: parseFloat(pos.marginUsed)
-    };
-  }
-  async infoRequest(body) {
-    const resp = await fetch(`${this.apiUrl}/info`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      throw new Error(`Hyperliquid Info API error: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-};
-
-// src/perp/signer.ts
-var HYPERLIQUID_DOMAIN = {
-  name: "HyperliquidSignTransaction",
-  version: "1",
-  chainId: 42161n,
-  verifyingContract: "0x0000000000000000000000000000000000000000"
-};
-var HYPERLIQUID_TYPES = {
-  HyperliquidTransaction: [
-    { name: "hyperliquidChain", type: "string" },
-    { name: "action", type: "string" },
-    { name: "nonce", type: "uint64" }
-  ]
-};
-var lastNonce = 0n;
-function getNextNonce() {
-  const now = BigInt(Date.now());
-  if (now <= lastNonce) {
-    lastNonce = lastNonce + 1n;
-  } else {
-    lastNonce = now;
-  }
-  return lastNonce;
-}
-var HyperliquidSigner = class {
-  constructor(walletClient) {
-    this.walletClient = walletClient;
-  }
-  async signAction(action, nonce) {
-    const actionNonce = nonce ?? getNextNonce();
-    const actionStr = JSON.stringify(action);
-    const account = this.walletClient.account;
-    if (!account) throw new Error("Wallet client has no account");
-    const signature = await this.walletClient.signTypedData({
-      account,
-      domain: HYPERLIQUID_DOMAIN,
-      types: HYPERLIQUID_TYPES,
-      primaryType: "HyperliquidTransaction",
-      message: {
-        hyperliquidChain: "Mainnet",
-        action: actionStr,
-        nonce: actionNonce
-      }
-    });
-    return { signature, nonce: actionNonce };
-  }
-  getAddress() {
-    const account = this.walletClient.account;
-    if (!account) throw new Error("Wallet client has no account");
-    return account.address;
-  }
-};
-
-// src/perp/orders.ts
-var HyperliquidOrderManager = class {
-  client;
-  signer;
-  config;
-  constructor(client, signer, config) {
-    this.client = client;
-    this.signer = signer;
-    this.config = config;
-  }
-  async placeOrder(signal) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(signal.instrument);
-      const isBuy = signal.action === "open_long" || signal.action === "close_short";
-      const orderWire = {
-        a: assetIndex,
-        b: isBuy,
-        p: signal.orderType === "market" ? this.getMarketPrice(signal) : signal.price.toString(),
-        s: signal.size.toString(),
-        r: signal.reduceOnly,
-        t: signal.orderType === "market" ? { limit: { tif: "Ioc" } } : { limit: { tif: "Gtc" } }
-      };
-      const action = {
-        type: "order",
-        orders: [orderWire],
-        grouping: "na"
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      const resp = await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      return this.parseOrderResponse(resp);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Order failed for ${signal.instrument}:`, message);
-      return { success: false, status: "error", error: message };
-    }
-  }
-  async cancelOrder(instrument, orderId) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(instrument);
-      const action = {
-        type: "cancel",
-        cancels: [{ a: assetIndex, o: orderId }]
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      console.log(`[perp] Cancelled order ${orderId} for ${instrument}`);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Cancel failed for order ${orderId}:`, message);
-      return false;
-    }
-  }
-  async closePosition(instrument, positionSize) {
-    const isLong = positionSize > 0;
-    return this.placeOrder({
-      action: isLong ? "close_long" : "close_short",
-      instrument,
-      size: Math.abs(positionSize),
-      price: 0,
-      leverage: 1,
-      orderType: "market",
-      reduceOnly: true,
-      confidence: 1,
-      reasoning: "Position close"
-    });
-  }
-  async updateLeverage(instrument, leverage, isCross = true) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(instrument);
-      const action = {
-        type: "updateLeverage",
-        asset: assetIndex,
-        isCross,
-        leverage
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      console.log(`[perp] Leverage set for ${instrument}: ${leverage}x (${isCross ? "cross" : "isolated"})`);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Leverage update failed for ${instrument}:`, message);
-      return false;
-    }
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  getMarketPrice(signal) {
-    const isBuy = signal.action === "open_long" || signal.action === "close_short";
-    if (signal.price > 0) {
-      const slippage = isBuy ? 1.005 : 0.995;
-      return (signal.price * slippage).toString();
-    }
-    return "0";
-  }
-  parseOrderResponse(resp) {
-    if (resp?.status === "ok" && resp?.response?.type === "order") {
-      const statuses = resp.response.data?.statuses || [];
-      if (statuses.length > 0) {
-        const status = statuses[0];
-        if (status.filled) {
-          return {
-            success: true,
-            orderId: status.filled.oid,
-            status: "filled",
-            avgPrice: status.filled.avgPx,
-            filledSize: status.filled.totalSz
-          };
-        }
-        if (status.resting) {
-          return {
-            success: true,
-            orderId: status.resting.oid,
-            status: "resting"
-          };
-        }
-        if (status.error) {
-          return { success: false, status: "error", error: status.error };
-        }
-      }
-    }
-    return {
-      success: false,
-      status: "error",
-      error: `Unexpected response: ${JSON.stringify(resp)}`
-    };
-  }
-  async exchangeRequest(body) {
-    const resp = await fetch(`${this.config.apiUrl}/exchange`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      throw new Error(`Hyperliquid Exchange API error: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-};
-
-// src/perp/positions.ts
-var HyperliquidPositionManager = class {
-  client;
-  userAddress;
-  cachedPositions = [];
-  cachedAccount = null;
-  lastRefreshAt = 0;
-  cacheTtlMs = 5e3;
-  constructor(client, userAddress) {
-    this.client = client;
-    this.userAddress = userAddress;
-  }
-  // ── POSITION QUERIES ───────────────────────────────────────
-  async getPositions(forceRefresh = false) {
-    if (!forceRefresh && this.isCacheFresh()) return this.cachedPositions;
-    await this.refresh();
-    return this.cachedPositions;
-  }
-  async getPosition(instrument) {
-    const positions = await this.getPositions();
-    return positions.find((p) => p.instrument === instrument) ?? null;
-  }
-  async getAccountSummary(forceRefresh = false) {
-    if (!forceRefresh && this.isCacheFresh() && this.cachedAccount) {
-      return this.cachedAccount;
-    }
-    await this.refresh();
-    return this.cachedAccount;
-  }
-  // ── LIQUIDATION MONITORING ─────────────────────────────────
-  async getLiquidationProximity() {
-    const positions = await this.getPositions();
-    const proximities = /* @__PURE__ */ new Map();
-    for (const pos of positions) {
-      if (pos.liquidationPrice <= 0 || pos.markPrice <= 0) {
-        proximities.set(pos.instrument, 0);
-        continue;
-      }
-      let proximity;
-      if (pos.size > 0) {
-        if (pos.markPrice <= pos.liquidationPrice) {
-          proximity = 1;
-        } else {
-          const distanceToLiq = pos.markPrice - pos.liquidationPrice;
-          const entryToLiq = pos.entryPrice - pos.liquidationPrice;
-          proximity = entryToLiq > 0 ? 1 - distanceToLiq / entryToLiq : 0;
-        }
-      } else {
-        if (pos.markPrice >= pos.liquidationPrice) {
-          proximity = 1;
-        } else {
-          const distanceToLiq = pos.liquidationPrice - pos.markPrice;
-          const entryToLiq = pos.liquidationPrice - pos.entryPrice;
-          proximity = entryToLiq > 0 ? 1 - distanceToLiq / entryToLiq : 0;
-        }
-      }
-      proximities.set(pos.instrument, Math.max(0, Math.min(1, proximity)));
-    }
-    return proximities;
-  }
-  async getDangerousPositions(threshold = 0.7) {
-    const positions = await this.getPositions();
-    const proximities = await this.getLiquidationProximity();
-    return positions.filter((p) => (proximities.get(p.instrument) ?? 0) > threshold);
-  }
-  // ── SUMMARY HELPERS ────────────────────────────────────────
-  async getTotalUnrealizedPnl() {
-    const positions = await this.getPositions();
-    return positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
-  }
-  async getTotalNotional() {
-    const positions = await this.getPositions();
-    return positions.reduce((sum, p) => sum + p.notionalUSD, 0);
-  }
-  async getPositionCount() {
-    return (await this.getPositions()).length;
-  }
-  // ── CACHE ──────────────────────────────────────────────────
-  async refresh() {
-    try {
-      const [positions, account] = await Promise.all([
-        this.client.getPositions(this.userAddress),
-        this.client.getAccountSummary(this.userAddress)
-      ]);
-      this.cachedPositions = positions;
-      this.cachedAccount = account;
-      this.lastRefreshAt = Date.now();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error("[perp] Failed to refresh positions:", message);
-    }
-  }
-  isCacheFresh() {
-    return Date.now() - this.lastRefreshAt < this.cacheTtlMs;
-  }
-};
-
-// src/perp/websocket.ts
-import WebSocket2 from "ws";
-var HyperliquidWebSocket = class {
-  wsUrl;
-  userAddress;
-  client;
-  ws = null;
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 20;
-  baseReconnectMs = 1e3;
-  maxReconnectMs = 6e4;
-  reconnectTimer = null;
-  pingTimer = null;
-  isConnecting = false;
-  shouldReconnect = true;
-  lastProcessedFillTime = 0;
-  onFill = null;
-  onFunding = null;
-  onLiquidation = null;
-  constructor(config, userAddress, client) {
-    this.wsUrl = config.wsUrl;
-    this.userAddress = userAddress;
-    this.client = client;
-  }
-  // ── CONNECTION ─────────────────────────────────────────────
-  async connect() {
-    if (this.ws?.readyState === WebSocket2.OPEN || this.isConnecting) return;
-    this.isConnecting = true;
-    this.shouldReconnect = true;
-    return new Promise((resolve2, reject) => {
-      try {
-        this.ws = new WebSocket2(this.wsUrl);
-        this.ws.on("open", () => {
-          this.isConnecting = false;
-          this.reconnectAttempts = 0;
-          console.log("[perp-ws] Connected");
-          this.subscribe({
-            type: "subscribe",
-            subscription: { type: "userFills", user: this.userAddress }
-          });
-          this.subscribe({
-            type: "subscribe",
-            subscription: { type: "userFundings", user: this.userAddress }
-          });
-          this.startPing();
-          this.backfillMissedFills().catch((err) => {
-            console.warn("[perp-ws] Backfill failed:", err instanceof Error ? err.message : err);
-          });
-          resolve2();
-        });
-        this.ws.on("message", (data) => {
-          this.handleMessage(data);
-        });
-        this.ws.on("close", (code, reason) => {
-          this.isConnecting = false;
-          console.log(`[perp-ws] Closed: ${code} ${reason.toString()}`);
-          this.stopPing();
-          this.scheduleReconnect();
-        });
-        this.ws.on("error", (error) => {
-          this.isConnecting = false;
-          console.error("[perp-ws] Error:", error.message);
-          if (this.reconnectAttempts === 0) reject(error);
-        });
-      } catch (error) {
-        this.isConnecting = false;
-        reject(error);
-      }
-    });
-  }
-  disconnect() {
-    this.shouldReconnect = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.stopPing();
-    if (this.ws) {
-      this.ws.removeAllListeners();
-      if (this.ws.readyState === WebSocket2.OPEN) {
-        this.ws.close(1e3, "Client disconnect");
-      }
-      this.ws = null;
-    }
-    console.log("[perp-ws] Disconnected");
-  }
-  get isConnected() {
-    return this.ws?.readyState === WebSocket2.OPEN;
-  }
-  // ── EVENT HANDLERS ─────────────────────────────────────────
-  onFillReceived(callback) {
-    this.onFill = callback;
-  }
-  onFundingReceived(callback) {
-    this.onFunding = callback;
-  }
-  onLiquidationDetected(callback) {
-    this.onLiquidation = callback;
-  }
-  getLastProcessedFillTime() {
-    return this.lastProcessedFillTime;
-  }
-  // ── MESSAGE HANDLING ───────────────────────────────────────
-  handleMessage(data) {
-    try {
-      const msg = JSON.parse(data.toString());
-      if (msg.channel === "userFills") {
-        this.handleFillMessage(msg.data);
-      } else if (msg.channel === "userFundings") {
-        this.handleFundingMessage(msg.data);
-      }
-    } catch {
-    }
-  }
-  handleFillMessage(fills) {
-    if (!Array.isArray(fills) || !this.onFill) return;
-    for (const rawFill of fills) {
-      const fill = this.client.parseFill(rawFill);
-      if (fill.time > this.lastProcessedFillTime) {
-        this.lastProcessedFillTime = fill.time;
-      }
-      if (fill.liquidation && this.onLiquidation) {
-        this.onLiquidation(fill.coin, parseFloat(fill.sz));
-      }
-      this.onFill(fill);
-    }
-  }
-  handleFundingMessage(fundings) {
-    if (!Array.isArray(fundings) || !this.onFunding) return;
-    for (const funding of fundings) {
-      this.onFunding({
-        time: funding.time,
-        coin: funding.coin,
-        usdc: funding.usdc,
-        szi: funding.szi,
-        fundingRate: funding.fundingRate
-      });
-    }
-  }
-  // ── BACKFILL ───────────────────────────────────────────────
-  async backfillMissedFills() {
-    if (this.lastProcessedFillTime === 0 || !this.onFill) return;
-    console.log(`[perp-ws] Backfilling fills since ${new Date(this.lastProcessedFillTime).toISOString()}`);
-    const fills = await this.client.getUserFillsByTime(
-      this.userAddress,
-      this.lastProcessedFillTime + 1
-    );
-    if (fills.length > 0) {
-      console.log(`[perp-ws] Backfilled ${fills.length} missed fills`);
-      for (const rawFill of fills) {
-        const fill = this.client.parseFill(rawFill);
-        if (fill.time > this.lastProcessedFillTime) {
-          this.lastProcessedFillTime = fill.time;
-        }
-        if (fill.liquidation && this.onLiquidation) {
-          this.onLiquidation(fill.coin, parseFloat(fill.sz));
-        }
-        this.onFill(fill);
-      }
-    }
-  }
-  // ── RECONNECTION ───────────────────────────────────────────
-  scheduleReconnect() {
-    if (!this.shouldReconnect || this.reconnectAttempts >= this.maxReconnectAttempts) {
-      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-        console.error(`[perp-ws] Max reconnect attempts (${this.maxReconnectAttempts}) reached`);
-      }
-      return;
-    }
-    const delay = Math.min(
-      this.baseReconnectMs * Math.pow(2, this.reconnectAttempts),
-      this.maxReconnectMs
-    );
-    this.reconnectAttempts++;
-    console.log(`[perp-ws] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.connect().catch((err) => {
-        console.error("[perp-ws] Reconnect failed:", err instanceof Error ? err.message : err);
-      });
-    }, delay);
-  }
-  // ── KEEPALIVE ──────────────────────────────────────────────
-  startPing() {
-    this.stopPing();
-    this.pingTimer = setInterval(() => {
-      if (this.ws?.readyState === WebSocket2.OPEN) {
-        this.ws.send(JSON.stringify({ method: "ping" }));
-      }
-    }, 25e3);
-  }
-  stopPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-  }
-  // ── HELPERS ────────────────────────────────────────────────
-  subscribe(msg) {
-    if (this.ws?.readyState === WebSocket2.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-};
-
-// src/prediction/types.ts
-var DEFAULT_PREDICTION_CONFIG = {
-  enabled: false,
-  clobApiUrl: "https://clob.polymarket.com",
-  gammaApiUrl: "https://gamma-api.polymarket.com",
-  maxNotionalUSD: 1e3,
-  maxTotalExposureUSD: 5e3
-};
-var POLYGON_CHAIN_ID = 137;
-var PREDICTION_INSTRUMENT_PREFIX = "POLY:";
-function encodePredictionInstrument(conditionId, outcomeIndex) {
-  return `${PREDICTION_INSTRUMENT_PREFIX}${conditionId}:${outcomeIndex}`;
-}
-function decodePredictionInstrument(instrument) {
-  if (!instrument.startsWith(PREDICTION_INSTRUMENT_PREFIX)) return null;
-  const parts = instrument.slice(PREDICTION_INSTRUMENT_PREFIX.length).split(":");
-  if (parts.length !== 2) return null;
-  return { conditionId: parts[0], outcomeIndex: parseInt(parts[1], 10) };
-}
-
-// src/prediction/client.ts
-import { ClobClient } from "@polymarket/clob-client";
-import { Wallet } from "ethers";
-var PolymarketClient = class {
-  config;
-  clobClient = null;
-  apiCreds = null;
-  signer;
-  walletAddress;
-  marketCache = /* @__PURE__ */ new Map();
-  CACHE_TTL_MS = 6e4;
-  constructor(privateKey, config) {
-    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
-    this.signer = new Wallet(privateKey);
-    this.walletAddress = this.signer.address;
-  }
-  // ── INITIALIZATION ─────────────────────────────────────────
-  async initialize() {
-    const initClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer
-    );
-    this.apiCreds = await initClient.createOrDeriveApiKey();
-    this.clobClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer,
-      this.apiCreds,
-      0
-    );
-    console.log(`[prediction] CLOB initialized for ${this.walletAddress}`);
-  }
-  get isInitialized() {
-    return this.clobClient !== null && this.apiCreds !== null;
-  }
-  // ── CLOB API — ORDER BOOK & PRICES ─────────────────────────
-  async getOrderBook(tokenId) {
-    this.ensureInitialized();
-    const book = await this.clobClient.getOrderBook(tokenId);
-    return {
-      bids: (book.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) })),
-      asks: (book.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }))
-    };
-  }
-  async getMidpointPrice(tokenId) {
-    const book = await this.getOrderBook(tokenId);
-    if (book.bids.length === 0 || book.asks.length === 0) return 0;
-    return (book.bids[0].price + book.asks[0].price) / 2;
-  }
-  async getLastTradePrice(tokenId) {
-    this.ensureInitialized();
-    const resp = await this.clobClient.getLastTradePrice(tokenId);
-    return parseFloat(resp?.price || "0");
-  }
-  // ── CLOB API — ORDERS ──────────────────────────────────────
-  async placeLimitOrder(params) {
-    this.ensureInitialized();
-    const order = await this.clobClient.createAndPostOrder({
-      tokenID: params.tokenId,
-      price: params.price,
-      side: params.side,
-      size: params.size
-    });
-    return {
-      orderId: order?.orderID || "",
-      success: !!order?.orderID
-    };
-  }
-  async placeMarketOrder(params) {
-    this.ensureInitialized();
-    const order = await this.clobClient.createMarketOrder({
-      tokenID: params.tokenId,
-      amount: params.amount,
-      side: params.side
-    });
-    const result = await this.clobClient.postOrder(order);
-    return {
-      orderId: result?.orderID || "",
-      success: !!result?.orderID
-    };
-  }
-  async cancelOrder(orderId) {
-    this.ensureInitialized();
-    try {
-      await this.clobClient.cancelOrder({ orderID: orderId });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async cancelAllOrders() {
-    this.ensureInitialized();
-    try {
-      await this.clobClient.cancelAll();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async getOpenOrders() {
-    this.ensureInitialized();
-    return this.clobClient.getOpenOrders();
-  }
-  async getTradeHistory() {
-    this.ensureInitialized();
-    const trades = await this.clobClient.getTrades();
-    return (trades || []).map((t) => this.parseRawFill(t));
-  }
-  // ── GAMMA API — MARKET DISCOVERY (public) ──────────────────
-  async getMarkets(params) {
-    const query = new URLSearchParams();
-    if (params?.limit) query.set("limit", String(params.limit));
-    if (params?.offset) query.set("offset", String(params.offset));
-    if (params?.active !== void 0) query.set("active", String(params.active));
-    if (params?.category) query.set("tag", params.category);
-    const url = `${this.config.gammaApiUrl}/markets?${query.toString()}`;
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error(`Gamma API error: ${resp.status} ${await resp.text()}`);
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  async getMarketByConditionId(conditionId) {
-    const cached = this.marketCache.get(conditionId);
-    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
-      return cached.market;
-    }
-    const url = `${this.config.gammaApiUrl}/markets?condition_id=${conditionId}`;
-    const resp = await fetch(url);
-    if (!resp.ok) return null;
-    const raw = await resp.json();
-    if (!raw || raw.length === 0) return null;
-    const market = this.parseGammaMarket(raw[0]);
-    this.marketCache.set(conditionId, { market, cachedAt: Date.now() });
-    return market;
-  }
-  async searchMarkets(query, limit = 20) {
-    const url = `${this.config.gammaApiUrl}/markets?_q=${encodeURIComponent(query)}&limit=${limit}&active=true`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  async getTrendingMarkets(limit = 10) {
-    const url = `${this.config.gammaApiUrl}/markets?active=true&limit=${limit}&order=volume24hr&ascending=false`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  // ── WALLET ─────────────────────────────────────────────────
-  getWalletAddress() {
-    return this.walletAddress;
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  ensureInitialized() {
-    if (!this.clobClient) {
-      throw new Error("PolymarketClient not initialized. Call initialize() first.");
-    }
-  }
-  parseGammaMarket(raw) {
-    const outcomes = raw.outcomes ? JSON.parse(raw.outcomes) : ["Yes", "No"];
-    const outcomePrices = raw.outcomePrices ? JSON.parse(raw.outcomePrices) : [0, 0];
-    const outcomeTokenIds = raw.clobTokenIds ? JSON.parse(raw.clobTokenIds) : [];
-    return {
-      conditionId: raw.conditionId || raw.condition_id || "",
-      question: raw.question || "",
-      description: raw.description || "",
-      category: raw.groupItemTitle || raw.category || "Other",
-      outcomes,
-      outcomeTokenIds,
-      outcomePrices: outcomePrices.map((p) => parseFloat(p) || 0),
-      volume24h: parseFloat(raw.volume24hr || raw.volume24h || "0"),
-      liquidity: parseFloat(raw.liquidity || "0"),
-      endDate: raw.endDate ? new Date(raw.endDate).getTime() / 1e3 : 0,
-      active: raw.active !== false && raw.closed !== true,
-      resolved: raw.resolved === true,
-      winningOutcome: raw.winningOutcome,
-      resolutionSource: raw.resolutionSource || void 0,
-      uniqueTraders: raw.uniqueTraders || void 0
-    };
-  }
-  parseRawFill(raw) {
-    const tokenId = raw.asset_id || void 0;
-    const marketConditionId = raw.market || raw.asset_id || "";
-    return {
-      orderId: raw.orderId || raw.order_id || "",
-      tradeId: raw.id || raw.tradeId || "",
-      marketConditionId,
-      outcomeIndex: raw.outcome_index ?? (raw.side === "BUY" ? 0 : 1),
-      side: raw.side === "BUY" || raw.side === "buy" ? "BUY" : "SELL",
-      price: String(raw.price || "0"),
-      size: String(raw.size || "0"),
-      fee: String(raw.fee || "0"),
-      timestamp: raw.timestamp || raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
-      isMaker: raw.maker_order || raw.is_maker || false,
-      tokenId
-    };
-  }
-};
-
-// src/prediction/order-manager.ts
-var PolymarketOrderManager = class {
-  client;
-  config;
-  seenFillIds = /* @__PURE__ */ new Set();
-  recentFills = [];
-  positions = /* @__PURE__ */ new Map();
-  lastPriceRefresh = 0;
-  PRICE_REFRESH_MS = 1e4;
-  constructor(client, config) {
-    this.client = client;
-    this.config = config;
-  }
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-  async executeSignal(signal) {
-    if (signal.action === "hold") {
-      return { success: true, status: "cancelled", error: "Hold signal \u2014 no action" };
-    }
-    const violation = this.checkRiskLimits(signal);
-    if (violation) {
-      return { success: false, status: "error", error: violation };
-    }
-    try {
-      const market = await this.client.getMarketByConditionId(signal.marketConditionId);
-      if (!market) {
-        return { success: false, status: "error", error: `Market not found: ${signal.marketConditionId}` };
-      }
-      if (!market.active) {
-        return { success: false, status: "error", error: `Market is closed: ${market.question}` };
-      }
-      const tokenId = market.outcomeTokenIds[signal.outcomeIndex];
-      if (!tokenId) {
-        return { success: false, status: "error", error: `Invalid outcome index: ${signal.outcomeIndex}` };
-      }
-      const isBuy = signal.action === "buy_yes" || signal.action === "buy_no";
-      const side = isBuy ? "BUY" : "SELL";
-      let result;
-      if (signal.orderType === "market") {
-        result = await this.client.placeMarketOrder({
-          tokenId,
-          amount: signal.amount,
-          side
-        });
-      } else {
-        result = await this.client.placeLimitOrder({
-          tokenId,
-          price: signal.limitPrice,
-          size: signal.amount,
-          side
-        });
-      }
-      if (result.success) {
-        console.log(`[prediction] Order placed: ${signal.action} ${signal.amount} on "${market.question}" @ ${signal.limitPrice}`);
-        return { success: true, orderId: result.orderId, status: "resting" };
-      }
-      return { success: false, status: "error", error: "Order placement failed" };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error("[prediction] Order execution error:", message);
-      return { success: false, status: "error", error: message };
-    }
-  }
-  // ── FILL POLLING ───────────────────────────────────────────
-  async pollNewFills() {
-    try {
-      const allFills = await this.client.getTradeHistory();
-      const newFills = [];
-      for (const fill of allFills) {
-        if (!this.seenFillIds.has(fill.tradeId)) {
-          this.seenFillIds.add(fill.tradeId);
-          newFills.push(fill);
-          this.processFill(fill);
-          this.recentFills.push(fill);
-        }
-      }
-      if (this.recentFills.length > 100) {
-        this.recentFills = this.recentFills.slice(-100);
-      }
-      return newFills;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn("[prediction] Fill polling error:", message);
-      return [];
-    }
-  }
-  getRecentFills() {
-    return this.recentFills;
-  }
-  // ── POSITION QUERIES ───────────────────────────────────────
-  async getPositions(forceRefresh = false) {
-    if (forceRefresh || Date.now() - this.lastPriceRefresh > this.PRICE_REFRESH_MS) {
-      await this.refreshPrices();
-    }
-    return Array.from(this.positions.values()).filter((p) => p.balance > 0).map((p) => this.toExternalPosition(p));
-  }
-  async getAccountSummary() {
-    const positions = await this.getPositions();
-    const totalExposure = positions.reduce((sum, p) => sum + p.costBasis, 0);
-    const totalUnrealizedPnl = positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
-    const openMarkets = new Set(positions.map((p) => p.marketConditionId));
-    return {
-      totalExposure,
-      totalUnrealizedPnl,
-      openMarketCount: openMarkets.size,
-      openPositionCount: positions.length
-    };
-  }
-  getTotalExposure() {
-    let total = 0;
-    for (const pos of this.positions.values()) {
-      if (pos.balance > 0) total += pos.totalCostBasis;
-    }
-    return total;
-  }
-  // ── CANCELLATION ───────────────────────────────────────────
-  async cancelOrder(orderId) {
-    return this.client.cancelOrder(orderId);
-  }
-  async cancelAllOrders() {
-    return this.client.cancelAllOrders();
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  checkRiskLimits(signal) {
-    if (signal.amount > this.config.maxNotionalUSD) {
-      return `Trade exceeds max notional: $${signal.amount} > $${this.config.maxNotionalUSD}`;
-    }
-    if (signal.limitPrice <= 0 || signal.limitPrice >= 1) {
-      return `Invalid price: ${signal.limitPrice} (must be 0.01-0.99)`;
-    }
-    if (signal.confidence < 0.3) {
-      return `Low confidence: ${signal.confidence} < 0.3`;
-    }
-    const isBuy = signal.action === "buy_yes" || signal.action === "buy_no";
-    if (isBuy) {
-      const currentExposure = this.getTotalExposure();
-      if (currentExposure + signal.amount > this.config.maxTotalExposureUSD) {
-        return `Total exposure exceeded: $${currentExposure + signal.amount} > $${this.config.maxTotalExposureUSD}`;
-      }
-    }
-    return null;
-  }
-  processFill(fill) {
-    const key = `${fill.marketConditionId}:${fill.outcomeIndex}`;
-    let pos = this.positions.get(key);
-    const price = parseFloat(fill.price);
-    const size = parseFloat(fill.size);
-    if (!pos) {
-      pos = {
-        marketConditionId: fill.marketConditionId,
-        outcomeIndex: fill.outcomeIndex,
-        marketQuestion: fill.marketQuestion || "",
-        tokenId: fill.tokenId || "",
-        balance: 0,
-        totalCostBasis: 0,
-        totalProceeds: 0,
-        averageEntryPrice: 0,
-        currentPrice: price,
-        category: void 0,
-        endDate: void 0
-      };
-      this.positions.set(key, pos);
-    } else if (!pos.tokenId && fill.tokenId) {
-      pos.tokenId = fill.tokenId;
-    }
-    if (fill.side === "BUY") {
-      const oldCost = pos.averageEntryPrice * pos.balance;
-      const newCost = price * size;
-      pos.balance += size;
-      pos.totalCostBasis += newCost;
-      pos.averageEntryPrice = pos.balance > 0 ? (oldCost + newCost) / pos.balance : 0;
-    } else {
-      pos.balance -= size;
-      pos.totalProceeds += price * size;
-      if (pos.balance < 0) pos.balance = 0;
-    }
-  }
-  async refreshPrices() {
-    const openPositions = Array.from(this.positions.values()).filter((p) => p.balance > 0);
-    await Promise.all(
-      openPositions.map(async (pos) => {
-        try {
-          if (!pos.tokenId) {
-            const market = await this.client.getMarketByConditionId(pos.marketConditionId);
-            if (market && market.outcomeTokenIds[pos.outcomeIndex]) {
-              pos.tokenId = market.outcomeTokenIds[pos.outcomeIndex];
-            }
-          }
-          if (pos.tokenId) {
-            const price = await this.client.getMidpointPrice(pos.tokenId);
-            if (price > 0) pos.currentPrice = price;
-          }
-        } catch {
-        }
-      })
-    );
-    this.lastPriceRefresh = Date.now();
-  }
-  toExternalPosition(pos) {
-    const unrealizedPnl = pos.balance > 0 ? (pos.currentPrice - pos.averageEntryPrice) * pos.balance : 0;
-    return {
-      marketConditionId: pos.marketConditionId,
-      marketQuestion: pos.marketQuestion,
-      outcomeIndex: pos.outcomeIndex,
-      outcomeLabel: pos.outcomeIndex === 0 ? "Yes" : "No",
-      tokenId: pos.tokenId,
-      balance: pos.balance,
-      averageEntryPrice: pos.averageEntryPrice,
-      currentPrice: pos.currentPrice,
-      unrealizedPnl,
-      costBasis: pos.totalCostBasis - pos.totalProceeds,
-      endDate: pos.endDate,
-      category: pos.category
-    };
-  }
-};
-
-// src/runtime.ts
-import { createWalletClient, http } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { arbitrum } from "viem/chains";
-var SDK_VERSION = "0.1.0";
-var AgentRuntime = class {
-  config;
-  relay;
-  signal;
-  store;
-  positions;
-  llm;
-  strategy = null;
-  risk;
-  market;
-  paper = null;
-  // Venue clients
-  hlClient = null;
-  hlSigner = null;
-  hlOrders = null;
-  hlPositions = null;
-  hlWs = null;
-  pmClient = null;
-  pmOrders = null;
-  mode = "idle";
-  cycleCount = 0;
-  lastCycleAt = 0;
-  tradingInterval = null;
-  running = false;
-  constructor(config) {
-    this.config = config;
-    this.store = new FileStore(`data/${config.agentId}-store.json`);
-    this.positions = new PositionTracker(this.store);
-    this.market = new MarketDataService();
-    this.risk = new RiskManager(
-      {
-        maxPositionSizeBps: config.trading.maxPositionSizeBps,
-        maxDailyLossBps: config.trading.maxDailyLossBps,
-        maxConcurrentPositions: config.trading.maxConcurrentPositions,
-        maxSlippageBps: config.trading.maxSlippageBps,
-        minTradeValueUSD: config.trading.minTradeValueUSD
-      },
-      config.trading.initialCapitalUSD
-    );
-    this.llm = createLLMAdapter(config.llm);
-    this.relay = new RelayClient({
-      url: config.relay.url,
-      agentId: config.agentId,
-      token: config.apiToken,
-      heartbeatIntervalMs: config.relay.heartbeatIntervalMs,
-      reconnectMaxAttempts: config.relay.reconnectMaxAttempts,
-      onCommand: (cmd) => this.handleCommand(cmd),
-      onConnected: () => {
-        console.log(`[runtime] Connected to command center`);
-        this.sendStatus();
-      },
-      onDisconnected: () => {
-        console.log(`[runtime] Disconnected from command center`);
-      }
-    });
-    this.signal = new SignalReporter(this.relay);
-    if (config.trading.mode === "paper") {
-      this.paper = new PaperExecutor(config.trading.initialCapitalUSD ?? 1e4);
-    }
-  }
-  async start() {
-    console.log(`[runtime] Starting agent ${this.config.agentId}`);
-    console.log(`[runtime] Mode: ${this.config.trading.mode}`);
-    console.log(`[runtime] LLM: ${this.config.llm.provider}/${this.config.llm.model}`);
-    try {
-      this.strategy = await loadStrategy(this.config.strategy);
-      console.log(`[runtime] Strategy loaded`);
-    } catch (err) {
-      console.error(`[runtime] Failed to load strategy:`, err.message);
-      this.strategy = null;
-    }
-    if (this.config.trading.mode === "live") {
-      await this.initializeVenues();
-    }
-    try {
-      await this.relay.connect();
-      this.signal.reportInfo("Agent Started", `Agent ${this.config.agentId} connected to command center`);
-    } catch (err) {
-      console.error(`[runtime] Failed to connect to relay:`, err.message);
-      console.log(`[runtime] Will retry in background...`);
-    }
-    this.running = true;
-    this.mode = "idle";
-    this.sendStatus();
-    if (this.config.trading.mode === "paper" || this.config.trading.mode === "live") {
-      this.startTrading();
-    }
-    process.on("SIGTERM", () => this.stop());
-    process.on("SIGINT", () => this.stop());
-  }
-  async stop() {
-    console.log(`[runtime] Stopping agent ${this.config.agentId}`);
-    this.running = false;
-    this.stopTrading();
-    if (this.hlWs) {
-      this.hlWs.disconnect();
-    }
-    this.signal.reportInfo("Agent Stopped", `Agent ${this.config.agentId} shutting down`);
-    this.relay.disconnect();
-    console.log(`[runtime] Agent stopped`);
-    process.exit(0);
-  }
-  // ── VENUE INITIALIZATION ───────────────────────────────────
-  async initializeVenues() {
-    const privateKey = this.config.wallet?.privateKey;
-    if (!privateKey) {
-      console.log("[runtime] No wallet configured \u2014 live trading disabled");
-      return;
-    }
-    const hlConfig = this.config.venues?.hyperliquid_perp;
-    if (hlConfig?.enabled) {
-      try {
-        const account = privateKeyToAccount(privateKey);
-        const walletClient = createWalletClient({
-          account,
-          chain: arbitrum,
-          transport: http()
-        });
-        const perpConfig = {
-          enabled: true,
-          apiUrl: hlConfig.apiUrl,
-          wsUrl: hlConfig.wsUrl,
-          maxLeverage: hlConfig.maxLeverage,
-          maxNotionalUSD: hlConfig.maxNotionalUSD,
-          allowedInstruments: hlConfig.allowedInstruments
-        };
-        this.hlClient = new HyperliquidClient(perpConfig);
-        this.hlSigner = new HyperliquidSigner(walletClient);
-        this.hlOrders = new HyperliquidOrderManager(this.hlClient, this.hlSigner, perpConfig);
-        this.hlPositions = new HyperliquidPositionManager(this.hlClient, account.address);
-        this.hlWs = new HyperliquidWebSocket(perpConfig, account.address, this.hlClient);
-        await this.hlClient.getMeta();
-        this.hlWs.onFillReceived((fill) => {
-          this.handleHyperliquidFill(fill);
-        });
-        this.hlWs.onLiquidationDetected((instrument, size) => {
-          this.signal.reportError("Liquidation Detected", `${instrument}: ${size} liquidated`);
-        });
-        await this.hlWs.connect();
-        console.log(`[runtime] Hyperliquid initialized (${account.address})`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Hyperliquid:", err.message);
-      }
-    }
-    const pmConfig = this.config.venues?.polymarket;
-    if (pmConfig?.enabled) {
-      try {
-        const predConfig = {
-          enabled: true,
-          clobApiUrl: pmConfig.clobApiUrl,
-          gammaApiUrl: pmConfig.gammaApiUrl,
-          maxNotionalUSD: pmConfig.maxNotionalUSD,
-          maxTotalExposureUSD: pmConfig.maxTotalExposureUSD,
-          allowedCategories: pmConfig.allowedCategories
-        };
-        this.pmClient = new PolymarketClient(privateKey, predConfig);
-        await this.pmClient.initialize();
-        this.pmOrders = new PolymarketOrderManager(this.pmClient, predConfig);
-        console.log(`[runtime] Polymarket initialized`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Polymarket:", err.message);
-      }
-    }
-  }
-  // ── TRADING LOOP ───────────────────────────────────────────
-  startTrading() {
-    if (this.tradingInterval) return;
-    this.mode = this.config.trading.mode === "paper" ? "paper" : "trading";
-    console.log(`[runtime] Trading started (${this.mode}, interval: ${this.config.trading.tradingIntervalMs}ms)`);
-    this.sendStatus();
-    this.signal.reportInfo("Trading Started", `Mode: ${this.mode}`);
-    this.runCycle();
-    this.tradingInterval = setInterval(() => {
-      this.runCycle();
-    }, this.config.trading.tradingIntervalMs);
-  }
-  stopTrading() {
-    if (this.tradingInterval) {
-      clearInterval(this.tradingInterval);
-      this.tradingInterval = null;
-    }
-    this.mode = "idle";
-    this.sendStatus();
-    console.log(`[runtime] Trading stopped`);
-  }
-  async runCycle() {
-    if (!this.running || !this.strategy) return;
-    this.cycleCount++;
-    this.lastCycleAt = Date.now();
-    try {
-      const prices = this.market.getPrices();
-      const positionSummary = this.positions.getSummary(prices);
-      const signals = await this.strategy({
-        llm: this.llm,
-        market: this.market,
-        position: positionSummary,
-        store: this.store,
-        config: this.config.trading,
-        log: (msg) => {
-          console.log(`[strategy] ${msg}`);
-          this.signal.reportInfo("Strategy Log", msg);
-        }
-      });
-      if (!Array.isArray(signals) || signals.length === 0) {
-        await this.pollPredictionFills();
-        this.sendStatus();
-        return;
-      }
-      const filtered = this.risk.filterSignals(signals, this.market, positionSummary.openPositions.length);
-      for (const sig of filtered) {
-        try {
-          await this.executeSignal(sig);
-        } catch (err) {
-          console.error(`[runtime] Trade execution error:`, err.message);
-          this.signal.reportError("Trade Error", err.message);
-        }
-      }
-      await this.pollPredictionFills();
-    } catch (err) {
-      console.error(`[runtime] Cycle error:`, err.message);
-      this.signal.reportError("Cycle Error", err.message);
-      this.mode = "idle";
-    }
-    this.sendStatus();
-  }
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-  async executeSignal(sig) {
-    const venue = sig.venue;
-    if (this.paper) {
-      const trade = this.paper.execute(sig, this.market);
-      if (trade) {
-        this.signal.reportTrade({
-          ...sig,
-          price: trade.entryPrice,
-          fee: trade.fee,
-          venue: trade.venue,
-          venueFillId: trade.id,
-          venueTimestamp: new Date(trade.timestamp).toISOString()
-        });
-      }
-      return;
-    }
-    if (venue === "hyperliquid_perp" && this.hlOrders) {
-      await this.executeHyperliquidSignal(sig);
-    } else if (venue === "polymarket" && this.pmOrders) {
-      await this.executePolymarketSignal(sig);
-    } else {
-      console.log(`[runtime] No executor for venue "${venue}" \u2014 signal dropped`);
-    }
-  }
-  async executeHyperliquidSignal(sig) {
-    if (!this.hlOrders) return;
-    const action = sig.side === "long" ? "open_long" : sig.side === "short" ? "open_short" : sig.side === "buy" ? "open_long" : "close_long";
-    const result = await this.hlOrders.placeOrder({
-      action,
-      instrument: sig.symbol,
-      size: sig.size,
-      price: sig.price,
-      leverage: sig.leverage ?? 1,
-      orderType: sig.orderType ?? "market",
-      reduceOnly: action.startsWith("close"),
-      confidence: sig.confidence ?? 1,
-      reasoning: sig.reasoning
-    });
-    if (result.success && result.status === "filled") {
-      console.log(`[runtime] HL order filled: ${sig.symbol} ${result.avgPrice}`);
-    } else if (result.success && result.status === "resting") {
-      console.log(`[runtime] HL order resting: ${sig.symbol} (oid: ${result.orderId})`);
-    } else {
-      console.warn(`[runtime] HL order failed: ${result.error}`);
-      this.signal.reportError("Perp Order Failed", `${sig.symbol}: ${result.error}`);
-    }
-  }
-  async executePolymarketSignal(sig) {
-    if (!this.pmOrders) return;
-    const action = sig.side === "buy" ? "buy_yes" : sig.side === "sell" ? "sell_yes" : sig.side === "long" ? "buy_yes" : "sell_yes";
-    const result = await this.pmOrders.executeSignal({
-      action,
-      marketConditionId: sig.symbol,
-      marketQuestion: sig.reasoning ?? sig.symbol,
-      outcomeIndex: 0,
-      amount: sig.size,
-      limitPrice: sig.price,
-      orderType: sig.orderType ?? "limit",
-      confidence: sig.confidence ?? 1,
-      reasoning: sig.reasoning
-    });
-    if (result.success) {
-      console.log(`[runtime] PM order placed: ${sig.symbol}`);
-    } else {
-      console.warn(`[runtime] PM order failed: ${result.error}`);
-      this.signal.reportError("Prediction Order Failed", `${sig.symbol}: ${result.error}`);
-    }
-  }
-  // ── FILL HANDLING ──────────────────────────────────────────
-  handleHyperliquidFill(fill) {
-    const tradeSignal = {
-      venue: "hyperliquid_perp",
-      symbol: fill.coin,
-      side: fill.side === "B" ? "long" : "short",
-      size: parseFloat(fill.sz),
-      price: parseFloat(fill.px),
-      fee: parseFloat(fill.fee),
-      venueFillId: fill.hash,
-      venueTimestamp: new Date(fill.time).toISOString(),
-      orderType: fill.isMaker ? "limit" : "market"
-    };
-    const action = fill.side === "B" ? "buy" : "sell";
-    if (action === "buy") {
-      this.positions.recordBuy(
-        fill.coin,
-        parseFloat(fill.sz),
-        parseFloat(fill.px),
-        parseFloat(fill.fee),
-        "hyperliquid_perp",
-        void 0,
-        fill.hash
-      );
-    } else {
-      this.positions.recordSell(
-        fill.coin,
-        parseFloat(fill.sz),
-        parseFloat(fill.px),
-        parseFloat(fill.fee),
-        "hyperliquid_perp",
-        void 0,
-        fill.hash
-      );
-    }
-    this.signal.reportPerpFill(tradeSignal);
-  }
-  async pollPredictionFills() {
-    if (!this.pmOrders) return;
-    try {
-      const newFills = await this.pmOrders.pollNewFills();
-      for (const fill of newFills) {
-        const tradeSignal = {
-          venue: "polymarket",
-          chain: "polygon",
-          symbol: encodePredictionInstrument(fill.marketConditionId, fill.outcomeIndex),
-          side: fill.side === "BUY" ? "buy" : "sell",
-          size: parseFloat(fill.size),
-          price: parseFloat(fill.price),
-          fee: parseFloat(fill.fee),
-          venueFillId: fill.tradeId,
-          venueTimestamp: new Date(fill.timestamp).toISOString()
-        };
-        this.signal.reportPredictionFill(tradeSignal);
-      }
-    } catch (err) {
-      console.warn("[runtime] Prediction fill poll error:", err.message);
-    }
-  }
-  // ── COMMANDS ───────────────────────────────────────────────
-  handleCommand(command) {
-    console.log(`[runtime] Command received: ${command.type}`);
-    switch (command.type) {
-      case "start_trading":
-        this.startTrading();
-        break;
-      case "stop_trading":
-        this.stopTrading();
-        break;
-      case "update_risk_params":
-        if (command.params) {
-          console.log(`[runtime] Risk params updated`);
-        }
-        break;
-      case "get_status":
-        this.sendStatus();
-        break;
-      case "reload_config":
-        console.log(`[runtime] Config reload requested`);
-        break;
-      default:
-        console.warn(`[runtime] Unknown command: ${command.type}`);
-    }
-  }
-  // ── STATUS ─────────────────────────────────────────────────
-  sendStatus() {
-    const status = {
-      mode: this.mode,
-      agentId: this.config.agentId,
-      sdkVersion: SDK_VERSION,
-      cycleCount: this.cycleCount,
-      lastCycleAt: this.lastCycleAt,
-      tradingIntervalMs: this.config.trading.tradingIntervalMs,
-      llm: {
-        provider: this.config.llm.provider,
-        model: this.config.llm.model || "default"
-      },
-      risk: {
-        dailyPnL: this.risk.getDailyPnL(),
-        dailyLossLimit: this.risk.getDailyLossLimit(),
-        isLimitHit: this.risk.isDailyLossLimitHit()
-      },
-      positions: {
-        openPositions: this.positions.getPositions().length,
-        totalUnrealizedPnL: 0,
-        totalRealizedPnL: this.positions.getRealizedPnL()
-      },
-      venues: {
-        hyperliquid: {
-          enabled: !!this.hlClient,
-          trading: !!this.hlOrders && this.mode === "trading"
-        },
-        polymarket: {
-          enabled: !!this.pmClient,
-          trading: !!this.pmOrders && this.mode === "trading"
-        }
-      }
-    };
-    if (this.paper) {
-      const metrics = this.paper.getMetrics();
-      status.paper = {
-        active: true,
-        simulatedValue: this.paper.getEquity(),
-        simulatedPnLPct: metrics.totalReturn * 100
-      };
-      status.portfolioValue = this.paper.getEquity();
-    }
-    this.relay.sendHeartbeat(status);
-  }
-};
-
-export {
-  loadConfig,
-  generateSampleConfig,
-  writeSampleConfig,
-  RelayClient,
-  SignalReporter,
-  FileStore,
-  PositionTracker,
-  createLLMAdapter,
-  getTemplate,
-  listTemplates,
-  loadStrategy,
-  RiskManager,
-  MarketDataService,
-  PaperExecutor,
-  HyperliquidClient,
-  HYPERLIQUID_DOMAIN,
-  getNextNonce,
-  HyperliquidSigner,
-  HyperliquidOrderManager,
-  HyperliquidPositionManager,
-  HyperliquidWebSocket,
-  encodePredictionInstrument,
-  decodePredictionInstrument,
-  PolymarketClient,
-  PolymarketOrderManager,
-  AgentRuntime
-};