hood-traders 0.1.0

package/dist/chunk-NXL2F7EP.js

@@ -0,0 +1,1371 @@
+#!/usr/bin/env node
+
+// src/framework/risk.ts
+var RiskEngine = class {
+  constructor(limits) {
+    this.limits = limits;
+  }
+  limits;
+  get riskLimits() {
+    return this.limits;
+  }
+  check(ctx) {
+    if (ctx.killed) {
+      return { ok: false, reason: "kill_switch", detail: "kill switch is tripped \u2014 no new orders" };
+    }
+    if (ctx.notionalUsd <= 0) {
+      return { ok: false, reason: "zero_amount", detail: "order notional is zero or negative" };
+    }
+    if (ctx.lastTradeAt !== null) {
+      const elapsed = (ctx.now - ctx.lastTradeAt) / 1e3;
+      if (elapsed < this.limits.cooldownSeconds) {
+        const wait = (this.limits.cooldownSeconds - elapsed).toFixed(1);
+        return { ok: false, reason: "cooldown", detail: `cooldown active \u2014 ${wait}s until next trade allowed` };
+      }
+    }
+    if (ctx.slippageBps > this.limits.maxSlippageBps) {
+      return {
+        ok: false,
+        reason: "slippage_bound",
+        detail: `slippage ${ctx.slippageBps}bps exceeds cap ${this.limits.maxSlippageBps}bps`
+      };
+    }
+    if (ctx.side === "buy") {
+      if (ctx.positionUsdAfter > this.limits.maxPositionUsdg) {
+        return {
+          ok: false,
+          reason: "position_cap",
+          detail: `position would reach $${ctx.positionUsdAfter.toFixed(2)}, over cap $${this.limits.maxPositionUsdg}`
+        };
+      }
+      if (ctx.spentTodayUsd + ctx.notionalUsd > this.limits.maxDailySpendUsdg) {
+        return {
+          ok: false,
+          reason: "daily_cap",
+          detail: `daily spend would reach $${(ctx.spentTodayUsd + ctx.notionalUsd).toFixed(2)}, over cap $${this.limits.maxDailySpendUsdg}`
+        };
+      }
+      if (ctx.fleetSpentTodayUsd + ctx.notionalUsd > ctx.fleetMaxDailySpendUsdg) {
+        return {
+          ok: false,
+          reason: "fleet_daily_cap",
+          detail: `fleet daily spend would reach $${(ctx.fleetSpentTodayUsd + ctx.notionalUsd).toFixed(2)}, over cap $${ctx.fleetMaxDailySpendUsdg}`
+        };
+      }
+    }
+    return { ok: true, detail: "within all risk limits" };
+  }
+};
+function utcDayStart(now) {
+  const d = new Date(now);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+
+// src/framework/agent.ts
+import { formatUnits } from "viem";
+import { buildSwapTx, ensureApproval } from "hoodchain";
+var DUST = 1000n;
+var Agent = class {
+  id;
+  strategy;
+  mode;
+  market;
+  risk;
+  journal;
+  kill;
+  account;
+  opts;
+  clock;
+  positions = /* @__PURE__ */ new Map();
+  lastTradeAt = null;
+  realizedUsd = 0;
+  spentTodayUsd = 0;
+  spentDay = 0;
+  ticks = 0;
+  trades = 0;
+  refusals = 0;
+  lastTickAt = null;
+  lastError = null;
+  timer = null;
+  running = false;
+  ticking = false;
+  constructor(opts) {
+    this.opts = opts;
+    this.id = opts.id;
+    this.strategy = opts.strategy;
+    this.mode = opts.mode;
+    this.market = opts.market;
+    this.risk = new RiskEngine(opts.limits);
+    this.journal = opts.journal;
+    this.kill = opts.kill;
+    this.account = opts.account;
+    this.clock = opts.clock ?? Date.now;
+  }
+  /** Begin the tick loop and wire the strategy's stream subscriptions. */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    const log = (message, meta = {}) => this.journal.recordDecision({ agentId: this.id, ts: this.clock(), kind: "observe", detail: message, meta });
+    await this.strategy.start?.({ market: this.market, log });
+    this.kill.onKill((reason) => log(`kill switch tripped: ${reason} \u2014 halting new orders`));
+    this.scheduleTick();
+  }
+  /** Stop the loop and the strategy's subscriptions. */
+  stop() {
+    this.running = false;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.strategy.stop?.();
+  }
+  scheduleTick() {
+    if (!this.running) return;
+    this.timer = setTimeout(async () => {
+      await this.tick();
+      this.scheduleTick();
+    }, this.opts.tickIntervalMs);
+    this.timer.unref?.();
+  }
+  /** Run one full pipeline pass. Safe to call directly (used by tests). */
+  async tick() {
+    if (this.ticking) return;
+    this.ticking = true;
+    const now = this.clock();
+    try {
+      this.rolloverDay(now);
+      await this.markPositions(now);
+      if (this.kill.isKilled()) {
+        this.recordEquity(now);
+        this.ticks++;
+        this.lastTickAt = now;
+        return;
+      }
+      const decision = await this.decide(now);
+      for (const alert of decision.alerts) {
+        this.journal.recordDecision({
+          agentId: this.id,
+          ts: now,
+          kind: "alert",
+          detail: `[${alert.level}] ${alert.message}`,
+          meta: alert.meta ?? {}
+        });
+      }
+      for (const intent of decision.intents) {
+        await this.processIntent(intent, now);
+      }
+      this.recordEquity(now);
+      this.ticks++;
+      this.lastTickAt = now;
+      this.lastError = null;
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      this.journal.recordDecision({
+        agentId: this.id,
+        ts: now,
+        kind: "observe",
+        detail: `tick error: ${this.lastError}`,
+        meta: {}
+      });
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async decide(now) {
+    const { quoteToken, quoteSymbol, quoteDecimals } = this.quoteInfo();
+    return this.strategy.tick({
+      market: this.market,
+      positions: [...this.positions.values()],
+      now,
+      quoteToken,
+      quoteSymbol,
+      quoteDecimals,
+      log: (message, meta = {}) => this.journal.recordDecision({ agentId: this.id, ts: now, kind: "observe", detail: message, meta })
+    });
+  }
+  quoteInfo() {
+    if (this.strategy.quote === "weth") {
+      return { quoteToken: this.market.weth, quoteSymbol: "WETH", quoteDecimals: 18 };
+    }
+    return { quoteToken: this.market.usdg, quoteSymbol: "USDG", quoteDecimals: this.market.usdgDecimals };
+  }
+  async processIntent(intent, now) {
+    const refuse = (reason, detail, meta = {}) => {
+      this.refusals++;
+      this.journal.recordDecision({
+        agentId: this.id,
+        ts: now,
+        kind: "refused",
+        detail: `${intent.side} ${intent.tokenSymbol}: ${detail}`,
+        meta: { reason, intentReason: intent.reason, ...meta }
+      });
+    };
+    const quoteToken = intent.quoteToken;
+    const quoteDecimals = intent.quoteSymbol === "USDG" ? this.market.usdgDecimals : 18;
+    let sim;
+    if (intent.side === "buy") {
+      sim = await this.market.quoteBuy(quoteToken, intent.token, intent.amountIn);
+    } else {
+      sim = await this.market.quoteSell(intent.token, quoteToken, intent.amountIn);
+    }
+    if (!sim || sim.amountOut <= 0n) {
+      refuse("no_route", "no liquid route to simulate the fill");
+      return;
+    }
+    const ethUsd = intent.quoteSymbol === "WETH" ? await this.market.ethUsd(3e4, now) : 1;
+    if (ethUsd === null) {
+      refuse("no_route", "cannot price ETH to enforce USD caps");
+      return;
+    }
+    let notionalUsd;
+    if (intent.side === "buy") {
+      notionalUsd = Number(formatUnits(intent.amountIn, quoteDecimals)) * ethUsd;
+    } else {
+      notionalUsd = Number(formatUnits(sim.amountOut, quoteDecimals)) * ethUsd;
+    }
+    const existing = this.positions.get(intent.token.toLowerCase());
+    if (intent.side === "sell") {
+      if (!existing || existing.amount < intent.amountIn - DUST) {
+        refuse("insufficient_balance", "position too small to sell requested amount");
+        return;
+      }
+    }
+    const positionUsdAfter = intent.side === "buy" ? (existing?.investedUsd ?? 0) + notionalUsd : 0;
+    const slippageBps = Math.min(intent.maxSlippageBps ?? this.risk.riskLimits.maxSlippageBps, 1e4);
+    const minOut = sim.amountOut * BigInt(1e4 - slippageBps) / 10000n;
+    const verdict = this.risk.check({
+      side: intent.side,
+      notionalUsd,
+      positionUsdAfter,
+      spentTodayUsd: this.spentTodayUsd,
+      fleetSpentTodayUsd: this.opts.fleetSpentTodayUsd(),
+      lastTradeAt: this.lastTradeAt,
+      slippageBps,
+      killed: this.kill.isKilled(),
+      now,
+      fleetMaxDailySpendUsdg: this.opts.fleetMaxDailySpendUsdg
+    });
+    if (!verdict.ok) {
+      refuse(verdict.reason ?? "refused", verdict.detail, { notionalUsd: round(notionalUsd) });
+      return;
+    }
+    let txHash = null;
+    let amountOut = sim.amountOut;
+    if (this.mode === "live") {
+      const executed = await this.executeLive(intent, sim, slippageBps);
+      if (!executed) {
+        refuse("no_route", "live execution failed (see logs)");
+        return;
+      }
+      txHash = executed.hash;
+      amountOut = executed.amountOutMinimum;
+    }
+    const trade = {
+      agentId: this.id,
+      mode: this.mode,
+      ts: now,
+      side: intent.side,
+      token: intent.token,
+      tokenSymbol: intent.tokenSymbol,
+      quoteToken,
+      quoteSymbol: intent.quoteSymbol,
+      amountIn: intent.amountIn,
+      amountOut,
+      txHash,
+      reason: intent.reason,
+      slippageBps,
+      gasEstimate: sim.gasEstimate,
+      meta: { ...intent.meta ?? {}, notionalUsd: round(notionalUsd), minOut: minOut.toString() }
+    };
+    this.journal.recordTrade(trade);
+    this.trades++;
+    this.lastTradeAt = now;
+    this.applyFill(intent, amountOut, notionalUsd, now);
+    if (intent.side === "buy") {
+      this.spentTodayUsd += notionalUsd;
+      this.opts.reportFleetSpend(notionalUsd);
+    }
+  }
+  async executeLive(intent, sim, slippageBps) {
+    if (!this.account) return null;
+    try {
+      const tx = buildSwapTx(this.market.client, sim, { slippageBps });
+      await ensureApproval(this.market.client, intent.side === "buy" ? intent.quoteToken : intent.token, intent.amountIn);
+      const hash = await this.market.client.wallet.sendTransaction({
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        account: this.account,
+        chain: this.market.client.chain
+      });
+      await this.market.client.public.waitForTransactionReceipt({ hash });
+      return { hash, amountOutMinimum: tx.amountOutMinimum };
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      return null;
+    }
+  }
+  applyFill(intent, amountOut, notionalUsd, now) {
+    const key = intent.token.toLowerCase();
+    const existing = this.positions.get(key);
+    if (intent.side === "buy") {
+      if (existing) {
+        existing.amount += amountOut;
+        existing.costBasis += intent.amountIn;
+        existing.investedUsd += notionalUsd;
+      } else {
+        this.positions.set(key, {
+          token: intent.token,
+          tokenSymbol: intent.tokenSymbol,
+          amount: amountOut,
+          costBasis: intent.amountIn,
+          investedUsd: notionalUsd,
+          quoteToken: intent.quoteToken,
+          quoteSymbol: intent.quoteSymbol,
+          openedAt: now,
+          markUsd: null,
+          meta: intent.meta ?? {}
+        });
+      }
+      return;
+    }
+    if (!existing) return;
+    const sellAmount = intent.amountIn > existing.amount ? existing.amount : intent.amountIn;
+    const fraction = existing.amount > 0n ? Number(sellAmount) / Number(existing.amount) : 1;
+    const costFractionUsd = existing.investedUsd * fraction;
+    const costBasisSold = existing.amount > 0n ? existing.costBasis * sellAmount / existing.amount : existing.costBasis;
+    this.realizedUsd += notionalUsd - costFractionUsd;
+    existing.amount -= sellAmount;
+    existing.costBasis -= costBasisSold;
+    existing.investedUsd -= costFractionUsd;
+    if (existing.amount <= DUST) this.positions.delete(key);
+  }
+  /** Mark every open position to its live exit value (a real sell-side quote). */
+  async markPositions(now) {
+    for (const pos of this.positions.values()) {
+      const q = await this.market.quoteSell(pos.token, pos.quoteToken, pos.amount);
+      if (!q) {
+        pos.markUsd = null;
+        continue;
+      }
+      const quoteDecimals = pos.quoteSymbol === "USDG" ? this.market.usdgDecimals : 18;
+      const ethUsd = pos.quoteSymbol === "WETH" ? await this.market.ethUsd(3e4, now) : 1;
+      if (ethUsd === null) {
+        pos.markUsd = null;
+        continue;
+      }
+      pos.markUsd = Number(formatUnits(q.amountOut, quoteDecimals)) * ethUsd;
+    }
+  }
+  openValueUsd() {
+    let sum = 0;
+    for (const pos of this.positions.values()) sum += pos.markUsd ?? pos.investedUsd;
+    return sum;
+  }
+  recordEquity(now) {
+    const openValueUsd = this.openValueUsd();
+    this.journal.recordEquity({
+      agentId: this.id,
+      ts: now,
+      realizedUsd: round(this.realizedUsd),
+      openValueUsd: round(openValueUsd),
+      equityUsd: round(this.realizedUsd + openValueUsd)
+    });
+  }
+  rolloverDay(now) {
+    const day = utcDayStart(now);
+    if (day !== this.spentDay) {
+      this.spentDay = day;
+      this.spentTodayUsd = 0;
+    }
+  }
+  /** Live status snapshot for the dashboard API. */
+  status() {
+    const openValueUsd = this.openValueUsd();
+    return {
+      id: this.id,
+      strategy: this.strategy.id,
+      mode: this.mode,
+      running: this.running,
+      killed: this.kill.isKilled(),
+      limits: this.risk.riskLimits,
+      spentTodayUsd: round(this.spentTodayUsd),
+      realizedUsd: round(this.realizedUsd),
+      openValueUsd: round(openValueUsd),
+      equityUsd: round(this.realizedUsd + openValueUsd),
+      positions: [...this.positions.values()],
+      lastTickAt: this.lastTickAt,
+      lastError: this.lastError,
+      ticks: this.ticks,
+      trades: this.trades,
+      refusals: this.refusals
+    };
+  }
+};
+function round(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+// src/framework/journal.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+var Journal = class {
+  db;
+  constructor(dbPath) {
+    if (dbPath !== ":memory:") mkdirSync(dirname(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS trades (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        side TEXT NOT NULL,
+        token TEXT NOT NULL,
+        token_symbol TEXT NOT NULL,
+        quote_token TEXT NOT NULL,
+        quote_symbol TEXT NOT NULL,
+        amount_in TEXT NOT NULL,
+        amount_out TEXT NOT NULL,
+        tx_hash TEXT,
+        reason TEXT NOT NULL,
+        slippage_bps INTEGER NOT NULL,
+        gas_estimate TEXT NOT NULL,
+        meta TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_trades_agent_ts ON trades(agent_id, ts);
+
+      CREATE TABLE IF NOT EXISTS decisions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        detail TEXT NOT NULL,
+        meta TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_decisions_agent_ts ON decisions(agent_id, ts);
+
+      CREATE TABLE IF NOT EXISTS equity (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        realized_usd REAL NOT NULL,
+        open_value_usd REAL NOT NULL,
+        equity_usd REAL NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_equity_agent_ts ON equity(agent_id, ts);
+    `);
+  }
+  recordTrade(t) {
+    const info = this.db.prepare(
+      `INSERT INTO trades
+          (agent_id, mode, ts, side, token, token_symbol, quote_token, quote_symbol,
+           amount_in, amount_out, tx_hash, reason, slippage_bps, gas_estimate, meta)
+         VALUES (@agent_id,@mode,@ts,@side,@token,@token_symbol,@quote_token,@quote_symbol,
+           @amount_in,@amount_out,@tx_hash,@reason,@slippage_bps,@gas_estimate,@meta)`
+    ).run({
+      agent_id: t.agentId,
+      mode: t.mode,
+      ts: t.ts,
+      side: t.side,
+      token: t.token,
+      token_symbol: t.tokenSymbol,
+      quote_token: t.quoteToken,
+      quote_symbol: t.quoteSymbol,
+      amount_in: t.amountIn.toString(),
+      amount_out: t.amountOut.toString(),
+      tx_hash: t.txHash,
+      reason: t.reason,
+      slippage_bps: t.slippageBps,
+      gas_estimate: t.gasEstimate.toString(),
+      meta: JSON.stringify(t.meta ?? {})
+    });
+    return Number(info.lastInsertRowid);
+  }
+  recordDecision(d) {
+    const info = this.db.prepare(
+      `INSERT INTO decisions (agent_id, ts, kind, detail, meta)
+         VALUES (@agent_id,@ts,@kind,@detail,@meta)`
+    ).run({
+      agent_id: d.agentId,
+      ts: d.ts,
+      kind: d.kind,
+      detail: d.detail,
+      meta: JSON.stringify(d.meta ?? {})
+    });
+    return Number(info.lastInsertRowid);
+  }
+  recordEquity(e) {
+    this.db.prepare(
+      `INSERT INTO equity (agent_id, ts, realized_usd, open_value_usd, equity_usd)
+         VALUES (?,?,?,?,?)`
+    ).run(e.agentId, e.ts, e.realizedUsd, e.openValueUsd, e.equityUsd);
+  }
+  /** Sum of USDG-denominated spend by an agent since a UTC-day boundary (ms). */
+  spentSince(agentId, sinceMs, quoteSymbol = "USDG") {
+    const rows = this.db.prepare(
+      `SELECT amount_in FROM trades
+         WHERE agent_id=? AND ts>=? AND side='buy' AND quote_symbol=?`
+    ).all(agentId, sinceMs, quoteSymbol);
+    return rows.reduce((sum, r) => sum + Number(BigInt(r.amount_in)) / 1e6, 0);
+  }
+  recentTrades(agentId, limit = 50) {
+    const rows = this.db.prepare(`SELECT * FROM trades WHERE agent_id=? ORDER BY ts DESC LIMIT ?`).all(agentId, limit);
+    return rows.map(rowToTrade);
+  }
+  recentDecisions(agentId, limit = 100) {
+    const rows = this.db.prepare(`SELECT * FROM decisions WHERE agent_id=? ORDER BY ts DESC LIMIT ?`).all(agentId, limit);
+    return rows.map((r) => ({
+      id: r.id,
+      agentId: r.agent_id,
+      ts: r.ts,
+      kind: r.kind,
+      detail: r.detail,
+      meta: JSON.parse(r.meta || "{}")
+    }));
+  }
+  equityCurve(agentId, limit = 500) {
+    const rows = this.db.prepare(
+      `SELECT * FROM (
+           SELECT * FROM equity WHERE agent_id=? ORDER BY ts DESC LIMIT ?
+         ) ORDER BY ts ASC`
+    ).all(agentId, limit);
+    return rows.map((r) => ({
+      agentId: r.agent_id,
+      ts: r.ts,
+      realizedUsd: r.realized_usd,
+      openValueUsd: r.open_value_usd,
+      equityUsd: r.equity_usd
+    }));
+  }
+  /** All trades across every agent, newest first — for the fleet-wide feed. */
+  allRecentTrades(limit = 100) {
+    const rows = this.db.prepare(`SELECT * FROM trades ORDER BY ts DESC LIMIT ?`).all(limit);
+    return rows.map(rowToTrade);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function rowToTrade(r) {
+  return {
+    id: r.id,
+    agentId: r.agent_id,
+    mode: r.mode,
+    ts: r.ts,
+    side: r.side,
+    token: r.token,
+    tokenSymbol: r.token_symbol,
+    quoteToken: r.quote_token,
+    quoteSymbol: r.quote_symbol,
+    amountIn: BigInt(r.amount_in),
+    amountOut: BigInt(r.amount_out),
+    txHash: r.tx_hash ?? null,
+    reason: r.reason,
+    slippageBps: r.slippage_bps,
+    gasEstimate: BigInt(r.gas_estimate),
+    meta: JSON.parse(r.meta || "{}")
+  };
+}
+
+// src/framework/kill.ts
+import { existsSync } from "fs";
+var KillSwitch = class {
+  constructor(killFilePath) {
+    this.killFilePath = killFilePath;
+  }
+  killFilePath;
+  killed = false;
+  reason = null;
+  listeners = /* @__PURE__ */ new Set();
+  fileTimer = null;
+  /** Install SIGINT/SIGTERM handlers and begin polling the kill file. */
+  arm() {
+    const onSignal = (sig) => () => this.trip(`signal:${sig}`);
+    process.once("SIGINT", onSignal("SIGINT"));
+    process.once("SIGTERM", onSignal("SIGTERM"));
+    const check = () => {
+      if (!this.killed && existsSync(this.killFilePath)) this.trip("kill_file");
+    };
+    check();
+    this.fileTimer = setInterval(check, 1e3);
+    this.fileTimer.unref?.();
+  }
+  /** Trip the switch. Idempotent. */
+  trip(reason) {
+    if (this.killed) return;
+    this.killed = true;
+    this.reason = reason;
+    for (const l of this.listeners) {
+      try {
+        l(reason);
+      } catch {
+      }
+    }
+  }
+  isKilled() {
+    return this.killed;
+  }
+  killReason() {
+    return this.reason;
+  }
+  /** Subscribe to the trip event. Returns an unsubscribe fn. */
+  onKill(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Stop the file poller (used in tests/teardown). */
+  dispose() {
+    if (this.fileTimer) clearInterval(this.fileTimer);
+    this.fileTimer = null;
+    this.listeners.clear();
+  }
+};
+
+// src/framework/market.ts
+import {
+  createHoodClient,
+  getQuote,
+  quoteSwap,
+  swapAddresses,
+  listPricedStockTokens,
+  MAINNET_ADDRESSES,
+  TESTNET_ADDRESSES,
+  USDG_DECIMALS
+} from "hoodchain";
+import { formatUnits as formatUnits2, parseUnits } from "viem";
+var Market = class {
+  client;
+  usdg;
+  weth;
+  usdgDecimals = USDG_DECIMALS;
+  ethUsdCache = null;
+  constructor(config, account) {
+    this.client = createHoodClient({
+      chain: config.network,
+      rpcUrl: config.rpcUrl,
+      account,
+      acknowledgeStockTokenEligibility: config.stockTokenEligible
+    });
+    const addrs = config.network === "testnet" ? TESTNET_ADDRESSES : MAINNET_ADDRESSES;
+    this.usdg = addrs.usdg;
+    this.weth = config.network === "testnet" ? TESTNET_ADDRESSES.weth : MAINNET_ADDRESSES.weth;
+  }
+  /** Latest block number — a cheap liveness/observe heartbeat. */
+  blockNumber() {
+    return this.client.public.getBlockNumber();
+  }
+  /**
+   * ETH price in USD from the on-chain USDG/WETH pool (quote 0.01 WETH → USDG).
+   * Cached for 30s — it moves slowly relative to a trading tick and every call
+   * is a real RPC round trip. Returns `null` if no USDG/WETH pool answers.
+   */
+  async ethUsd(maxAgeMs = 3e4, now = Date.now()) {
+    if (this.ethUsdCache && now - this.ethUsdCache.ts < maxAgeMs) return this.ethUsdCache.value;
+    try {
+      const probe = parseUnits("0.01", 18);
+      const q = await quoteSwap(this.client, { tokenIn: this.weth, tokenOut: this.usdg, amountIn: probe });
+      const usd = Number(formatUnits2(q.amountOut, this.usdgDecimals)) / 0.01;
+      this.ethUsdCache = { value: usd, ts: now };
+      return usd;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Spot USD price of one whole `token` from live liquidity. Probes token→USDG
+   * directly, then token→WETH→USDG, using a 1-token probe. Returns `null` when
+   * neither route has liquidity.
+   */
+  async spotPrice(token, tokenDecimals = 18, now = Date.now()) {
+    const probe = parseUnits("1", tokenDecimals);
+    try {
+      const q = await quoteSwap(this.client, { tokenIn: token, tokenOut: this.usdg, amountIn: probe });
+      return { token, priceUsd: Number(formatUnits2(q.amountOut, this.usdgDecimals)), via: "usdg", ts: now };
+    } catch {
+    }
+    try {
+      const q = await quoteSwap(this.client, { tokenIn: token, tokenOut: this.weth, amountIn: probe });
+      const eth = await this.ethUsd(3e4, now);
+      if (eth === null) return null;
+      const priceEth = Number(formatUnits2(q.amountOut, 18));
+      return { token, priceUsd: priceEth * eth, via: "weth", ts: now };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Quote a buy: how much `token` `amountIn` of `quoteToken` acquires, at live
+   * liquidity. This is the simulate step — a QuoterV2 `eth_call`, no state
+   * change. Returns `null` when no route fills.
+   */
+  async quoteBuy(quoteToken, token, amountIn) {
+    try {
+      return await quoteSwap(this.client, { tokenIn: quoteToken, tokenOut: token, amountIn });
+    } catch {
+      return null;
+    }
+  }
+  /** Quote a sell: proceeds in `quoteToken` from selling `amount` of `token`. */
+  async quoteSell(token, quoteToken, amount) {
+    try {
+      return await quoteSwap(this.client, { tokenIn: token, tokenOut: quoteToken, amountIn: amount });
+    } catch {
+      return null;
+    }
+  }
+  /** Chainlink price for a Stock Token (already multiplier-adjusted). */
+  async stockChainlinkPrice(symbol) {
+    try {
+      return await getQuote(this.client, symbol);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * DEX price of a Stock Token in USD from the USDG pool — the number the
+   * premium-watch strategy compares against the Chainlink oracle. Probes with a
+   * flat 10 USDG order (small enough to keep impact low across the priced
+   * registry) and backs out the implied per-token price from the fill.
+   */
+  async stockDexPrice(tokenAddress, referenceUsd) {
+    if (referenceUsd <= 0) return null;
+    const usdgIn = parseUnits("10", this.usdgDecimals);
+    const q = await this.quoteBuy(this.usdg, tokenAddress, usdgIn);
+    if (!q) return null;
+    const tokensOut = Number(formatUnits2(q.amountOut, 18));
+    if (tokensOut <= 0) return null;
+    return 10 / tokensOut;
+  }
+  /** Priced Stock Tokens from the registry (those with a Chainlink feed). */
+  pricedStockTokens() {
+    return listPricedStockTokens();
+  }
+  /** Router/quoter/weth/usdg set for the active network. */
+  addresses() {
+    return swapAddresses(this.client);
+  }
+};
+
+// src/framework/fleet.ts
+import { privateKeyToAccount } from "viem/accounts";
+var Fleet = class {
+  config;
+  journal;
+  kill;
+  market;
+  account;
+  agents = [];
+  fleetSpentTodayUsd = 0;
+  spentDay = 0;
+  startedAt = 0;
+  constructor(config) {
+    this.config = config;
+    this.account = config.privateKey ? privateKeyToAccount(config.privateKey) : null;
+    this.journal = new Journal(config.dbPath);
+    this.kill = new KillSwitch(config.killFile);
+    this.market = new Market(config, this.account ?? void 0);
+  }
+  /** Build agents from specs. */
+  addAgents(specs) {
+    for (const spec of specs) {
+      const limits = { ...this.config.defaultLimits, ...spec.limits };
+      this.agents.push(
+        new Agent({
+          id: spec.id,
+          strategy: spec.strategy,
+          market: this.market,
+          limits,
+          journal: this.journal,
+          kill: this.kill,
+          mode: this.config.mode,
+          account: this.account,
+          fleetMaxDailySpendUsdg: this.config.fleetMaxDailySpendUsdg,
+          fleetSpentTodayUsd: () => this.currentFleetSpend(),
+          reportFleetSpend: (usd) => this.recordFleetSpend(usd),
+          tickIntervalMs: spec.tickIntervalMs ?? 5e3
+        })
+      );
+    }
+  }
+  currentFleetSpend(now = Date.now()) {
+    const day = utcDayStart(now);
+    if (day !== this.spentDay) {
+      this.spentDay = day;
+      this.fleetSpentTodayUsd = 0;
+    }
+    return this.fleetSpentTodayUsd;
+  }
+  recordFleetSpend(usd) {
+    this.currentFleetSpend();
+    this.fleetSpentTodayUsd += usd;
+  }
+  /** Arm the kill switch and start every agent's loop. */
+  async start() {
+    this.startedAt = Date.now();
+    this.kill.arm();
+    await Promise.all(this.agents.map((a) => a.start()));
+  }
+  /** Stop all agents (kill switch stays tripped if it was). */
+  stop() {
+    for (const a of this.agents) a.stop();
+  }
+  /** Run exactly one tick per agent, in parallel, without arming the interval scheduler. Used by E2E tests. */
+  async tickAllOnce() {
+    await Promise.all(this.agents.map((a) => a.tick()));
+  }
+  /** Trip the kill switch — halts new orders across the fleet. */
+  tripKill(reason) {
+    this.kill.trip(reason);
+  }
+  agentStatuses() {
+    return this.agents.map((a) => a.status());
+  }
+  summary() {
+    const statuses = this.agentStatuses();
+    return {
+      network: this.config.network,
+      mode: this.config.mode,
+      killed: this.kill.isKilled(),
+      killReason: this.kill.killReason(),
+      fleetSpentTodayUsd: round2(this.currentFleetSpend()),
+      fleetMaxDailySpendUsdg: this.config.fleetMaxDailySpendUsdg,
+      realizedUsd: round2(statuses.reduce((s, a) => s + a.realizedUsd, 0)),
+      openValueUsd: round2(statuses.reduce((s, a) => s + a.openValueUsd, 0)),
+      equityUsd: round2(statuses.reduce((s, a) => s + a.equityUsd, 0)),
+      agents: this.agents.length,
+      startedAt: this.startedAt
+    };
+  }
+  close() {
+    this.stop();
+    this.kill.dispose();
+    this.journal.close();
+  }
+};
+function round2(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+// src/framework/config.ts
+function num(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`Env ${name}="${raw}" is not a non-negative number`);
+  }
+  return n;
+}
+function bool(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  return raw === "1" || raw.toLowerCase() === "true" || raw.toLowerCase() === "yes";
+}
+function loadFleetConfig(env = process.env) {
+  const network = env.HOOD_NETWORK === "testnet" ? "testnet" : "mainnet";
+  const wantLive = bool("HOOD_TRADERS_LIVE", false);
+  const privateKey = env.ROBINHOOD_CHAIN_PRIVATE_KEY;
+  const hasKey = typeof privateKey === "string" && /^0x[0-9a-fA-F]{64}$/.test(privateKey);
+  const mode = wantLive && hasKey ? "live" : "paper";
+  return {
+    network,
+    rpcUrl: env.HOOD_RPC_URL || void 0,
+    mode,
+    hasWallet: hasKey,
+    privateKey: hasKey ? privateKey : void 0,
+    stockTokenEligible: bool("HOOD_STOCK_TOKEN_ELIGIBLE", false),
+    fleetMaxDailySpendUsdg: num("FLEET_MAX_DAILY_SPEND_USDG", 250),
+    dashboardPort: num("DASHBOARD_PORT", 4670),
+    killFile: env.KILL_FILE || "./KILL",
+    dbPath: env.HOOD_TRADERS_DB || "./data/hood-traders.db",
+    defaultLimits: {
+      maxPositionUsdg: num("AGENT_MAX_POSITION_USDG", 50),
+      maxDailySpendUsdg: num("AGENT_MAX_DAILY_SPEND_USDG", 100),
+      maxSlippageBps: num("AGENT_MAX_SLIPPAGE_BPS", 100),
+      cooldownSeconds: num("AGENT_COOLDOWN_SECONDS", 60)
+    }
+  };
+}
+
+// src/strategies/launch-sniper.ts
+import { erc20Abi, watchLaunches } from "hoodchain";
+import { formatUnits as formatUnits3, parseEther } from "viem";
+var DEFAULTS = {
+  entryWeth: 0.01,
+  takeProfitPct: 0.6,
+  stopLossPct: 0.35,
+  maxHoldSeconds: 30 * 60,
+  maxDeployerPct: 0.15,
+  maxRoundTripLossPct: 0.35,
+  maxLaunchAgeSeconds: 5 * 60
+};
+var LaunchSniper = class {
+  id = "launch-sniper";
+  title = "Launch Sniper";
+  quote = "weth";
+  p;
+  queue = [];
+  seen = /* @__PURE__ */ new Set();
+  unwatch = null;
+  constructor(params = {}) {
+    this.p = { ...DEFAULTS, ...params };
+  }
+  get meta() {
+    return {
+      edge: "Harvest opening-minutes volatility of freshly launched memecoins by buying only round-trippable, non-deployer-heavy launches and exiting mechanically on TP/stop/time.",
+      failureModes: [
+        "Most launches trend to zero \u2014 the stop loss fires frequently; profitability depends on winners covering losers.",
+        "Honeypots can enable a sell tax AFTER entry; the entry-time round-trip check cannot see that.",
+        "Odyssey bonding-curve tokens have no Uniswap pool pre-graduation and are skipped (this is effectively a NOXA sniper).",
+        "Paper fills use the QuoterV2 mid; live, faster bots win the best fills and you eat slippage."
+      ],
+      params: { ...this.p }
+    };
+  }
+  start(ctx) {
+    this.unwatch = watchLaunches(
+      ctx.market.client,
+      (launch) => {
+        const key = launch.token.toLowerCase();
+        if (this.seen.has(key)) return;
+        this.seen.add(key);
+        this.queue.push({ launch, seenAt: Date.now() });
+        ctx.log(`new launch queued: ${launch.launchpad} ${launch.token}`, { creator: launch.creator });
+      },
+      { onError: (e) => ctx.log(`launch watcher error: ${e.message}`) }
+    );
+  }
+  stop() {
+    this.unwatch?.();
+    this.unwatch = null;
+  }
+  async tick(ctx) {
+    const intents = [];
+    const alerts = [];
+    for (const pos of ctx.positions) {
+      const ageSec = (ctx.now - pos.openedAt) / 1e3;
+      const pnlPct = pos.markUsd !== null && pos.investedUsd > 0 ? pos.markUsd / pos.investedUsd - 1 : null;
+      let exitReason = null;
+      if (pnlPct !== null && pnlPct >= this.p.takeProfitPct) exitReason = `take-profit ${(pnlPct * 100).toFixed(1)}%`;
+      else if (pnlPct !== null && pnlPct <= -this.p.stopLossPct) exitReason = `stop-loss ${(pnlPct * 100).toFixed(1)}%`;
+      else if (ageSec >= this.p.maxHoldSeconds) exitReason = `time-exit ${Math.round(ageSec)}s held`;
+      if (exitReason) {
+        intents.push({
+          side: "sell",
+          token: pos.token,
+          tokenSymbol: pos.tokenSymbol,
+          amountIn: pos.amount,
+          quoteToken: pos.quoteToken,
+          quoteSymbol: pos.quoteSymbol,
+          reason: exitReason,
+          meta: { pnlPct }
+        });
+      }
+    }
+    const candidate = this.queue.shift();
+    if (candidate) {
+      const decisionOrReject = await this.evaluate(ctx, candidate);
+      if (decisionOrReject.intent) intents.push(decisionOrReject.intent);
+      else if (decisionOrReject.alert) alerts.push(decisionOrReject.alert);
+    }
+    return { intents, alerts };
+  }
+  async evaluate(ctx, candidate) {
+    const { launch } = candidate;
+    const ageSec = (ctx.now - candidate.seenAt) / 1e3;
+    if (ageSec > this.p.maxLaunchAgeSeconds) {
+      return { alert: { level: "info", message: `skip ${launch.token}: stale (${Math.round(ageSec)}s old)`, meta: {} } };
+    }
+    if (ctx.positions.some((p) => p.token.toLowerCase() === launch.token.toLowerCase())) return {};
+    const amountIn = parseEther(String(this.p.entryWeth));
+    const buyQuote = await ctx.market.quoteBuy(ctx.quoteToken, launch.token, amountIn);
+    if (!buyQuote || buyQuote.amountOut <= 0n) {
+      return { alert: { level: "info", message: `skip ${launch.token}: no liquid Uniswap route`, meta: { launchpad: launch.launchpad } } };
+    }
+    const sellQuote = await ctx.market.quoteSell(launch.token, ctx.quoteToken, buyQuote.amountOut);
+    if (!sellQuote || sellQuote.amountOut <= 0n) {
+      return { alert: { level: "warn", message: `skip ${launch.token}: cannot sell back (honeypot?)`, meta: {} } };
+    }
+    const retention = Number(sellQuote.amountOut) / Number(amountIn);
+    if (1 - retention > this.p.maxRoundTripLossPct) {
+      return {
+        alert: {
+          level: "warn",
+          message: `skip ${launch.token}: round-trip loss ${((1 - retention) * 100).toFixed(1)}% > ${(this.p.maxRoundTripLossPct * 100).toFixed(0)}%`,
+          meta: { retention }
+        }
+      };
+    }
+    const deployerPct = await this.deployerConcentration(ctx, launch);
+    if (deployerPct !== null && deployerPct > this.p.maxDeployerPct) {
+      return {
+        alert: {
+          level: "warn",
+          message: `skip ${launch.token}: deployer holds ${(deployerPct * 100).toFixed(1)}% > ${(this.p.maxDeployerPct * 100).toFixed(0)}%`,
+          meta: { deployerPct }
+        }
+      };
+    }
+    return {
+      intent: {
+        side: "buy",
+        token: launch.token,
+        tokenSymbol: shortToken(launch.token),
+        amountIn,
+        quoteToken: ctx.quoteToken,
+        quoteSymbol: ctx.quoteSymbol,
+        reason: `sniped ${launch.launchpad} launch \u2014 retention ${(retention * 100).toFixed(1)}%, deployer ${deployerPct === null ? "n/a" : (deployerPct * 100).toFixed(1) + "%"}`,
+        meta: { launchpad: launch.launchpad, deployerPct, retention }
+      }
+    };
+  }
+  async deployerConcentration(ctx, launch) {
+    try {
+      const [supply, bal] = await ctx.market.client.public.multicall({
+        contracts: [
+          { address: launch.token, abi: erc20Abi, functionName: "totalSupply" },
+          { address: launch.token, abi: erc20Abi, functionName: "balanceOf", args: [launch.creator] }
+        ],
+        allowFailure: false
+      });
+      if (supply === 0n) return null;
+      return Number(formatUnits3(bal * 10000n / supply, 4));
+    } catch {
+      return null;
+    }
+  }
+};
+function shortToken(addr) {
+  return `${addr.slice(0, 6)}\u2026${addr.slice(-4)}`;
+}
+
+// src/strategies/momentum.ts
+import { getRecentLaunches, parseUsdg } from "hoodchain";
+var DEFAULTS2 = {
+  entryUsdg: 10,
+  breakoutPct: 0.15,
+  lookbackSamples: 6,
+  trailingStopPct: 0.2,
+  maxHoldSeconds: 60 * 60,
+  maxTracked: 15,
+  discoveryLookbackBlocks: 200000n
+};
+var Momentum = class {
+  id = "momentum";
+  title = "Momentum";
+  quote = "usdg";
+  p;
+  history = /* @__PURE__ */ new Map();
+  peakSinceEntry = /* @__PURE__ */ new Map();
+  lastDiscoveryAt = 0;
+  constructor(params = {}) {
+    this.p = { ...DEFAULTS2, ...params };
+  }
+  get meta() {
+    return {
+      edge: "Trend-follow price breakouts on already-graduated, liquid tokens \u2014 surviving the launch phase filters for real demand, and a trailing stop rides the middle of a move.",
+      failureModes: [
+        "Breakouts on thin pools are trivially fakeable by a single wallet; price-only signal has no depth check.",
+        "Trailing stops whipsaw in choppy conditions \u2014 a string of small losses between real trends is expected.",
+        "Discovery only scans a bounded block lookback; breakouts on tokens outside that window are missed until the next pass.",
+        "Momentum has no edge in a flat or declining market \u2014 it is a trend-only strategy by design."
+      ],
+      params: { ...this.p }
+    };
+  }
+  async tick(ctx) {
+    const intents = [];
+    const alerts = [];
+    if (ctx.now - this.lastDiscoveryAt > 5 * 6e4 || this.history.size === 0) {
+      await this.discover(ctx);
+      this.lastDiscoveryAt = ctx.now;
+    }
+    for (const h of this.history.values()) {
+      const spot = await ctx.market.spotPrice(h.token);
+      if (!spot) continue;
+      h.samples.push({ ts: ctx.now, priceUsd: spot.priceUsd });
+      if (h.samples.length > this.p.lookbackSamples + 1) h.samples.shift();
+    }
+    for (const pos of ctx.positions) {
+      const key = pos.token.toLowerCase();
+      const spot = await ctx.market.spotPrice(pos.token);
+      const ageSec = (ctx.now - pos.openedAt) / 1e3;
+      if (spot) {
+        const peak = Math.max(this.peakSinceEntry.get(key) ?? spot.priceUsd, spot.priceUsd);
+        this.peakSinceEntry.set(key, peak);
+        const drawdown = peak > 0 ? 1 - spot.priceUsd / peak : 0;
+        if (drawdown >= this.p.trailingStopPct) {
+          intents.push(this.exitIntent(pos, ctx, `trailing stop: ${(drawdown * 100).toFixed(1)}% off peak $${peak.toFixed(6)}`));
+          this.peakSinceEntry.delete(key);
+          continue;
+        }
+      }
+      if (ageSec >= this.p.maxHoldSeconds) {
+        intents.push(this.exitIntent(pos, ctx, `time-exit ${Math.round(ageSec)}s held`));
+        this.peakSinceEntry.delete(key);
+      }
+    }
+    for (const h of this.history.values()) {
+      if (h.samples.length < this.p.lookbackSamples) continue;
+      if (ctx.positions.some((p) => p.token.toLowerCase() === h.token.toLowerCase())) continue;
+      const first = h.samples[h.samples.length - this.p.lookbackSamples];
+      const last = h.samples[h.samples.length - 1];
+      if (!first || !last || first.priceUsd <= 0) continue;
+      const gain = last.priceUsd / first.priceUsd - 1;
+      if (gain >= this.p.breakoutPct) {
+        const amountIn = parseUsdg(String(this.p.entryUsdg));
+        intents.push({
+          side: "buy",
+          token: h.token,
+          tokenSymbol: h.symbol,
+          amountIn,
+          quoteToken: ctx.quoteToken,
+          quoteSymbol: ctx.quoteSymbol,
+          reason: `breakout +${(gain * 100).toFixed(1)}% over ${this.p.lookbackSamples} samples ($${first.priceUsd.toFixed(6)}\u2192$${last.priceUsd.toFixed(6)})`,
+          meta: { gain, entryPriceUsd: last.priceUsd }
+        });
+        this.peakSinceEntry.set(h.token.toLowerCase(), last.priceUsd);
+      } else {
+        alerts.push({
+          level: "info",
+          message: `${h.symbol} watch: ${(gain * 100).toFixed(1)}% vs ${(this.p.breakoutPct * 100).toFixed(0)}% breakout threshold`
+        });
+      }
+    }
+    return { intents, alerts };
+  }
+  exitIntent(pos, ctx, reason) {
+    return {
+      side: "sell",
+      token: pos.token,
+      tokenSymbol: pos.tokenSymbol,
+      amountIn: pos.amount,
+      quoteToken: pos.quoteToken,
+      quoteSymbol: pos.quoteSymbol,
+      reason
+    };
+  }
+  async discover(ctx) {
+    let launches;
+    try {
+      launches = await getRecentLaunches(ctx.market.client, { lookbackBlocks: this.p.discoveryLookbackBlocks });
+    } catch (err) {
+      ctx.log(`momentum discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    const graduated = launches.filter((l) => l.launchpad === "noxa" || l.pool !== null);
+    const candidates = graduated.slice(-this.p.maxTracked);
+    for (const l of candidates) {
+      const key = l.token.toLowerCase();
+      if (this.history.has(key)) continue;
+      const spot = await ctx.market.spotPrice(l.token);
+      if (!spot) continue;
+      this.history.set(key, { token: l.token, symbol: shortToken2(l.token), samples: [{ ts: ctx.now, priceUsd: spot.priceUsd }] });
+    }
+    const keep = new Set(candidates.map((l) => l.token.toLowerCase()));
+    for (const key of [...this.history.keys()]) {
+      if (!keep.has(key) && !ctx.positions.some((p) => p.token.toLowerCase() === key)) this.history.delete(key);
+    }
+  }
+};
+function shortToken2(addr) {
+  return `${addr.slice(0, 6)}\u2026${addr.slice(-4)}`;
+}
+
+// src/strategies/premium-watch.ts
+import { getStockToken, parseUsdg as parseUsdg2 } from "hoodchain";
+var DEFAULT_SYMBOLS = ["AAPL", "TSLA", "NVDA", "AMZN", "MSFT"];
+var DEFAULTS3 = {
+  symbols: DEFAULT_SYMBOLS,
+  alertThresholdBps: 50,
+  tradeThresholdBps: 150,
+  tradeSizeUsdg: 20,
+  exitThresholdBps: 20,
+  maxHoldSeconds: 2 * 60 * 60,
+  enableTrading: false
+};
+var PremiumWatch = class {
+  id = "premium-watch";
+  title = "Premium Watch";
+  quote = "usdg";
+  p;
+  constructor(params = {}) {
+    this.p = { ...DEFAULTS3, ...params };
+  }
+  get meta() {
+    return {
+      edge: "Track Chainlink-vs-DEX spread on Stock Tokens and, only in eligible+opted-in configuration, buy discounts expecting reversion as the thin pool re-equilibrates. Default mode is alerts-only.",
+      failureModes: [
+        "A premium/discount can be correct \u2014 DEX price may reflect information the \u226424h Chainlink heartbeat has not caught up to; fading it then loses on purpose.",
+        "Stock Token pools are thin; the probe price does not reflect real trade-size slippage, and the trade itself moves the spread being arbitraged.",
+        "No shorting primitive exists, so only discounts (DEX cheap) are ever tradeable \u2014 premiums are alert-only by construction, not by choice.",
+        "Chainlink staleness (weekend gap, feed outage) can masquerade as a discount when the oracle, not the pool, is stale.",
+        "Trading requires an explicit eligibility affirmation (Stock Tokens cannot be sold to US/CA/UK/CH persons) \u2014 default is alerts-only until the operator opts in."
+      ],
+      params: { ...this.p, enableTrading: this.p.enableTrading }
+    };
+  }
+  async tick(ctx) {
+    const intents = [];
+    const alerts = [];
+    const tradingLive = this.p.enableTrading && ctx.market.client.acknowledgeStockTokenEligibility;
+    if (this.p.enableTrading && !ctx.market.client.acknowledgeStockTokenEligibility) {
+      alerts.push({
+        level: "warn",
+        message: "premium-watch: enableTrading=true but the client has not acknowledged Stock Token eligibility \u2014 staying alerts-only"
+      });
+    }
+    for (const pos of ctx.positions) {
+      const symbol = pos.tokenSymbol;
+      const spread = await this.readSpread(ctx, symbol);
+      const ageSec = (ctx.now - pos.openedAt) / 1e3;
+      let exitReason = null;
+      if (spread && Math.abs(spread.bps) <= this.p.exitThresholdBps) {
+        exitReason = `converged: spread ${spread.bps.toFixed(0)}bps within exit band`;
+      } else if (ageSec >= this.p.maxHoldSeconds) {
+        exitReason = `time-exit ${Math.round(ageSec)}s held`;
+      }
+      if (exitReason) {
+        intents.push({
+          side: "sell",
+          token: pos.token,
+          tokenSymbol: symbol,
+          amountIn: pos.amount,
+          quoteToken: pos.quoteToken,
+          quoteSymbol: pos.quoteSymbol,
+          reason: exitReason
+        });
+      }
+    }
+    for (const symbol of this.p.symbols) {
+      const spread = await this.readSpread(ctx, symbol);
+      if (!spread) continue;
+      const direction = spread.bps > 0 ? "premium (DEX rich)" : "discount (DEX cheap)";
+      if (Math.abs(spread.bps) >= this.p.alertThresholdBps) {
+        alerts.push({
+          level: "warn",
+          message: `${symbol} ${direction}: oracle $${spread.oracleUsd.toFixed(2)} vs DEX $${spread.dexUsd.toFixed(2)} (${spread.bps.toFixed(0)}bps)`,
+          meta: { symbol, oracleUsd: spread.oracleUsd, dexUsd: spread.dexUsd, bps: spread.bps }
+        });
+      }
+      const alreadyHeld = ctx.positions.some((p) => p.tokenSymbol === symbol);
+      const isDiscount = spread.bps <= -this.p.tradeThresholdBps;
+      if (tradingLive && isDiscount && !alreadyHeld) {
+        const token = getStockToken(symbol);
+        intents.push({
+          side: "buy",
+          token: token.address,
+          tokenSymbol: symbol,
+          amountIn: parseUsdg2(String(this.p.tradeSizeUsdg)),
+          quoteToken: ctx.quoteToken,
+          quoteSymbol: ctx.quoteSymbol,
+          reason: `convergence entry: ${symbol} discount ${spread.bps.toFixed(0)}bps (oracle $${spread.oracleUsd.toFixed(2)} vs DEX $${spread.dexUsd.toFixed(2)})`,
+          meta: { symbol, oracleUsd: spread.oracleUsd, dexUsd: spread.dexUsd, bps: spread.bps }
+        });
+      } else if (isDiscount && !tradingLive) {
+        alerts.push({
+          level: "info",
+          message: `${symbol} discount ${spread.bps.toFixed(0)}bps clears trade threshold but trading is disabled/ineligible \u2014 alert only`
+        });
+      }
+    }
+    return { intents, alerts };
+  }
+  async readSpread(ctx, symbol) {
+    const oracle = await ctx.market.stockChainlinkPrice(symbol);
+    if (!oracle) return null;
+    const token = getStockToken(symbol);
+    const dexUsd = await ctx.market.stockDexPrice(token.address, oracle.priceUsd);
+    if (dexUsd === null) return null;
+    const bps = (dexUsd - oracle.priceUsd) / oracle.priceUsd * 1e4;
+    return { oracleUsd: oracle.priceUsd, dexUsd, bps };
+  }
+};
+
+// src/server/dashboard.ts
+import { createServer } from "http";
+import { readFile } from "fs/promises";
+import { extname, join } from "path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml"
+};
+function json(res, status, body) {
+  const payload = JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  res.end(payload);
+}
+async function serveStatic(staticRoot, req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  let rel = url.pathname === "/" ? "/index.html" : url.pathname;
+  if (rel.includes("..")) return false;
+  const path = join(staticRoot, rel);
+  try {
+    const body = await readFile(path);
+    res.writeHead(200, { "content-type": MIME[extname(path)] ?? "application/octet-stream" });
+    res.end(body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createDashboardServer(fleet, staticRoot) {
+  return createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (url.pathname === "/api/summary" && req.method === "GET") {
+      return json(res, 200, fleet.summary());
+    }
+    if (url.pathname === "/api/agents" && req.method === "GET") {
+      return json(res, 200, fleet.agentStatuses());
+    }
+    if (url.pathname.startsWith("/api/agents/") && url.pathname.endsWith("/trades") && req.method === "GET") {
+      const agentId = decodeURIComponent(url.pathname.split("/")[3] ?? "");
+      return json(res, 200, fleet.journal.recentTrades(agentId, 100));
+    }
+    if (url.pathname.startsWith("/api/agents/") && url.pathname.endsWith("/journal") && req.method === "GET") {
+      const agentId = decodeURIComponent(url.pathname.split("/")[3] ?? "");
+      return json(res, 200, fleet.journal.recentDecisions(agentId, 200));
+    }
+    if (url.pathname.startsWith("/api/agents/") && url.pathname.endsWith("/equity") && req.method === "GET") {
+      const agentId = decodeURIComponent(url.pathname.split("/")[3] ?? "");
+      return json(res, 200, fleet.journal.equityCurve(agentId, 500));
+    }
+    if (url.pathname === "/api/trades" && req.method === "GET") {
+      return json(res, 200, fleet.journal.allRecentTrades(100));
+    }
+    if (url.pathname === "/api/kill" && req.method === "POST") {
+      fleet.tripKill("dashboard");
+      return json(res, 200, { killed: true, reason: "dashboard" });
+    }
+    if (url.pathname === "/api/health" && req.method === "GET") {
+      return json(res, 200, { ok: true });
+    }
+    if (await serveStatic(staticRoot, req, res)) return;
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end("not found");
+  });
+}
+
+export {
+  RiskEngine,
+  utcDayStart,
+  Agent,
+  Journal,
+  KillSwitch,
+  Market,
+  Fleet,
+  loadFleetConfig,
+  LaunchSniper,
+  Momentum,
+  PremiumWatch,
+  createDashboardServer
+};
+//# sourceMappingURL=chunk-NXL2F7EP.js.map