@agenticmail/enterprise 0.5.441 → 0.5.443

package/dist/chunk-7S5XAXRD.js

@@ -0,0 +1,4747 @@
+import {
+  errorResult,
+  jsonResult
+} from "./chunk-ZB3VC2MR.js";
+import {
+  cachedFetchJSON,
+  safeDbDDL,
+  safeDbExec,
+  safeDbGet,
+  safeDbQuery
+} from "./chunk-N5C3PJZC.js";
+import {
+  checkAlerts,
+  createBracketAlerts,
+  deleteAlert,
+  deleteAllAlerts,
+  deleteAutoApproveRule,
+  ensureSDK,
+  generateWallet,
+  getAlerts,
+  getAutoApproveRules,
+  getBracketConfig,
+  getCalibration,
+  getClobClient,
+  getDailyCounter,
+  getPaperPositions,
+  getPendingTrades,
+  getResolvedPredictions,
+  getStrategyPerformance,
+  getUnresolvedPredictions,
+  importSDK,
+  incrementDailyCounter,
+  initLearningDB,
+  initPolymarketDB,
+  loadConfig,
+  loadWalletCredentials,
+  logTrade,
+  markLessonsExtracted,
+  pauseTrading,
+  recallLessons,
+  recordPrediction,
+  resolvePendingTrade,
+  resolvePrediction,
+  resumeTrading,
+  saveAlert,
+  saveAutoApproveRule,
+  saveConfig,
+  savePaperPosition,
+  savePendingTrade,
+  saveWalletCredentials,
+  storeLesson
+} from "./chunk-HV5VIS5K.js";
+import {
+  analyzeCounterparties,
+  analyzeFlow,
+  analyzeMicrostructure,
+  analyzeOrderbookDepth,
+  analyzePolymarketComments,
+  analyzePortfolio,
+  analyzeSentiment,
+  analyzeStatArb,
+  analyzeTwitterSentiment,
+  analyzeVolatility,
+  assessResolutionRisk,
+  attributePnL,
+  batchScreen,
+  bayesianUpdate,
+  calculateCorrelationMatrix,
+  calculateEntropy,
+  calculateKelly,
+  calculatePortfolioKelly,
+  calculateSmartMoneyIndex,
+  calculateTechnicalIndicators,
+  calculateVaR,
+  compareOdds,
+  decodeTransaction,
+  detectManipulation,
+  detectRegime,
+  fetchBreakingNews,
+  fetchNewsFeed,
+  fetchOfficialSource,
+  findCorrelations,
+  fullAnalysis,
+  generateCompositeSignal,
+  getWalletTransactions,
+  mapLiquidity,
+  measureSocialVelocity,
+  monitorRedditPulse,
+  monitorTelegram,
+  portfolioReview,
+  priceBinaryOption,
+  profileWallet,
+  quickAnalysis,
+  runMonteCarlo,
+  scanArbitrage,
+  scanWhaleTrades,
+  testMarketEfficiency,
+  trackResolution
+} from "./chunk-X2ZHRKPL.js";
+import {
+  screenMarkets
+} from "./chunk-YHOMKT3Q.js";
+import {
+  CLOB_API,
+  CTF_ADDRESS,
+  USDC_ADDRESS
+} from "./chunk-WH37MNM7.js";
+import {
+  createWatcherTools
+} from "./chunk-ULD6C5DB.js";
+
+// src/agent-tools/tools/polymarket-screener.ts
+function createPolymarketScreenerTools(_opts) {
+  return [
+    {
+      name: "poly_screen_markets",
+      description: "Screen and rank prediction markets using a 6-dimension scoring system: liquidity, volume, spread, edge potential, timing, and momentum. Returns ranked list with recommendations. Supports strategy modes: momentum, contested, best_opportunities, high_volume, closing_soon, mispriced, safe_bets, new_markets.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query to filter markets" },
+          strategy: {
+            type: "string",
+            description: "Screening strategy",
+            enum: ["momentum", "contested", "best_opportunities", "high_volume", "closing_soon", "mispriced", "safe_bets", "new_markets"]
+          },
+          limit: { type: "number", description: "Max markets to return", default: 10 },
+          min_volume: { type: "number", description: "Minimum 24h volume filter" },
+          min_liquidity: { type: "number", description: "Minimum liquidity filter" },
+          active_only: { type: "boolean", description: "Only active markets", default: true }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          const raw = await screenMarkets(p);
+          if (raw?.markets && Array.isArray(raw.markets)) {
+            raw.markets = raw.markets.slice(0, 8).map((m) => {
+              const mkt = m.market || {};
+              return {
+                market: {
+                  id: mkt.id,
+                  question: mkt.question,
+                  slug: mkt.slug,
+                  outcomes: mkt.outcomes,
+                  outcomePrices: mkt.outcomePrices || mkt.outcome_prices,
+                  volume24hr: mkt.volume24hr,
+                  liquidity: mkt.liquidity,
+                  endDate: mkt.end_date_iso || mkt.endDate
+                },
+                scores: m.scores,
+                analysis: m.analysis ? {
+                  overround: m.analysis.overround,
+                  hoursToClose: m.analysis.hoursToClose,
+                  volumePerHour: m.analysis.volumePerHour,
+                  priceLevel: m.analysis.priceLevel,
+                  edgeType: m.analysis.edgeType
+                } : void 0,
+                recommendation: m.recommendation ? { action: m.recommendation.action, confidence: m.recommendation.confidence } : void 0,
+                pipeline: m.pipeline ? { action: m.pipeline.action, score: m.pipeline.score, kelly: m.pipeline.kelly } : void 0
+              };
+            });
+          }
+          return jsonResult(raw);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-execution.ts
+var CLOB_API2 = "https://clob.polymarket.com";
+async function initExecutionDB(db) {
+  if (!db) return;
+  const stmts = [
+    `CREATE TABLE IF NOT EXISTS poly_sniper_orders (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      side TEXT NOT NULL,
+      target_price REAL NOT NULL,
+      max_price REAL,
+      trail_amount REAL DEFAULT 0.01,
+      size_usdc REAL NOT NULL,
+      cancel_price REAL,
+      status TEXT DEFAULT 'active',
+      filled_size REAL DEFAULT 0,
+      filled_avg_price REAL DEFAULT 0,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )`,
+    `CREATE TABLE IF NOT EXISTS poly_scale_orders (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      side TEXT NOT NULL,
+      total_size REAL NOT NULL,
+      slices INTEGER NOT NULL,
+      interval_seconds INTEGER NOT NULL,
+      strategy TEXT DEFAULT 'twap',
+      completed_slices INTEGER DEFAULT 0,
+      filled_size REAL DEFAULT 0,
+      avg_price REAL DEFAULT 0,
+      status TEXT DEFAULT 'active',
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )`,
+    `CREATE TABLE IF NOT EXISTS poly_exit_rules (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      entry_price REAL NOT NULL,
+      position_size REAL NOT NULL,
+      take_profit REAL,
+      stop_loss REAL,
+      trailing_stop_pct REAL,
+      time_exit TEXT,
+      highest_price REAL,
+      status TEXT DEFAULT 'active',
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )`,
+    `CREATE TABLE IF NOT EXISTS poly_hedges (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      primary_token TEXT NOT NULL,
+      hedge_token TEXT NOT NULL,
+      primary_side TEXT NOT NULL,
+      hedge_side TEXT NOT NULL,
+      primary_size REAL NOT NULL,
+      hedge_size REAL NOT NULL,
+      hedge_ratio REAL NOT NULL,
+      correlation REAL,
+      status TEXT DEFAULT 'active',
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )`
+  ];
+  for (const sql of stmts) {
+    await safeDbDDL(db, sql);
+  }
+}
+function createPolymarketExecutionTools(options) {
+  const db = options.engineDb;
+  const agentId = options.agentId || "default";
+  let dbReady = false;
+  async function ensureDB() {
+    if (dbReady || !db) return;
+    await initExecutionDB(db);
+    dbReady = true;
+  }
+  const tools = [];
+  tools.push({
+    name: "poly_sniper",
+    label: "Sniper Order",
+    description: "Smart limit order that auto-adjusts. Set a target price and the sniper will trail the best bid/ask by a small amount, automatically adjusting the limit price to stay competitive. Cancels if price hits a ceiling. Perfect for accumulating at the best possible price.",
+    category: "enterprise",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "cancel", "status"], description: "Action to perform" },
+        id: { type: "string", description: "Sniper order ID (for cancel/status)" },
+        token_id: { type: "string", description: "Token ID (for create)" },
+        side: { type: "string", enum: ["BUY", "SELL"], description: "Order side" },
+        target_price: { type: "number", description: "Target price to buy/sell at" },
+        max_price: { type: "number", description: "Maximum price willing to pay (for BUY) or minimum to accept (for SELL)" },
+        trail_amount: { type: "number", description: "How much to trail best bid/ask by (default: 0.01)", default: 0.01 },
+        size_usdc: { type: "number", description: "Total USDC to spend" },
+        cancel_price: { type: "number", description: "Auto-cancel if price reaches this level" }
+      },
+      required: ["action"]
+    },
+    execute: async (params) => {
+      await ensureDB();
+      if (!db) return errorResult("No DB available");
+      const action = params.action;
+      if (action === "create") {
+        if (!params.token_id || !params.side || !params.target_price || !params.size_usdc) {
+          return errorResult("token_id, side, target_price, and size_usdc required");
+        }
+        const id = `snipe_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        try {
+          await safeDbExec(
+            db,
+            `INSERT INTO poly_sniper_orders (id, agent_id, token_id, side, target_price, max_price, trail_amount, size_usdc, cancel_price)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            id,
+            agentId,
+            params.token_id,
+            params.side,
+            params.target_price,
+            params.max_price || null,
+            params.trail_amount || 0.01,
+            params.size_usdc,
+            params.cancel_price || null
+          );
+          let currentBook = null;
+          try {
+            const book = await cachedFetchJSON(`${CLOB_API2}/book?token_id=${params.token_id}`);
+            const bestBid = Math.max(...(book?.bids || []).map((b) => parseFloat(b.price)));
+            const bestAsk = Math.min(...(book?.asks || []).map((a) => parseFloat(a.price)));
+            currentBook = { bestBid, bestAsk, spread: +(bestAsk - bestBid).toFixed(4) };
+          } catch {
+          }
+          return jsonResult({
+            created: id,
+            token_id: params.token_id,
+            side: params.side,
+            target_price: params.target_price,
+            max_price: params.max_price,
+            trail_amount: params.trail_amount || 0.01,
+            size_usdc: params.size_usdc,
+            cancel_price: params.cancel_price,
+            current_book: currentBook,
+            note: "Sniper order created. In production, this would monitor the orderbook and auto-adjust your limit order. Currently tracked in DB \u2014 use poly_sniper with action=status to check. Execute manually or wait for the automated execution loop.",
+            execution_strategy: params.side === "BUY" ? `Will place limit bid at best_bid + ${params.trail_amount}. If price drops to ${params.target_price}, will fill. Cancels if price hits ${params.cancel_price || "never"}.` : `Will place limit ask at best_ask - ${params.trail_amount}. If price rises to ${params.target_price}, will fill. Cancels if price hits ${params.cancel_price || "never"}.`
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "cancel") {
+        if (!params.id) return errorResult("id required");
+        try {
+          await safeDbExec(
+            db,
+            "UPDATE poly_sniper_orders SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP WHERE id = ? AND agent_id = ?",
+            params.id,
+            agentId
+          );
+          return jsonResult({ cancelled: params.id });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "status") {
+        if (!params.id) return errorResult("id required");
+        try {
+          const row = await safeDbGet(db, "SELECT * FROM poly_sniper_orders WHERE id = ? AND agent_id = ?", params.id, agentId);
+          if (!row) return errorResult("Sniper order not found");
+          return jsonResult(row);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      try {
+        const rows = await safeDbQuery(db, "SELECT * FROM poly_sniper_orders WHERE agent_id = ? AND status = 'active' ORDER BY created_at DESC", agentId);
+        return jsonResult({ active_snipers: rows, total: rows.length });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  tools.push({
+    name: "poly_scale_in",
+    label: "Scale In (TWAP/VWAP)",
+    description: "Execute a large order by splitting it into smaller slices over time (TWAP) or proportional to volume (VWAP). Minimizes market impact when building or unwinding large positions. Essential for $1000+ orders in thin markets.",
+    category: "enterprise",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "cancel", "status"], description: "Action" },
+        id: { type: "string", description: "Scale order ID (for cancel/status)" },
+        token_id: { type: "string", description: "Token ID (for create)" },
+        side: { type: "string", enum: ["BUY", "SELL"], description: "Order side" },
+        total_size: { type: "number", description: "Total USDC to trade" },
+        slices: { type: "number", description: "Number of slices (default: 10)", default: 10 },
+        interval_minutes: { type: "number", description: "Minutes between slices (default: 5)", default: 5 },
+        strategy: { type: "string", enum: ["twap", "vwap", "aggressive", "passive"], default: "twap" }
+      },
+      required: ["action"]
+    },
+    execute: async (params) => {
+      await ensureDB();
+      if (!db) return errorResult("No DB available");
+      const action = params.action;
+      if (action === "create") {
+        if (!params.token_id || !params.side || !params.total_size) {
+          return errorResult("token_id, side, and total_size required");
+        }
+        const slices = params.slices || 10;
+        const intervalSec = (params.interval_minutes || 5) * 60;
+        const sliceSize = params.total_size / slices;
+        const id = `scale_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        try {
+          await safeDbExec(
+            db,
+            `INSERT INTO poly_scale_orders (id, agent_id, token_id, side, total_size, slices, interval_seconds, strategy)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            id,
+            agentId,
+            params.token_id,
+            params.side,
+            params.total_size,
+            slices,
+            intervalSec,
+            params.strategy || "twap"
+          );
+          const totalDuration = slices * (params.interval_minutes || 5);
+          return jsonResult({
+            created: id,
+            token_id: params.token_id,
+            side: params.side,
+            total_size: params.total_size,
+            slices,
+            slice_size: +sliceSize.toFixed(2),
+            interval_minutes: params.interval_minutes || 5,
+            strategy: params.strategy || "twap",
+            estimated_duration_minutes: totalDuration,
+            schedule: Array.from({ length: Math.min(slices, 10) }, (_, i) => ({
+              slice: i + 1,
+              size_usdc: +sliceSize.toFixed(2),
+              execute_at: `+${i * (params.interval_minutes || 5)}min`
+            })),
+            note: `Scale-in plan created. ${slices} slices of $${sliceSize.toFixed(2)} every ${params.interval_minutes || 5} minutes = ${totalDuration} minutes total. Execute each slice using poly_place_order or set up a cron job for automated execution.`
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "cancel") {
+        if (!params.id) return errorResult("id required");
+        try {
+          await safeDbExec(db, "UPDATE poly_scale_orders SET status = 'cancelled' WHERE id = ? AND agent_id = ?", params.id, agentId);
+          return jsonResult({ cancelled: params.id });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "status") {
+        if (!params.id) return errorResult("id required");
+        try {
+          const row = await safeDbGet(db, "SELECT * FROM poly_scale_orders WHERE id = ? AND agent_id = ?", params.id, agentId);
+          if (!row) return errorResult("Scale order not found");
+          const remaining = row.slices - row.completed_slices;
+          return jsonResult({
+            ...row,
+            remaining_slices: remaining,
+            remaining_usdc: +(row.total_size - row.filled_size).toFixed(2),
+            progress_pct: +(row.completed_slices / row.slices * 100).toFixed(1)
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      try {
+        const rows = await safeDbQuery(db, "SELECT * FROM poly_scale_orders WHERE agent_id = ? AND status = 'active' ORDER BY created_at DESC", agentId);
+        return jsonResult({ active_scales: rows, total: rows.length });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  tools.push({
+    name: "poly_hedge",
+    label: "Hedge Position",
+    description: "Create a hedge by taking an opposing position in a correlated market. Reduces directional risk while capturing spread between related markets. Specify the primary and hedge tokens with a ratio.",
+    category: "enterprise",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "close", "analyze"], description: "Action" },
+        id: { type: "string", description: "Hedge ID (for close)" },
+        primary_token: { type: "string", description: "Primary position token ID" },
+        hedge_token: { type: "string", description: "Hedge token ID (correlated market)" },
+        primary_side: { type: "string", enum: ["BUY", "SELL"], description: "Primary position side" },
+        primary_size: { type: "number", description: "Primary position size in USDC" },
+        hedge_ratio: { type: "number", description: "Hedge ratio (0.5 = half hedge, 1.0 = full hedge, default: 0.5)", default: 0.5 }
+      },
+      required: ["action"]
+    },
+    execute: async (params) => {
+      await ensureDB();
+      if (!db) return errorResult("No DB available");
+      const action = params.action;
+      if (action === "create") {
+        if (!params.primary_token || !params.hedge_token || !params.primary_side || !params.primary_size) {
+          return errorResult("primary_token, hedge_token, primary_side, primary_size required");
+        }
+        const hedgeRatio = params.hedge_ratio || 0.5;
+        const hedgeSide = params.primary_side === "BUY" ? "SELL" : "BUY";
+        const hedgeSize = +(params.primary_size * hedgeRatio).toFixed(2);
+        const id = `hedge_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        try {
+          await safeDbExec(
+            db,
+            `INSERT INTO poly_hedges (id, agent_id, primary_token, hedge_token, primary_side, hedge_side, primary_size, hedge_size, hedge_ratio)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            id,
+            agentId,
+            params.primary_token,
+            params.hedge_token,
+            params.primary_side,
+            hedgeSide,
+            params.primary_size,
+            hedgeSize,
+            hedgeRatio
+          );
+          return jsonResult({
+            created: id,
+            primary: { token: params.primary_token, side: params.primary_side, size: params.primary_size },
+            hedge: { token: params.hedge_token, side: hedgeSide, size: hedgeSize },
+            hedge_ratio: hedgeRatio,
+            net_exposure: +(params.primary_size - hedgeSize).toFixed(2),
+            note: "Hedge plan created. Execute both legs: (1) poly_place_order for primary, (2) poly_place_order for hedge. The hedge reduces your directional risk by " + (hedgeRatio * 100).toFixed(0) + "%."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "analyze") {
+        if (!params.primary_token || !params.hedge_token) return errorResult("primary_token and hedge_token required");
+        try {
+          const [book1, book2] = await Promise.all([
+            cachedFetchJSON(`${CLOB_API2}/book?token_id=${params.primary_token}`).catch(() => null),
+            cachedFetchJSON(`${CLOB_API2}/book?token_id=${params.hedge_token}`).catch(() => null)
+          ]);
+          const mid1 = book1 ? (Math.max(...(book1.bids || []).map((b) => parseFloat(b.price))) + Math.min(...(book1.asks || []).map((a) => parseFloat(a.price)))) / 2 : 0;
+          const mid2 = book2 ? (Math.max(...(book2.bids || []).map((b) => parseFloat(b.price))) + Math.min(...(book2.asks || []).map((a) => parseFloat(a.price)))) / 2 : 0;
+          return jsonResult({
+            primary: { token: params.primary_token, mid_price: +mid1.toFixed(4) },
+            hedge: { token: params.hedge_token, mid_price: +mid2.toFixed(4) },
+            price_spread: +Math.abs(mid1 - mid2).toFixed(4),
+            recommended_ratio: mid1 > 0 && mid2 > 0 ? +(mid1 / mid2).toFixed(2) : 0.5,
+            note: "If tokens are from the same market (YES/NO), optimal hedge ratio is the price ratio. If from correlated markets, use poly_market_correlation first."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "close") {
+        if (!params.id) return errorResult("id required");
+        try {
+          await safeDbExec(db, "UPDATE poly_hedges SET status = 'closed' WHERE id = ? AND agent_id = ?", params.id, agentId);
+          return jsonResult({ closed: params.id, note: "Hedge marked as closed. Unwind both legs manually using poly_place_order." });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      try {
+        const rows = await safeDbQuery(db, "SELECT * FROM poly_hedges WHERE agent_id = ? AND status = 'active' ORDER BY created_at DESC", agentId);
+        return jsonResult({ active_hedges: rows, total: rows.length });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  tools.push({
+    name: "poly_exit_strategy",
+    label: "Exit Strategy",
+    description: "Set automated exit rules for a position: take-profit, stop-loss, trailing stop, and time-based exits. When a condition triggers, the tool flags the position for immediate action. Never hold a position without an exit plan.",
+    category: "enterprise",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "remove", "check"], description: "Action" },
+        id: { type: "string", description: "Exit rule ID (for remove)" },
+        token_id: { type: "string", description: "Token ID (for create/check)" },
+        entry_price: { type: "number", description: "Your entry price" },
+        position_size: { type: "number", description: "Position size in shares" },
+        take_profit: { type: "number", description: "Take profit price" },
+        stop_loss: { type: "number", description: "Stop loss price" },
+        trailing_stop_pct: { type: "number", description: "Trailing stop as % from highest price (e.g., 10 = 10%)" },
+        time_exit: { type: "string", description: 'Time-based exit: ISO date or relative like "24h", "7d"' }
+      },
+      required: ["action"]
+    },
+    execute: async (params) => {
+      await ensureDB();
+      if (!db) return errorResult("No DB available");
+      const action = params.action;
+      if (action === "create") {
+        if (!params.token_id || !params.entry_price) return errorResult("token_id and entry_price required");
+        if (!params.take_profit && !params.stop_loss && !params.trailing_stop_pct && !params.time_exit) {
+          return errorResult("At least one exit condition required: take_profit, stop_loss, trailing_stop_pct, or time_exit");
+        }
+        const id = `exit_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        let timeExit = params.time_exit || null;
+        if (timeExit && !timeExit.includes("T")) {
+          const match = timeExit.match(/^(\d+)(h|d|m)$/);
+          if (match) {
+            const ms = parseInt(match[1]) * (match[2] === "h" ? 36e5 : match[2] === "d" ? 864e5 : 6e4);
+            timeExit = new Date(Date.now() + ms).toISOString();
+          }
+        }
+        try {
+          await safeDbExec(
+            db,
+            `INSERT INTO poly_exit_rules (id, agent_id, token_id, entry_price, position_size, take_profit, stop_loss, trailing_stop_pct, time_exit, highest_price)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            id,
+            agentId,
+            params.token_id,
+            params.entry_price,
+            params.position_size || 0,
+            params.take_profit || null,
+            params.stop_loss || null,
+            params.trailing_stop_pct || null,
+            timeExit,
+            params.entry_price
+          );
+          return jsonResult({
+            created: id,
+            token_id: params.token_id,
+            entry_price: params.entry_price,
+            rules: {
+              take_profit: params.take_profit || null,
+              stop_loss: params.stop_loss || null,
+              trailing_stop_pct: params.trailing_stop_pct || null,
+              time_exit: timeExit
+            },
+            note: "Exit rules set. Check triggers periodically with action=check, or set up a heartbeat/cron to auto-check."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "check") {
+        try {
+          const rules = params.token_id ? await safeDbQuery(db, "SELECT * FROM poly_exit_rules WHERE agent_id = ? AND token_id = ? AND status = 'active'", agentId, params.token_id) : await safeDbQuery(db, "SELECT * FROM poly_exit_rules WHERE agent_id = ? AND status = 'active'", agentId);
+          if (!rules.length) return jsonResult({ triggers: [], note: "No active exit rules" });
+          const triggers = [];
+          const tokenIds = [...new Set(rules.map((r) => r.token_id))];
+          const prices = {};
+          await Promise.all(tokenIds.map(async (tid) => {
+            try {
+              const book = await cachedFetchJSON(`${CLOB_API2}/book?token_id=${tid}`);
+              const bestBid = Math.max(...(book?.bids || []).map((b) => parseFloat(b.price)), 0);
+              const bestAsk = Math.min(...(book?.asks || []).map((a) => parseFloat(a.price)), 1);
+              prices[tid] = (bestBid + bestAsk) / 2;
+            } catch {
+            }
+          }));
+          const now = /* @__PURE__ */ new Date();
+          for (const rule of rules) {
+            const currentPrice = prices[rule.token_id];
+            if (!currentPrice) continue;
+            if (currentPrice > (rule.highest_price || 0)) {
+              try {
+                await safeDbExec(db, "UPDATE poly_exit_rules SET highest_price = ? WHERE id = ?", currentPrice, rule.id);
+              } catch {
+              }
+            }
+            if (rule.take_profit && currentPrice >= rule.take_profit) {
+              triggers.push({
+                id: rule.id,
+                type: "TAKE_PROFIT",
+                token_id: rule.token_id,
+                trigger_price: rule.take_profit,
+                current_price: currentPrice,
+                entry_price: rule.entry_price,
+                pnl_pct: +((currentPrice - rule.entry_price) / rule.entry_price * 100).toFixed(2),
+                action: "SELL NOW \u2014 Take profit target reached"
+              });
+            }
+            if (rule.stop_loss && currentPrice <= rule.stop_loss) {
+              triggers.push({
+                id: rule.id,
+                type: "STOP_LOSS",
+                token_id: rule.token_id,
+                trigger_price: rule.stop_loss,
+                current_price: currentPrice,
+                entry_price: rule.entry_price,
+                pnl_pct: +((currentPrice - rule.entry_price) / rule.entry_price * 100).toFixed(2),
+                action: "SELL NOW \u2014 Stop loss triggered"
+              });
+            }
+            if (rule.trailing_stop_pct && rule.highest_price) {
+              const trailPrice = rule.highest_price * (1 - rule.trailing_stop_pct / 100);
+              if (currentPrice <= trailPrice) {
+                triggers.push({
+                  id: rule.id,
+                  type: "TRAILING_STOP",
+                  token_id: rule.token_id,
+                  highest_price: rule.highest_price,
+                  trail_pct: rule.trailing_stop_pct,
+                  trigger_price: +trailPrice.toFixed(4),
+                  current_price: currentPrice,
+                  action: `SELL NOW \u2014 Price dropped ${rule.trailing_stop_pct}% from high of ${rule.highest_price}`
+                });
+              }
+            }
+            if (rule.time_exit && new Date(rule.time_exit) <= now) {
+              triggers.push({
+                id: rule.id,
+                type: "TIME_EXIT",
+                token_id: rule.token_id,
+                time_exit: rule.time_exit,
+                current_price: currentPrice,
+                entry_price: rule.entry_price,
+                action: "SELL NOW \u2014 Time-based exit triggered"
+              });
+            }
+          }
+          return jsonResult({
+            rules_checked: rules.length,
+            triggers_fired: triggers.length,
+            triggers,
+            all_clear: triggers.length === 0
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      if (action === "remove") {
+        if (!params.id) return errorResult("id required");
+        try {
+          await safeDbExec(db, "UPDATE poly_exit_rules SET status = 'removed' WHERE id = ? AND agent_id = ?", params.id, agentId);
+          return jsonResult({ removed: params.id });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+      try {
+        const rows = await safeDbQuery(db, "SELECT * FROM poly_exit_rules WHERE agent_id = ? AND status = 'active' ORDER BY created_at DESC", agentId);
+        return jsonResult({ active_rules: rows, total: rows.length });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  return tools;
+}
+
+// src/agent-tools/tools/polymarket-social.ts
+function createPolymarketSocialTools(_opts) {
+  return [
+    {
+      name: "poly_twitter_sentiment",
+      description: "Analyze Twitter/X sentiment for a topic via Google News RSS proxy. Returns overall sentiment, mention count, and topics detected.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          include_polymarket: { type: "boolean", description: 'Also search with "polymarket" appended', default: true }
+        },
+        required: ["query"]
+      },
+      async execute(_id, p) {
+        try {
+          const raw = await analyzeTwitterSentiment(p.query, p.include_polymarket);
+          return jsonResult({
+            query: raw.query,
+            overall_sentiment: raw.overall_sentiment,
+            sentiment_label: raw.sentiment_label,
+            total_mentions: raw.total_mentions,
+            signal: raw.signal,
+            topics_detected: raw.topics_detected,
+            // Only top 5 items per query, title+sentiment only
+            results: (raw.results || []).map((r) => ({
+              query: r.query,
+              avg_sentiment: r.avg_sentiment,
+              volume: r.volume,
+              items: (r.items || []).slice(0, 5).map((i) => ({
+                title: i.title,
+                sentiment: i.sentiment,
+                source: i.source
+              }))
+            }))
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_polymarket_comments",
+      description: "Analyze sentiment in Polymarket market comments section. Returns bullish/bearish breakdown and top comments.",
+      parameters: {
+        type: "object",
+        properties: {
+          market_slug: { type: "string", description: "Market slug" }
+        },
+        required: ["market_slug"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzePolymarketComments(p.market_slug));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_reddit_pulse",
+      description: "Monitor Reddit discussion on a topic across subreddits. Returns sentiment, trending posts, and engagement metrics.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          subreddits: { type: "array", items: { type: "string" }, description: "Subreddits (default: polymarket, politics, sports, worldnews)" },
+          timeframe: { type: "string", enum: ["hour", "day", "week", "month"], default: "day" }
+        },
+        required: ["query"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await monitorRedditPulse(p.query, p.subreddits, p.timeframe));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_telegram_monitor",
+      description: "Monitor public Telegram channels for discussion on a topic. Scrapes recent messages and scores sentiment.",
+      parameters: {
+        type: "object",
+        properties: {
+          channels: { type: "array", items: { type: "string" }, description: "Channel handles (e.g. @polymarket_alerts)" },
+          query: { type: "string", description: "Optional filter query" },
+          limit: { type: "number", default: 20 }
+        },
+        required: ["channels"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await monitorTelegram(p.channels, p.query, p.limit));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_social_velocity",
+      description: "Measure social discussion velocity (spike detection). Compares recent vs baseline mention rates to detect surges in attention.",
+      parameters: {
+        type: "object",
+        properties: {
+          topic: { type: "string", description: "Topic to measure" },
+          compare_topic: { type: "string", description: "Optional comparison topic" }
+        },
+        required: ["topic"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await measureSocialVelocity(p.topic, p.compare_topic));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-feeds.ts
+function createPolymarketFeedsTools(opts) {
+  const getDb = () => opts?.engineDb;
+  return [
+    {
+      name: "poly_calendar_events",
+      description: "Manage an event calendar for tracking market-moving dates: add/remove/list events that could affect your positions.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["add", "remove", "list", "upcoming"], description: "Calendar action" },
+          title: { type: "string", description: "Event title (for add)" },
+          date: { type: "string", description: "Event date ISO (for add)" },
+          category: { type: "string", description: "Category: politics, sports, crypto, economics, legal, other" },
+          market_slugs: { type: "array", items: { type: "string" }, description: "Related market slugs" },
+          notes: { type: "string", description: "Additional notes" },
+          event_id: { type: "string", description: "Event ID (for remove)" },
+          days_ahead: { type: "number", description: "Days ahead to look (for upcoming)", default: 7 }
+        },
+        required: ["action"]
+      },
+      async execute(_id, p) {
+        try {
+          const db = getDb();
+          if (!db) return errorResult("No database available");
+          await safeDbDDL(db, `CREATE TABLE IF NOT EXISTS poly_calendar_events (
+            id TEXT PRIMARY KEY, title TEXT NOT NULL, event_date TEXT NOT NULL,
+            category TEXT DEFAULT 'other', market_slugs TEXT, notes TEXT,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+          )`);
+          if (p.action === "add") {
+            if (!p.title || !p.date) return errorResult("Need title and date");
+            const id = `evt_${Date.now()}`;
+            await safeDbExec(
+              db,
+              `INSERT INTO poly_calendar_events (id, title, event_date, category, market_slugs, notes) VALUES (?, ?, ?, ?, ?, ?)`,
+              [id, p.title, p.date, p.category || "other", JSON.stringify(p.market_slugs || []), p.notes || ""]
+            );
+            return jsonResult({ id, title: p.title, date: p.date, status: "added" });
+          }
+          if (p.action === "remove") {
+            if (!p.event_id) return errorResult("Need event_id");
+            await safeDbExec(db, `DELETE FROM poly_calendar_events WHERE id = ?`, [p.event_id]);
+            return jsonResult({ id: p.event_id, status: "removed" });
+          }
+          if (p.action === "upcoming") {
+            const days = p.days_ahead || 7;
+            const rows2 = await safeDbQuery(db, `SELECT * FROM poly_calendar_events WHERE event_date >= CURRENT_DATE AND event_date <= CURRENT_DATE + INTERVAL '${days} days' ORDER BY event_date`);
+            return jsonResult({ upcoming: rows2, days_ahead: days });
+          }
+          const rows = await safeDbQuery(db, `SELECT * FROM poly_calendar_events ORDER BY event_date DESC LIMIT 50`);
+          return jsonResult({ events: rows, total: rows.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_official_sources",
+      description: "Fetch data from official sources: whitehouse, scotus, sec, fed, espn, noaa, congress, or any custom RSS/Atom URL.",
+      parameters: {
+        type: "object",
+        properties: {
+          source: { type: "string", description: 'Source name or "custom"', enum: ["whitehouse", "scotus", "sec", "fed", "espn", "noaa", "congress", "custom"] },
+          query: { type: "string", description: "Filter results by keyword" },
+          custom_url: { type: "string", description: "Custom RSS/Atom URL (when source=custom)" }
+        },
+        required: ["source"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await fetchOfficialSource(p.source, p.query, p.custom_url));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_odds_aggregator",
+      description: "Compare Polymarket odds against external sources. Finds divergences between Polymarket pricing and other platforms.",
+      parameters: {
+        type: "object",
+        properties: {
+          market_question: { type: "string", description: "Market question to search for" },
+          polymarket_price: { type: "number", description: "Current Polymarket YES price" }
+        },
+        required: ["market_question"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await compareOdds(p.market_question, p.polymarket_price));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_resolution_tracker",
+      description: "Track resolution details for a market: source URLs, resolution type, criteria clarity, and risk factors.",
+      parameters: {
+        type: "object",
+        properties: {
+          market_slug: { type: "string", description: "Market slug" },
+          condition_id: { type: "string", description: "Or condition ID" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await trackResolution(p.market_slug, p.condition_id));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_breaking_news",
+      description: "Fetch breaking news from AP, Reuters, BBC, CNN. Filter by topics and time window. Scores market relevance.",
+      parameters: {
+        type: "object",
+        properties: {
+          topics: { type: "array", items: { type: "string" }, description: "Topic keywords to filter" },
+          sources: { type: "array", items: { type: "string" }, description: "Sources: ap, reuters, bbc, cnn" },
+          since_minutes: { type: "number", description: "Look back N minutes", default: 60 }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await fetchBreakingNews(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-onchain.ts
+function createPolymarketOnchainTools(_opts) {
+  return [
+    {
+      name: "poly_whale_tracker",
+      description: "Track large trades (whale activity) on a specific token. Identifies significant buy/sell orders and unique whale wallets.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to track" },
+          min_size: { type: "number", description: "Minimum trade value in USDC to classify as whale", default: 1e3 }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await scanWhaleTrades(p.token_id, p.min_size));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_orderbook_depth",
+      description: "Deep orderbook analysis: bid/ask depth at multiple levels, wall detection, spoofing indicators, and imbalance signals.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeOrderbookDepth(p.token_id));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_onchain_flow",
+      description: "Analyze buy/sell flow over multiple time windows (5m, 15m, 1h, 4h, 24h). Detects net buying or selling pressure.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          windows: { type: "array", items: { type: "string" }, description: "Time windows (default: 1h, 4h, 24h)" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeFlow(p.token_id, p.windows));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_wallet_profiler",
+      description: "Profile a wallet address: total trades, volume, buy/sell ratio, unique markets, and recent activity.",
+      parameters: {
+        type: "object",
+        properties: {
+          wallet: { type: "string", description: "Wallet address to profile" },
+          token_id: { type: "string", description: "Optional: filter to specific token" }
+        },
+        required: ["wallet"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await profileWallet(p.wallet, p.token_id));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_liquidity_map",
+      description: "Map liquidity across multiple tokens. Ranks by spread tightness and depth. Identifies best and worst markets to trade.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_ids: { type: "array", items: { type: "string" }, description: "Token IDs to compare" }
+        },
+        required: ["token_ids"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await mapLiquidity(p.token_ids));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_transaction_decoder",
+      description: "Decode a Polygon transaction or list wallet transactions. Identifies Polymarket CTF interactions (position transfers, minting, redemption).",
+      parameters: {
+        type: "object",
+        properties: {
+          tx_hash: { type: "string", description: "Transaction hash to decode" },
+          wallet: { type: "string", description: "Or list wallet transactions" },
+          limit: { type: "number", description: "Max transactions (for wallet mode)", default: 20 }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          if (p.tx_hash) return jsonResult(await decodeTransaction(p.tx_hash));
+          if (p.wallet) return jsonResult(await getWalletTransactions(p.wallet, p.limit));
+          return errorResult("Provide tx_hash or wallet");
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-analytics.ts
+function createPolymarketAnalyticsTools(_opts) {
+  return [
+    {
+      name: "poly_market_correlation",
+      description: "Find price correlations between prediction market tokens. Identifies hedging opportunities and correlated risks.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_ids: { type: "array", items: { type: "string" }, description: "Array of token IDs (2-10)" },
+          min_correlation: { type: "number", description: "Minimum abs correlation to report", default: 0.5 }
+        },
+        required: ["token_ids"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await findCorrelations(p.token_ids, p.min_correlation));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_arbitrage_scanner",
+      description: "Scan for arbitrage opportunities: YES+NO != $1, multi-outcome mispricings, cross-market divergence.",
+      parameters: {
+        type: "object",
+        properties: {
+          market_slugs: { type: "array", items: { type: "string" }, description: "Specific markets to scan (or omit for top markets)" },
+          scan_type: { type: "string", enum: ["yes_no", "cross_market", "multi_outcome", "all"], default: "all" },
+          min_profit_pct: { type: "number", description: "Minimum profit % to flag", default: 0.5 }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await scanArbitrage(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_regime_detector",
+      description: "Detect market regime: TRENDING, MEAN_REVERTING, or RANDOM_WALK using Hurst exponent and trend analysis. Returns regime-specific trading strategies.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          lookback: { type: "number", description: "Data points to analyze", default: 72 }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await detectRegime(p.token_id, p.lookback));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_smart_money_index",
+      description: "Calculate a composite Smart Money Index combining orderbook imbalance, trade flow direction, price momentum, and news sentiment.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          market_question: { type: "string", description: "Market question (for news sentiment component)" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateSmartMoneyIndex(p.token_id, p.market_question));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_market_microstructure",
+      description: "Analyze market microstructure: spread, depth, slippage simulation for various order sizes, and optimal order type recommendation.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          order_sizes: { type: "array", items: { type: "number" }, description: "USDC sizes to simulate (default: [100, 500, 1000, 5000])" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeMicrostructure(p.token_id, p.order_sizes));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-portfolio.ts
+function createPolymarketPortfolioTools(opts) {
+  const getDb = () => opts?.engineDb;
+  return [
+    {
+      name: "poly_portfolio_optimizer",
+      description: "Analyze portfolio: current values, P&L, concentration (HHI), risk metrics. Uses Kelly criterion for optimal position sizing.",
+      parameters: {
+        type: "object",
+        properties: {
+          positions: {
+            type: "array",
+            description: "Array: { token_id, market, outcome, size, avg_price }",
+            items: { type: "object" }
+          },
+          bankroll: { type: "number", description: "Total available capital" },
+          estimated_true_probs: {
+            type: "object",
+            description: "Map of token_id -> your estimated true probability"
+          }
+        },
+        required: ["positions"]
+      },
+      async execute(_id, p) {
+        try {
+          const overview = await analyzePortfolio(p.positions);
+          let kellySizing = null;
+          if (p.bankroll && p.estimated_true_probs) {
+            const kellyInput = p.positions.map((pos) => {
+              const enriched = overview.positions.find((ep) => ep.token_id === pos.token_id);
+              return {
+                token_id: pos.token_id,
+                market: pos.market,
+                current_price: enriched?.current_price || pos.avg_price,
+                estimated_true_prob: p.estimated_true_probs[pos.token_id] || enriched?.current_price || pos.avg_price
+              };
+            });
+            kellySizing = calculatePortfolioKelly(kellyInput, p.bankroll);
+          }
+          return jsonResult({ overview, kelly_sizing: kellySizing });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_drawdown_monitor",
+      description: "Monitor portfolio drawdown over time. Records snapshots and alerts when drawdown exceeds thresholds.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["record", "status", "history"], description: "Action to take" },
+          current_value: { type: "number", description: "Current portfolio value (for record)" },
+          alert_threshold: { type: "number", description: "Alert if drawdown exceeds this %", default: 10 }
+        },
+        required: ["action"]
+      },
+      async execute(_id, p) {
+        try {
+          const db = getDb();
+          if (!db) return errorResult("No database available");
+          await safeDbDDL(db, `CREATE TABLE IF NOT EXISTS poly_drawdown_log (
+            id SERIAL PRIMARY KEY, value REAL NOT NULL, peak REAL NOT NULL,
+            drawdown_pct REAL NOT NULL, recorded_at TIMESTAMPTZ DEFAULT NOW()
+          )`);
+          if (p.action === "record") {
+            if (!p.current_value) return errorResult("Need current_value");
+            const rows2 = await safeDbQuery(db, `SELECT MAX(peak) as max_peak FROM poly_drawdown_log`);
+            const prevPeak = rows2[0]?.max_peak || p.current_value;
+            const peak = Math.max(prevPeak, p.current_value);
+            const drawdown = peak > 0 ? (peak - p.current_value) / peak * 100 : 0;
+            await safeDbExec(
+              db,
+              `INSERT INTO poly_drawdown_log (value, peak, drawdown_pct) VALUES (?, ?, ?)`,
+              [p.current_value, peak, drawdown]
+            );
+            const alert = drawdown > (p.alert_threshold || 10);
+            return jsonResult({ value: p.current_value, peak, drawdown_pct: +drawdown.toFixed(2), alert, threshold: p.alert_threshold || 10 });
+          }
+          if (p.action === "history") {
+            const rows2 = await safeDbQuery(db, `SELECT * FROM poly_drawdown_log ORDER BY recorded_at DESC LIMIT 100`);
+            return jsonResult({ history: rows2 });
+          }
+          const rows = await safeDbQuery(db, `SELECT * FROM poly_drawdown_log ORDER BY recorded_at DESC LIMIT 1`);
+          return jsonResult({ latest: rows[0] || null });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_pnl_attribution",
+      description: "Attribute P&L across trades and markets. Shows win rate, profit factor, best/worst trades, and per-market contribution.",
+      parameters: {
+        type: "object",
+        properties: {
+          trades: {
+            type: "array",
+            description: "Array: { market, pnl }",
+            items: { type: "object", properties: { market: { type: "string" }, pnl: { type: "number" } } }
+          }
+        },
+        required: ["trades"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(attributePnL(p.trades));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-quant.ts
+function createPolymarketQuantTools(_opts) {
+  return [
+    {
+      name: "poly_kelly_criterion",
+      description: "Calculate optimal position size using the Kelly Criterion. Given your estimated true probability and market price, returns the mathematically optimal fraction of bankroll to bet. Also returns half-Kelly and quarter-Kelly (more conservative). Formula: f* = (p\xB7b - q) / b where b = (1/price - 1), p = true probability, q = 1-p.",
+      parameters: {
+        type: "object",
+        properties: {
+          true_probability: { type: "number", description: "Your estimated true probability of the outcome (0-1)" },
+          market_price: { type: "number", description: "Current market price (0-1). If omitted, fetched from token_id." },
+          token_id: { type: "string", description: "Token ID to fetch live price" },
+          bankroll: { type: "number", description: "Total available capital (USDC)" },
+          max_fraction: { type: "number", description: "Max fraction of bankroll per bet (risk cap)", default: 0.25 }
+        },
+        required: ["true_probability"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateKelly(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_binary_pricing",
+      description: "Price a prediction market outcome as a binary option using Black-Scholes framework. Returns theoretical fair value, Greeks (delta, gamma, theta, vega), and mispricing analysis.",
+      parameters: {
+        type: "object",
+        properties: {
+          current_price: { type: "number", description: "Current market price (0-1)" },
+          token_id: { type: "string", description: "Or fetch from token" },
+          time_to_expiry_hours: { type: "number", description: "Hours until market resolves" },
+          end_date: { type: "string", description: "Or provide end date (ISO)" },
+          volatility: { type: "number", description: "Annualized volatility (0-5). If omitted, estimated." },
+          true_probability: { type: "number", description: "Your estimated true probability (for mispricing analysis)" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await priceBinaryOption(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_bayesian_update",
+      description: "Update probability estimates using Bayes theorem when new evidence arrives. Start with a prior, add evidence with likelihood ratios, get posterior probability.",
+      parameters: {
+        type: "object",
+        properties: {
+          prior: { type: "number", description: "Prior probability (0-1). Use current market price or your belief." },
+          token_id: { type: "string", description: "Or fetch current price as prior" },
+          evidence: {
+            type: "array",
+            description: "Array of evidence objects: { description, likelihood_if_true, likelihood_if_false } OR { description, likelihood_ratio }",
+            items: {
+              type: "object",
+              properties: {
+                description: { type: "string" },
+                likelihood_if_true: { type: "number" },
+                likelihood_if_false: { type: "number" },
+                likelihood_ratio: { type: "number" }
+              }
+            }
+          }
+        },
+        required: ["evidence"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await bayesianUpdate(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_monte_carlo",
+      description: "Run Monte Carlo simulation on prediction market positions. Simulates thousands of outcomes for expected P&L distribution, probability of profit, VaR, and optimal exits.",
+      parameters: {
+        type: "object",
+        properties: {
+          positions: {
+            type: "array",
+            description: "Array of positions: { token_id, side, entry_price, size, true_probability? }",
+            items: { type: "object" }
+          },
+          simulations: { type: "number", description: "Number of paths (default 10000)", default: 1e4 },
+          time_horizon_hours: { type: "number", description: "Simulation horizon in hours", default: 24 },
+          volatility: { type: "number", description: "Annualized volatility override" },
+          correlation: { type: "number", description: "Assumed correlation between positions", default: 0 }
+        },
+        required: ["positions"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await runMonteCarlo(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_technical_indicators",
+      description: "Calculate technical analysis indicators: RSI, MACD, Bollinger Bands, EMA crossovers, rate of change, and trend strength. Adapted for 0-1 bounded prediction market prices.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          prices: { type: "array", items: { type: "number" }, description: "Or provide price array" },
+          indicators: { type: "array", items: { type: "string" }, description: "Which indicators (default: all)" },
+          rsi_period: { type: "number", default: 14 },
+          macd_fast: { type: "number", default: 12 },
+          macd_slow: { type: "number", default: 26 },
+          macd_signal: { type: "number", default: 9 },
+          bollinger_period: { type: "number", default: 20 },
+          bollinger_std: { type: "number", default: 2 }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateTechnicalIndicators(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_volatility",
+      description: "Comprehensive volatility analysis: realized volatility, EWMA, volatility term structure, Hurst exponent to determine if market is trending (H>0.5), mean-reverting (H<0.5), or random walk (H\u22480.5).",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          prices: { type: "array", items: { type: "number" }, description: "Or provide prices directly" },
+          windows: { type: "array", items: { type: "number" }, description: "Volatility windows (default: [5, 10, 20, 50])" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeVolatility(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_stat_arb",
+      description: "Statistical arbitrage analysis between two related markets. Tests cointegration, calculates spread z-score, generates mean-reversion trading signals.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id_1: { type: "string", description: "First token ID" },
+          token_id_2: { type: "string", description: "Second token ID" },
+          lookback: { type: "number", default: 50 },
+          entry_zscore: { type: "number", default: 2 },
+          exit_zscore: { type: "number", default: 0.5 }
+        },
+        required: ["token_id_1", "token_id_2"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeStatArb(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_value_at_risk",
+      description: "Calculate VaR and CVaR (Expected Shortfall) for positions. Uses parametric, historical, and Cornish-Fisher methods.",
+      parameters: {
+        type: "object",
+        properties: {
+          positions: { type: "array", description: "Array: { token_id, size, entry_price?, side? }", items: { type: "object" } },
+          confidence: { type: "number", default: 0.95 },
+          horizon_hours: { type: "number", default: 24 },
+          method: { type: "string", enum: ["parametric", "historical", "cornish_fisher", "all"], default: "all" }
+        },
+        required: ["positions"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateVaR(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_entropy",
+      description: "Calculate Shannon entropy and information-theoretic measures for market probability distributions. Higher entropy = more uncertainty = potentially more trading opportunity.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          probabilities: { type: "array", items: { type: "number" }, description: "Or provide probabilities directly" },
+          market_slug: { type: "string", description: "Or fetch from market slug" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateEntropy(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_news_feed",
+      description: "Fetch and analyze news articles related to a market topic. Scores sentiment, extracts key entities, and assesses potential market impact.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query (market question or topic)" },
+          sources: { type: "array", items: { type: "string" }, description: "News sources to check" },
+          max_results: { type: "number", default: 20 }
+        },
+        required: ["query"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await fetchNewsFeed(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_sentiment_analysis",
+      description: "Analyze sentiment of text, headlines, or market comments. Returns sentiment score (-1 to 1), confidence, and key phrases detected.",
+      parameters: {
+        type: "object",
+        properties: {
+          texts: { type: "array", items: { type: "string" }, description: "Array of texts to analyze" },
+          text: { type: "string", description: "Or single text" },
+          context: { type: "string", description: "Market context for better scoring" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeSentiment(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_generate_signal",
+      description: "Generate a composite trading signal combining orderbook, technicals, momentum, mean-reversion, fundamental edge, and volume analysis. Returns overall signal with confidence.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          market_id: { type: "string", description: "Market/condition ID" },
+          true_probability: { type: "number", description: "Your estimated true probability" },
+          bankroll: { type: "number", description: "Available capital" },
+          risk_tolerance: { type: "string", enum: ["conservative", "moderate", "aggressive"], default: "moderate" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await generateCompositeSignal(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_correlation_matrix",
+      description: "Calculate correlation matrix between multiple prediction market tokens. Identifies diversification opportunities and correlated risks.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_ids: { type: "array", items: { type: "string" }, description: "Array of token IDs (2-10)" },
+          lookback: { type: "number", description: "Data points to use", default: 100 }
+        },
+        required: ["token_ids"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await calculateCorrelationMatrix(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_efficiency_test",
+      description: "Test if a prediction market is informationally efficient. Uses runs test, autocorrelation, variance ratio, and entropy analysis.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to test" },
+          prices: { type: "array", items: { type: "number" }, description: "Or provide prices" },
+          lookback: { type: "number", default: 100 }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await testMarketEfficiency(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-counterintel.ts
+function createPolymarketCounterintelTools(_opts) {
+  return [
+    {
+      name: "poly_manipulation_detector",
+      description: "Detect market manipulation: wash trading, volume concentration, rapid-fire trading, price manipulation (pump/dump), and orderbook layering.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to scan" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await detectManipulation(p.token_id));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_resolution_risk",
+      description: "Assess resolution risk: ambiguous language, subjective criteria, missing sources, low liquidity, complex conditions. Scores overall risk.",
+      parameters: {
+        type: "object",
+        properties: {
+          market_slug: { type: "string", description: "Market slug" },
+          condition_id: { type: "string", description: "Or condition ID" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await assessResolutionRisk(p.market_slug, p.condition_id));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_counterparty_analysis",
+      description: "Analyze who is trading on the other side of your position. Breaks down traders into whales/mid/retail and assesses risk.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID" },
+          side: { type: "string", enum: ["BUY", "SELL"], description: "Your intended side (to analyze counterparties on opposite side)" }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await analyzeCounterparties(p.token_id, p.side));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket-pipeline.ts
+function createPolymarketPipelineTools(_opts) {
+  return [
+    {
+      name: "poly_full_analysis",
+      description: "Run the COMPLETE analysis pipeline on a market: screener \u2192 quant (Kelly, technicals, volatility, Monte Carlo, VaR) \u2192 analytics (regime, smart money, microstructure) \u2192 on-chain (orderbook, whales, flow) \u2192 social (Twitter, Reddit, velocity) \u2192 feeds (odds comparison, resolution) \u2192 counter-intel (manipulation, risk, counterparties). Returns a synthesized score (0-100), action recommendation, and detailed results from every stage.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID to analyze" },
+          market_slug: { type: "string", description: "Market slug (for resolution/risk data)" },
+          condition_id: { type: "string", description: "Condition ID" },
+          market_question: { type: "string", description: "Market question (for social/news analysis)" },
+          current_price: { type: "number", description: "Current price (auto-fetched if omitted)" },
+          bankroll: { type: "number", description: "Available capital for Kelly sizing", default: 100 },
+          estimated_true_prob: { type: "number", description: "Your estimated true probability" },
+          side: { type: "string", enum: ["BUY", "SELL"], description: "Intended trading side" },
+          skip_slow: { type: "boolean", description: "Skip social/feeds stages for speed", default: false }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await fullAnalysis({
+            tokenId: p.token_id,
+            marketSlug: p.market_slug,
+            conditionId: p.condition_id,
+            marketQuestion: p.market_question,
+            currentPrice: p.current_price,
+            bankroll: p.bankroll,
+            estimatedTrueProb: p.estimated_true_prob,
+            side: p.side,
+            skipSlow: p.skip_slow
+          }));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_quick_analysis",
+      description: "Fast analysis subset: quant + orderbook + regime + smart money + manipulation check. Returns score, action, Kelly sizing, and thesis. Use for dashboard buy modal or quick decisions.",
+      parameters: {
+        type: "object",
+        properties: {
+          token_id: { type: "string", description: "Token ID" },
+          market_question: { type: "string", description: "Market question" },
+          bankroll: { type: "number", description: "Available capital", default: 100 }
+        },
+        required: ["token_id"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await quickAnalysis(p.token_id, p.market_question, p.bankroll));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_batch_screen",
+      description: "Screen and rank multiple markets. Alias for poly_screen_markets with pipeline integration.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          limit: { type: "number", default: 10 },
+          strategy: {
+            type: "string",
+            enum: ["momentum", "contested", "best_opportunities", "high_volume", "closing_soon", "mispriced", "safe_bets", "new_markets"]
+          },
+          min_score: { type: "number", description: "Minimum score to include" }
+        }
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await batchScreen(p));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_portfolio_review",
+      description: "Complete portfolio review: overview + correlation matrix + Kelly sizing + P&L attribution + actionable recommendations.",
+      parameters: {
+        type: "object",
+        properties: {
+          positions: {
+            type: "array",
+            description: "Array: { token_id, market, outcome, size, avg_price }",
+            items: { type: "object" }
+          },
+          bankroll: { type: "number", description: "Total capital" },
+          closed_trades: {
+            type: "array",
+            description: "Array: { market, pnl } for P&L attribution",
+            items: { type: "object" }
+          }
+        },
+        required: ["positions", "bankroll"]
+      },
+      async execute(_id, p) {
+        try {
+          return jsonResult(await portfolioReview({ positions: p.positions, bankroll: p.bankroll, closedTrades: p.closed_trades }));
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/polymarket.ts
+var GAMMA_API = "https://gamma-api.polymarket.com";
+var USDC_E = USDC_ADDRESS;
+var marketCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 6e4;
+var agentConfigs = /* @__PURE__ */ new Map();
+var pendingTrades = /* @__PURE__ */ new Map();
+var dailyCounters = /* @__PURE__ */ new Map();
+var circuitBreakerState = /* @__PURE__ */ new Map();
+var _screenerTools = [];
+try {
+  _screenerTools = createPolymarketScreenerTools();
+} catch (e) {
+  console.warn("[polymarket] Screener init:", e.message);
+}
+var _pipelineTools = [];
+try {
+  _pipelineTools = createPolymarketPipelineTools();
+} catch (e) {
+  console.warn("[polymarket] Pipeline init:", e.message);
+}
+var walletState = /* @__PURE__ */ new Map();
+async function apiFetch(url, opts) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), opts?.timeoutMs || 1e4);
+  try {
+    const res = await fetch(url, { ...opts, signal: ctrl.signal });
+    if (!res.ok) {
+      const txt = await res.text().catch(() => "");
+      throw new Error(`API ${res.status}: ${txt.slice(0, 300)}`);
+    }
+    const ct = res.headers.get("content-type") || "";
+    return ct.includes("json") ? res.json() : res.text();
+  } finally {
+    clearTimeout(t);
+  }
+}
+function cached(key) {
+  const e = marketCache.get(key);
+  return e && Date.now() - e.ts < CACHE_TTL ? e.data : null;
+}
+function setCache(key, data) {
+  marketCache.set(key, { data, ts: Date.now() });
+}
+function getLocalDailyCounter(agentId) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let c = dailyCounters.get(agentId);
+  if (!c || c.date !== today) {
+    c = { count: 0, loss: 0, date: today };
+    dailyCounters.set(agentId, c);
+  }
+  return c;
+}
+function preTradeChecks(agentId, config, params) {
+  const cb = circuitBreakerState.get(agentId);
+  if (cb?.paused) return `Trading paused by circuit breaker: ${cb.reason}`;
+  if (params.size > config.maxOrderSize) return `Order size $${params.size} exceeds max order size $${config.maxOrderSize}`;
+  if (params.size > config.maxPositionSize) return `Position size $${params.size} exceeds max position size $${config.maxPositionSize}`;
+  const counter = getLocalDailyCounter(agentId);
+  if (counter.count >= config.maxDailyTrades) return `Daily trade limit (${config.maxDailyTrades}) reached`;
+  if (config.maxDailyLoss > 0 && counter.loss >= config.maxDailyLoss) {
+    circuitBreakerState.set(agentId, { paused: true, reason: "Daily loss limit hit", pausedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return `Daily loss limit ($${config.maxDailyLoss}) reached \u2014 circuit breaker activated`;
+  }
+  if (config.blockedMarkets.length > 0 && params.market_id && config.blockedMarkets.includes(params.market_id)) {
+    return `Market ${params.market_id} is blocked`;
+  }
+  return null;
+}
+async function executeOrder(agentId, db, tradeId, p, source) {
+  const sdk = await ensureSDK();
+  if (!sdk.ready) {
+    await logTrade(db, {
+      id: tradeId,
+      agentId,
+      tokenId: p.token_id,
+      marketQuestion: p.market_question,
+      outcome: p.outcome,
+      side: p.side,
+      price: p.price,
+      size: p.size,
+      status: "pending_sdk",
+      rationale: p.rationale
+    });
+    return jsonResult({
+      status: "pending_sdk",
+      trade_id: tradeId,
+      message: `Order logged. SDK installing: ${sdk.message}. Will execute when ready.`,
+      order: { tokenId: p.token_id, side: p.side, price: p.price, size: p.size },
+      persisted: true
+    });
+  }
+  const client = await getClobClient(agentId, db);
+  if (!client) {
+    await logTrade(db, {
+      id: tradeId,
+      agentId,
+      tokenId: p.token_id,
+      marketQuestion: p.market_question,
+      outcome: p.outcome,
+      side: p.side,
+      price: p.price,
+      size: p.size,
+      status: "no_wallet",
+      rationale: p.rationale
+    });
+    return errorResult("No wallet configured. Use poly_create_account or poly_setup_wallet first.");
+  }
+  try {
+    const tradingConfig = await loadConfig(agentId, db);
+    if (tradingConfig.mode === "approval" && !source.startsWith("auto_") && source !== "approved") {
+      await savePendingTrade(db, {
+        id: tradeId,
+        agentId,
+        tokenId: p.token_id,
+        marketQuestion: p.market_question || "",
+        outcome: p.outcome || "",
+        side: p.side,
+        price: p.price,
+        size: p.size,
+        rationale: p.rationale || "",
+        source
+      });
+      return jsonResult({
+        status: "pending_approval",
+        trade_id: tradeId,
+        message: `Trading mode is "approval". Order queued for review. Use poly_approve_trade to execute.`,
+        persisted: true
+      });
+    }
+    if (p.size > tradingConfig.maxOrderSize && tradingConfig.maxOrderSize > 0) {
+      return errorResult(`Order size ${p.size} exceeds max_order_size limit of ${tradingConfig.maxOrderSize}. Update config with poly_set_config.`);
+    }
+    if (p.size > tradingConfig.maxPositionSize && tradingConfig.maxPositionSize > 0) {
+      return errorResult(`Position size ${p.size} exceeds max_position_size limit of ${tradingConfig.maxPositionSize}.`);
+    }
+    const dailyCounter = await getDailyCounter(agentId, db);
+    const dailyCount = typeof dailyCounter === "number" ? dailyCounter : dailyCounter?.count || 0;
+    if (dailyCount >= tradingConfig.maxDailyTrades && tradingConfig.maxDailyTrades > 0 && !source.startsWith("auto_")) {
+      return errorResult(`Daily trade limit reached (${dailyCount}/${tradingConfig.maxDailyTrades}). Wait until tomorrow or adjust max_daily_trades.`);
+    }
+    if (tradingConfig.blockedMarkets?.length && p.market_question) {
+      const blocked = tradingConfig.blockedMarkets.some(
+        (m) => p.market_question.toLowerCase().includes(m.toLowerCase())
+      );
+      if (blocked) return errorResult(`This market is blocked by your trading config.`);
+    }
+  } catch (configErr) {
+    console.warn(`[executeOrder] Config check failed (proceeding): ${configErr.message}`);
+  }
+  if (p.side === "SELL") {
+    try {
+      const addr = client.funderAddress || client.address;
+      const positions = await fetch(`https://data-api.polymarket.com/positions?user=${addr}`, { signal: AbortSignal.timeout(8e3) }).then((r) => r.json()).catch(() => []);
+      const pos = (Array.isArray(positions) ? positions : []).find((pos2) => pos2.asset === p.token_id);
+      if (!pos || parseFloat(pos.size) <= 0) {
+        await logTrade(db, {
+          id: tradeId,
+          agentId,
+          tokenId: p.token_id,
+          marketQuestion: p.market_question,
+          outcome: p.outcome,
+          side: p.side,
+          price: p.price,
+          size: p.size,
+          status: "no_position",
+          rationale: `${p.rationale || ""} [No position found to sell]`
+        });
+        return errorResult(`Cannot SELL: no position found for this token. You may have already sold or the position was closed.`);
+      }
+      const availableShares = parseFloat(pos.size);
+      if (p.size > availableShares) {
+        console.warn(`[executeOrder] Reducing sell size from ${p.size} to ${availableShares} (available shares)`);
+        p.size = availableShares;
+      }
+    } catch (posErr) {
+      console.warn(`[executeOrder] Position pre-check failed (proceeding): ${posErr.message}`);
+    }
+  }
+  const POLY_MIN_SIZE = 5;
+  if (p.size > 0 && p.size < POLY_MIN_SIZE) {
+    if (p.size >= POLY_MIN_SIZE - 0.1) {
+      console.warn(`[executeOrder] Rounding size ${p.size} up to minimum ${POLY_MIN_SIZE}`);
+      p.size = POLY_MIN_SIZE;
+    } else {
+      await logTrade(db, {
+        id: tradeId,
+        agentId,
+        tokenId: p.token_id,
+        marketQuestion: p.market_question,
+        outcome: p.outcome,
+        side: p.side,
+        price: p.price,
+        size: p.size,
+        status: "rejected",
+        rationale: `${p.rationale || ""} [Size ${p.size} below Polymarket minimum of ${POLY_MIN_SIZE}]`
+      });
+      return errorResult(`Order size ${p.size} is below Polymarket minimum of ${POLY_MIN_SIZE} shares. Cannot execute.`);
+    }
+  }
+  try {
+    const clobModule = await importSDK("@polymarket/clob-client");
+    if (!clobModule) throw new Error("CLOB SDK not available. Run poly_check_sdk to verify installation.");
+    const { Side } = clobModule;
+    const side = p.side === "BUY" ? Side.BUY : Side.SELL;
+    const orderArgs = {
+      tokenID: p.token_id,
+      side,
+      size: p.size
+    };
+    if (p.price) orderArgs.price = p.price;
+    if (p.tick_size) orderArgs.feeRateBps = void 0;
+    if (p.neg_risk !== void 0) orderArgs.negRisk = p.neg_risk;
+    const signedOrder = await client.client.createOrder(orderArgs);
+    const response = await client.client.postOrder(signedOrder, p.order_type || "GTC");
+    const clobOrderId = response?.orderID || response?.id;
+    const orderStatus = clobOrderId ? "placed" : "rejected";
+    await logTrade(db, {
+      id: tradeId,
+      agentId,
+      tokenId: p.token_id,
+      marketQuestion: p.market_question,
+      outcome: p.outcome,
+      side: p.side,
+      price: p.price,
+      size: p.size,
+      status: orderStatus,
+      rationale: p.rationale,
+      clobOrderId: clobOrderId || null
+    });
+    if (!clobOrderId) {
+      return jsonResult({
+        status: "rejected",
+        trade_id: tradeId,
+        message: `Order submitted but no order ID returned \u2014 likely rejected by exchange.`,
+        response,
+        persisted: true
+      });
+    }
+    let bracket = null;
+    let bracketConfig = null;
+    if (p.side === "BUY") {
+      try {
+        bracketConfig = await getBracketConfig(agentId, db);
+        if (bracketConfig.enabled) {
+          const buyPrice = p.price || 0.5;
+          bracket = await createBracketAlerts(db, {
+            agentId,
+            tokenId: p.token_id,
+            marketQuestion: p.market_question || "",
+            buyPrice,
+            size: p.size,
+            takeProfitPct: bracketConfig.takeProfitPct,
+            stopLossPct: bracketConfig.stopLossPct,
+            sourceTradeId: tradeId
+          });
+        }
+      } catch (bracketErr) {
+        console.error(`[bracket] Failed to create bracket alerts: ${bracketErr.message}`);
+      }
+      try {
+        const exitId = `exit_auto_${tradeId}`;
+        const buyPrice = p.price || 0.5;
+        const trailingPct = bracketConfig.trailingStopPct || 12;
+        if (trailingPct > 0) {
+          await db.execute(`
+            INSERT INTO poly_exit_rules (id, agent_id, token_id, entry_price, position_size, trailing_stop_pct, highest_price, status)
+            VALUES ($1,$2,$3,$4,$5,$6,$7,'active')
+          `, [exitId, agentId, p.token_id, buyPrice, p.size, trailingPct, buyPrice]);
+          console.log(`[exit-rule] Auto-created trailing stop (${trailingPct}%) for BUY ${tradeId}`);
+        }
+      } catch (exitErr) {
+        console.error(`[exit-rule] Failed to create exit rule: ${exitErr.message}`);
+      }
+    }
+    let sellCleanup = null;
+    if (p.side === "SELL") {
+      try {
+        const tokenId = p.token_id;
+        const alertResult = await db.execute(
+          `UPDATE poly_price_alerts SET triggered = 1, triggered_at = NOW() WHERE agent_id = $1 AND token_id = $2 AND triggered = 0`,
+          [agentId, tokenId]
+        );
+        const exitResult = await db.execute(
+          `UPDATE poly_exit_rules SET status = 'cancelled' WHERE agent_id = $1 AND token_id = $2 AND status = 'active'`,
+          [agentId, tokenId]
+        );
+        const watcherResult = await db.execute(
+          `UPDATE poly_watchers SET status = 'paused' WHERE agent_id = $1 AND status = 'active' AND config::text LIKE $2`,
+          [agentId, `%${tokenId}%`]
+        );
+        const alertsCancelled = alertResult?.rowCount || alertResult?.changes || 0;
+        const exitsCancelled = exitResult?.rowCount || exitResult?.changes || 0;
+        const watchersPaused = watcherResult?.rowCount || watcherResult?.changes || 0;
+        if (alertsCancelled || exitsCancelled || watchersPaused) {
+          console.log(`[sell-cleanup] Token ${tokenId.slice(0, 16)}: cancelled ${alertsCancelled} alerts, ${exitsCancelled} exit rules, paused ${watchersPaused} watchers`);
+          sellCleanup = { alerts_cancelled: alertsCancelled, exit_rules_cancelled: exitsCancelled, watchers_paused: watchersPaused };
+        }
+      } catch (cleanupErr) {
+        console.warn(`[sell-cleanup] Failed: ${cleanupErr.message}`);
+      }
+    }
+    return jsonResult({
+      status: "placed",
+      trade_id: tradeId,
+      clob_order_id: clobOrderId,
+      source,
+      message: `Order placed: ${p.side} ${p.size} shares at ${p.price || "market"}`,
+      response,
+      persisted: true,
+      ...bracket ? {
+        bracket_orders: {
+          group: bracket.bracketGroup,
+          take_profit: { alert_id: bracket.takeProfitAlertId, price: bracket.takeProfitPrice },
+          stop_loss: { alert_id: bracket.stopLossAlertId, price: bracket.stopLossPrice },
+          message: `Auto-created bracket: TP@${bracket.takeProfitPrice} / SL@${bracket.stopLossPrice}`
+        }
+      } : {},
+      ...p.side === "BUY" && bracket ? {
+        exit_rules: {
+          trailing_stop: `${bracket ? bracketConfig?.trailingStopPct || 12 : 12}%`,
+          message: `Auto-created trailing stop. Tracks highest price and auto-sells if price drops from peak.`
+        }
+      } : {},
+      ...sellCleanup ? { cleanup: sellCleanup } : {}
+    });
+  } catch (e) {
+    await logTrade(db, {
+      id: tradeId,
+      agentId,
+      tokenId: p.token_id,
+      marketQuestion: p.market_question,
+      outcome: p.outcome,
+      side: p.side,
+      price: p.price,
+      size: p.size,
+      status: "failed",
+      rationale: `${p.rationale || ""} [ERROR: ${e.message}]`
+    });
+    if (e.message?.includes("not enough balance") || e.message?.includes("allowance")) {
+      return errorResult(`Order failed: insufficient balance or token allowance. Run poly_set_allowances to approve exchange contracts, then retry. Error: ${e.message}`);
+    }
+    return errorResult(`Order execution failed: ${e.message}`);
+  }
+}
+function slimMarket(m) {
+  return {
+    id: m.conditionId || m.id,
+    question: m.question,
+    slug: m.slug,
+    category: m.tags?.[0],
+    outcomes: m.outcomes,
+    outcomePrices: m.outcomePrices,
+    clobTokenIds: m.clobTokenIds,
+    volume: m.volume,
+    liquidity: m.liquidity,
+    endDate: m.endDate,
+    active: m.active,
+    closed: m.closed,
+    resolved: m.resolved,
+    negRisk: m.negRisk,
+    tickSize: m.minimumTickSize
+  };
+}
+function createPolymarketTools(options) {
+  const agentId = options.agentId || "default";
+  const db = options.engineDb;
+  if (db) {
+    initPolymarketDB(db).catch((e) => console.warn("[polymarket] DB init:", e.message));
+    initLearningDB(db).catch((e) => console.warn("[polymarket] Learning DB init:", e.message));
+  }
+  const tools = [
+    // ═══ ACCOUNT & ONBOARDING ═══════════════════════════════════
+    {
+      name: "poly_create_account",
+      description: "Create a new Polymarket account using the browser. Generates a fresh Ethereum wallet, navigates to polymarket.com, and completes the signup flow. The wallet credentials are stored securely in the enterprise database. The agent handles the entire flow autonomously.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        method: { type: "string", description: '"auto" = agent creates wallet + signs up via browser. "import" = user provides existing private key.', enum: ["auto", "import"] },
+        private_key: { type: "string", description: "For import method: existing Ethereum private key" },
+        funder_address: { type: "string", description: "For import method: Polymarket profile address" },
+        signature_type: { type: "number", description: "0=EOA, 1=Email/Magic, 2=Browser proxy", default: 0 }
+      } },
+      async execute(_id, p) {
+        try {
+          if (p.method === "import" && p.private_key) {
+            const sdk = await ensureSDK();
+            let address = "(pending SDK)";
+            let funder = p.funder_address;
+            if (sdk.ready) {
+              try {
+                const { Wallet } = await import("@ethersproject/wallet");
+                const key = p.private_key.startsWith("0x") ? p.private_key : `0x${p.private_key}`;
+                const wallet2 = new Wallet(key);
+                address = wallet2.address;
+                funder = funder || address;
+              } catch (e) {
+                return errorResult(`Invalid private key: ${e.message}`);
+              }
+            }
+            await saveWalletCredentials(agentId, db, {
+              privateKey: p.private_key.startsWith("0x") ? p.private_key : `0x${p.private_key}`,
+              funderAddress: funder,
+              signatureType: p.signature_type || 0
+            });
+            if (sdk.ready) {
+              try {
+                const client = await getClobClient(agentId, db);
+                if (client) {
+                  return jsonResult({
+                    status: "connected",
+                    method: "import",
+                    address: client.address,
+                    funder: client.funderAddress,
+                    message: "Wallet imported and CLOB API credentials derived. Ready to trade.",
+                    next_steps: ["Fund wallet with USDC on Polygon", "Configure trading with poly_set_config", "Start with poly_search_markets"]
+                  });
+                }
+              } catch {
+              }
+            }
+            return jsonResult({
+              status: "stored",
+              method: "import",
+              address,
+              message: "Wallet credentials stored. SDK will auto-install on first trade attempt.",
+              sdk_status: sdk.ready ? "ready" : sdk.message
+            });
+          }
+          const wallet = await generateWallet();
+          if (!wallet) return errorResult("Failed to generate wallet. SDK may need to be installed.");
+          await saveWalletCredentials(agentId, db, {
+            privateKey: wallet.privateKey,
+            funderAddress: wallet.address,
+            signatureType: 0
+          });
+          return jsonResult({
+            status: "wallet_generated",
+            address: wallet.address,
+            message: "Fresh wallet generated and stored in database. To complete Polymarket account setup:",
+            next_steps: [
+              "1. Use the browser tool to navigate to https://polymarket.com and sign up with this wallet",
+              "2. Or send USDC directly to the wallet address on Polygon and trade via API",
+              "3. The agent can navigate polymarket.com to complete signup if browser access is available"
+            ],
+            funding: {
+              address: wallet.address,
+              network: "Polygon (MATIC)",
+              token: "USDC"
+            },
+            note: "Private key is stored securely in the enterprise database. Never share it."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_check_sdk",
+      description: "Check if the Polymarket SDK is installed and ready. If not installed, auto-installs it. Use this to verify the system is ready for trading before attempting any authenticated operations.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const result = await ensureSDK();
+        const walletClient = await getClobClient(agentId, db);
+        return jsonResult({
+          sdk_ready: result.ready,
+          sdk_message: result.message,
+          wallet_connected: !!walletClient,
+          wallet_address: walletClient?.address || null,
+          funder_address: walletClient?.funderAddress || null
+        });
+      }
+    },
+    // ═══ MARKET DISCOVERY ═══════════════════════════════════════
+    {
+      name: "poly_search_markets",
+      description: "Search prediction markets",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        query: { type: "string" },
+        category: { type: "string" },
+        active: { type: "boolean" },
+        closed: { type: "boolean" },
+        limit: { type: "number" },
+        offset: { type: "number" },
+        order: { type: "string" },
+        ascending: { type: "boolean" },
+        min_volume: { type: "number" },
+        min_liquidity: { type: "number" },
+        end_date_before: { type: "string" },
+        end_date_after: { type: "string" }
+      } },
+      async execute(_id, p) {
+        try {
+          const qs = new URLSearchParams();
+          if (p.query) qs.set("search", p.query);
+          if (p.category) qs.set("tag", p.category);
+          qs.set("active", String(p.active !== void 0 ? p.active : true));
+          if (p.closed !== void 0) qs.set("closed", String(p.closed));
+          qs.set("limit", String(p.limit || 20));
+          if (p.offset) qs.set("offset", String(p.offset));
+          if (p.order) qs.set("order", p.order);
+          if (p.ascending !== void 0) qs.set("ascending", String(p.ascending));
+          if (p.end_date_before) qs.set("end_date_max", p.end_date_before);
+          if (p.end_date_after) qs.set("end_date_min", p.end_date_after);
+          if (!p.order) {
+            qs.set("order", "volume");
+            qs.set("ascending", "false");
+          }
+          const evQs = { active: String(p.active !== void 0 ? p.active : true), closed: String(p.closed || false), limit: String(Math.min((p.limit || 20) * 3, 100)), order: p.order || "volume", ascending: String(p.ascending ?? false) };
+          if (p.query) evQs.search = p.query;
+          if (p.category) evQs.tag_id = p.category;
+          const [marketsRaw, eventsRaw] = await Promise.all([
+            apiFetch(`${GAMMA_API}/markets?${qs}`).catch(() => []),
+            apiFetch(`${GAMMA_API}/events?${new URLSearchParams(evQs)}`).catch(() => [])
+          ]);
+          let allRaw = Array.isArray(marketsRaw) ? [...marketsRaw] : [];
+          if (Array.isArray(eventsRaw)) {
+            for (const ev of eventsRaw) {
+              if (ev.markets && Array.isArray(ev.markets)) {
+                for (const m of ev.markets) {
+                  if (m.active && !m.closed) allRaw.push(m);
+                }
+              }
+            }
+          }
+          const seen2 = /* @__PURE__ */ new Set();
+          allRaw = allRaw.filter((m) => {
+            const k = m.conditionId || m.id;
+            if (seen2.has(k)) return false;
+            seen2.add(k);
+            return true;
+          });
+          if (p.active !== false && !p.closed) {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            allRaw = allRaw.filter((m) => {
+              if (m.closed === true || m.closed === "true") return false;
+              if (m.resolved === true || m.resolved === "true") return false;
+              if (m.active === false || m.active === "false") return false;
+              if (m.endDate && m.endDate < now) return false;
+              if (m.end_date_iso && m.end_date_iso < now) return false;
+              try {
+                const prices = typeof m.outcomePrices === "string" ? JSON.parse(m.outcomePrices) : m.outcomePrices;
+                if (Array.isArray(prices) && prices.length > 0) {
+                  const allResolved = prices.every((p2) => parseFloat(p2) <= 0.01 || parseFloat(p2) >= 0.99);
+                  if (allResolved) return false;
+                }
+              } catch {
+              }
+              return true;
+            });
+          }
+          let markets = allRaw.map(slimMarket);
+          if (p.min_volume) markets = markets.filter((m) => parseFloat(m.volume || "0") >= p.min_volume);
+          if (p.min_liquidity) markets = markets.filter((m) => parseFloat(m.liquidity || "0") >= p.min_liquidity);
+          if (p.enrich !== false && markets.length > 0) {
+            try {
+              const { quickAnalysis: quickAnalysis2 } = await import("./pipeline-GZ7ZFZAW.js");
+              const top5 = markets.slice(0, 5).filter((m) => m.clobTokenIds?.[0]);
+              const pipeResults = await Promise.all(top5.map(
+                (m) => quickAnalysis2(m.clobTokenIds[0], m.question, p.bankroll || 100).catch(() => null)
+              ));
+              for (let i = 0; i < top5.length; i++) {
+                const pr = pipeResults[i];
+                if (pr) {
+                  top5[i].analysis = {
+                    score: pr.score,
+                    action: pr.action,
+                    thesis: pr.thesis,
+                    kelly: pr.kelly,
+                    regime: pr.regime,
+                    smart_money: pr.smart_money,
+                    manipulation_risk: pr.manipulation_risk
+                  };
+                }
+              }
+            } catch {
+            }
+          }
+          const maxResults = Math.min(p.limit || 8, 15);
+          const capped = markets.slice(0, maxResults);
+          const trimmed = capped.map((m) => {
+            const { clobTokenIds: _c, ...rest } = m;
+            return rest;
+          });
+          return jsonResult({ count: markets.length, showing: trimmed.length, markets: trimmed });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_market",
+      description: "Get market details",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" } }, required: ["market_id"] },
+      async execute(_id, p) {
+        try {
+          const c = cached(`market:${p.market_id}`);
+          if (c) return jsonResult(c);
+          let m;
+          try {
+            m = await apiFetch(`${GAMMA_API}/markets/${p.market_id}`);
+          } catch {
+            const arr = await apiFetch(`${GAMMA_API}/markets?slug=${p.market_id}&limit=1`);
+            m = Array.isArray(arr) && arr[0];
+          }
+          if (!m) return errorResult("Market not found");
+          const result = {
+            ...slimMarket(m),
+            description: m.description,
+            startDate: m.startDate,
+            resolutionSource: m.resolutionSource,
+            resolutionDetails: m.resolutionDetails,
+            creator: m.creator,
+            eventId: m.eventId
+          };
+          setCache(`market:${p.market_id}`, result);
+          return jsonResult(result);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_event",
+      description: "Get event with all sub-markets. event_id can be a numeric ID or slug.",
+      category: "enterprise",
+      parameters: { type: "object", properties: { event_id: { type: "string" } }, required: ["event_id"] },
+      async execute(_id, p) {
+        try {
+          let event = null;
+          try {
+            event = await apiFetch(`${GAMMA_API}/events/${p.event_id}`);
+          } catch {
+          }
+          if (!event || event.error) {
+            const arr = await apiFetch(`${GAMMA_API}/events?slug=${encodeURIComponent(p.event_id)}&limit=1`);
+            event = Array.isArray(arr) && arr[0];
+          }
+          if (!event || event.error) {
+            const arr = await apiFetch(`${GAMMA_API}/events?title=${encodeURIComponent(p.event_id)}&limit=1`);
+            event = Array.isArray(arr) && arr[0];
+          }
+          if (!event) return errorResult("Event not found");
+          return jsonResult({
+            id: event.id,
+            title: event.title || event.name,
+            description: event.description,
+            markets: (event.markets || []).map(slimMarket)
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_prices",
+      description: "Get current prices",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        token_ids: { type: "array", items: { type: "string" } },
+        side: { type: "string" }
+      } },
+      async execute(_id, p) {
+        try {
+          const ids = p.token_ids || (p.token_id ? [p.token_id] : []);
+          if (ids.length === 0) return errorResult("Provide token_id or token_ids");
+          const results = await Promise.all(ids.map(async (tid) => {
+            const [mid, price] = await Promise.all([
+              apiFetch(`${CLOB_API}/midpoint?token_id=${tid}`).catch(() => null),
+              p.side ? apiFetch(`${CLOB_API}/price?token_id=${tid}&side=${p.side}`).catch(() => null) : null
+            ]);
+            return { tokenId: tid, midpoint: mid?.mid, price: price?.price };
+          }));
+          return jsonResult(ids.length === 1 ? results[0] : { prices: results });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_orderbook",
+      description: "Get order book",
+      category: "enterprise",
+      parameters: { type: "object", properties: { token_id: { type: "string" }, depth: { type: "number" } }, required: ["token_id"] },
+      async execute(_id, p) {
+        try {
+          const book = await apiFetch(`${CLOB_API}/book?token_id=${p.token_id}`);
+          if (p.depth && book) {
+            if (book.bids) book.bids = book.bids.slice(0, p.depth);
+            if (book.asks) book.asks = book.asks.slice(0, p.depth);
+          }
+          const bestBid = book?.bids?.[0]?.price;
+          const bestAsk = book?.asks?.[0]?.price;
+          if (bestBid && bestAsk) {
+            book._spread = (parseFloat(bestAsk) - parseFloat(bestBid)).toFixed(4);
+            book._spreadPct = ((parseFloat(bestAsk) - parseFloat(bestBid)) / parseFloat(bestAsk) * 100).toFixed(2) + "%";
+            book._midpoint = ((parseFloat(bestAsk) + parseFloat(bestBid)) / 2).toFixed(4);
+          }
+          return jsonResult(book);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_trades",
+      description: "Get recent trades",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        market_id: { type: "string" },
+        limit: { type: "number" },
+        before: { type: "string" },
+        min_size: { type: "number" }
+      } },
+      async execute(_id, p) {
+        try {
+          const client = await getClobClient(_id, db);
+          if (client) {
+            try {
+              const params = {};
+              if (p.token_id) params.asset_id = p.token_id;
+              if (p.market_id) params.market = p.market_id;
+              if (p.before) params.before = p.before;
+              let trades2 = await client.client.getTrades(params);
+              if (Array.isArray(trades2)) {
+                trades2 = trades2.slice(0, p.limit || 50);
+                if (p.min_size) trades2 = trades2.filter((t) => parseFloat(t.size || "0") >= p.min_size);
+              }
+              return jsonResult(trades2);
+            } catch (clientErr) {
+              console.log(`[poly_get_trades] ClobClient failed (${clientErr.message}), trying Gamma fallback`);
+            }
+          }
+          const qs = new URLSearchParams();
+          if (p.token_id) qs.set("asset", p.token_id);
+          if (p.market_id) qs.set("conditionId", p.market_id);
+          qs.set("limit", String(p.limit || 50));
+          let trades = await apiFetch(`https://data-api.polymarket.com/trades?${qs}`);
+          if (p.min_size && Array.isArray(trades)) {
+            trades = trades.filter((t) => parseFloat(t.size || "0") >= p.min_size);
+          }
+          return jsonResult(trades);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_price_history",
+      description: "Historical price timeseries",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        market_id: { type: "string" },
+        interval: { type: "string" },
+        start_ts: { type: "string" },
+        end_ts: { type: "string" },
+        fidelity: { type: "number" }
+      } },
+      async execute(_id, p) {
+        try {
+          const qs = new URLSearchParams();
+          if (p.market_id) qs.set("market", p.market_id);
+          if (p.token_id) qs.set("asset_id", p.token_id);
+          if (p.fidelity) qs.set("fidelity", String(p.fidelity));
+          if (p.start_ts) qs.set("startTs", String(new Date(p.start_ts).getTime() / 1e3));
+          if (p.end_ts) qs.set("endTs", String(new Date(p.end_ts).getTime() / 1e3));
+          const history = await apiFetch(`${GAMMA_API}/markets/${p.market_id || p.token_id}/timeseries?${qs}`).catch(() => null);
+          if (!history) {
+            return jsonResult({ status: "limited", message: "Timeseries API not available for this market. Use poly_get_trades for raw trade data." });
+          }
+          return jsonResult(history);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_trending_markets",
+      description: "Trending markets",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        limit: { type: "number" },
+        category: { type: "string" },
+        sort_by: { type: "string" }
+      } },
+      async execute(_id, p) {
+        try {
+          const qs = new URLSearchParams({ active: "true", closed: "false", order: "volume", ascending: "false", limit: String(p.limit || 20) });
+          if (p.category) qs.set("tag", p.category);
+          if (p.sort_by === "closing_soon") {
+            qs.set("order", "end_date");
+            qs.set("ascending", "true");
+          }
+          if (p.sort_by === "new") {
+            qs.set("order", "created_at");
+            qs.set("ascending", "false");
+          }
+          const raw = await apiFetch(`${GAMMA_API}/markets?${qs}`);
+          return jsonResult({ count: (raw || []).length, markets: (Array.isArray(raw) ? raw : []).map(slimMarket) });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_market_comments",
+      description: "Market comments/discussion",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, limit: { type: "number" }, order: { type: "string" } }, required: ["market_id"] },
+      async execute(_id, p) {
+        try {
+          const qs = new URLSearchParams({ limit: String(p.limit || 30) });
+          const comments = await apiFetch(`${GAMMA_API}/comments?market=${p.market_id}&${qs}`);
+          return jsonResult(comments);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_related_markets",
+      description: "Find related markets",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, limit: { type: "number" } }, required: ["market_id"] },
+      async execute(_id, p) {
+        try {
+          const market = await apiFetch(`${GAMMA_API}/markets/${p.market_id}`).catch(() => null);
+          if (!market?.eventId) return jsonResult({ related: [], message: "No event association found" });
+          const eventMarkets = await apiFetch(`${GAMMA_API}/markets?event_id=${market.eventId}&limit=${p.limit || 10}`);
+          const related = (Array.isArray(eventMarkets) ? eventMarkets : []).filter((m) => (m.conditionId || m.id) !== p.market_id).map(slimMarket);
+          return jsonResult({ eventId: market.eventId, related });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_market_news",
+      description: "Related news for a market",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, query: { type: "string" }, hours: { type: "number" }, limit: { type: "number" } } },
+      async execute(_id, p) {
+        try {
+          let query = p.query;
+          if (!query && p.market_id) {
+            const m = cached(`market:${p.market_id}`) || await apiFetch(`${GAMMA_API}/markets/${p.market_id}`).catch(() => null);
+            query = m?.question;
+          }
+          if (!query) return errorResult("Provide market_id or query");
+          return jsonResult({
+            status: "use_web_search",
+            message: `Search news for: "${query}". Use the enterprise-http or web search tools to find related articles.`,
+            suggested_query: query
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ═══ WALLET & ACCOUNT ═══════════════════════════════════════
+    {
+      name: "poly_setup_wallet",
+      description: "Initialize trading wallet \u2014 auto-installs SDK if needed, stores credentials in enterprise DB",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        private_key: { type: "string" },
+        funder_address: { type: "string" },
+        signature_type: { type: "number" },
+        rpc_url: { type: "string" }
+      }, required: ["private_key"] },
+      async execute(_id, p) {
+        try {
+          const sdk = await ensureSDK();
+          if (!sdk.ready) {
+            await saveWalletCredentials(agentId, db, {
+              privateKey: p.private_key.startsWith("0x") ? p.private_key : `0x${p.private_key}`,
+              funderAddress: p.funder_address,
+              signatureType: p.signature_type || 0,
+              rpcUrl: p.rpc_url
+            });
+            return jsonResult({
+              status: "credentials_stored",
+              message: `Wallet credentials saved to database. SDK status: ${sdk.message}`,
+              note: "Credentials are persisted \u2014 they will survive server restarts. SDK will auto-install on next attempt."
+            });
+          }
+          await saveWalletCredentials(agentId, db, {
+            privateKey: p.private_key.startsWith("0x") ? p.private_key : `0x${p.private_key}`,
+            funderAddress: p.funder_address,
+            signatureType: p.signature_type || 0,
+            rpcUrl: p.rpc_url
+          });
+          const client = await getClobClient(agentId, db);
+          if (!client) return errorResult("Failed to initialize CLOB client after saving credentials");
+          walletState.set(agentId, { connected: true, address: client.funderAddress, sigType: p.signature_type || 0 });
+          return jsonResult({
+            status: "connected",
+            address: client.funderAddress,
+            signer_address: client.address,
+            signature_type: p.signature_type || 0,
+            persisted: true,
+            note: "Credentials stored in enterprise database. Will survive server restarts and redeployments."
+          });
+        } catch (e) {
+          return errorResult(`Wallet setup failed: ${e.message}`);
+        }
+      }
+    },
+    {
+      name: "poly_wallet_status",
+      description: "Check wallet connection status",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const client = await getClobClient(agentId, db);
+        if (!client) return jsonResult({ connected: false, message: "No wallet connected. Run poly_create_account or poly_setup_wallet." });
+        return jsonResult({ connected: true, address: client.address, funder: client.funderAddress, signatureType: client.signatureType });
+      }
+    },
+    {
+      name: "poly_set_allowances",
+      description: "Approve Polymarket exchange contracts to use your USDC for trading. This sends on-chain transactions (requires POL/MATIC for gas).",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected. Run poly_create_account first.");
+        try {
+          const creds = await loadWalletCredentials(agentId, db);
+          if (!creds) return errorResult("No wallet credentials");
+          const { ethers } = await import("ethers");
+          const rpcs = ["https://polygon.drpc.org", "https://polygon-bor-rpc.publicnode.com", "https://polygon.llamarpc.com", "https://polygon-rpc.com"];
+          let provider;
+          for (const rpc of rpcs) {
+            try {
+              provider = new ethers.JsonRpcProvider(rpc);
+              await provider.getNetwork();
+              break;
+            } catch {
+              provider = null;
+            }
+          }
+          if (!provider) return errorResult("Cannot connect to Polygon network");
+          const wallet = new ethers.Wallet(creds.privateKey, provider);
+          const MAX_ALLOWANCE = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+          const usdcAddresses = [
+            USDC_E,
+            // USDC.e (bridged)
+            "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+            // USDC (native)
+          ];
+          const spenders = [
+            "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E",
+            // CTF Exchange
+            "0xC5d563A36AE78145C45a50134d48A1215220f80a",
+            // Neg Risk CTF Exchange
+            "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+            // Neg Risk Adapter
+          ];
+          const erc20Abi = ["function approve(address spender, uint256 amount) returns (bool)", "function allowance(address owner, address spender) view returns (uint256)"];
+          const ctfAbi = ["function setApprovalForAll(address operator, bool approved)", "function isApprovedForAll(address owner, address operator) view returns (bool)"];
+          const txHashes = [];
+          for (const usdc of usdcAddresses) {
+            const contract = new ethers.Contract(usdc, erc20Abi, wallet);
+            for (const spender of spenders) {
+              try {
+                const current = await contract.allowance(wallet.address, spender);
+                if (current > BigInt(0)) continue;
+                const tx = await contract.approve(spender, MAX_ALLOWANCE);
+                await tx.wait();
+                txHashes.push(tx.hash);
+              } catch (e) {
+                if (e.message?.includes("CALL_EXCEPTION")) continue;
+                throw e;
+              }
+            }
+          }
+          const ctfAddress = CTF_ADDRESS;
+          const ctfContract = new ethers.Contract(ctfAddress, ctfAbi, wallet);
+          for (const spender of spenders) {
+            try {
+              const approved = await ctfContract.isApprovedForAll(wallet.address, spender);
+              if (approved) continue;
+              const tx = await ctfContract.setApprovalForAll(spender, true);
+              await tx.wait();
+              txHashes.push(tx.hash);
+            } catch (e) {
+              if (e.message?.includes("CALL_EXCEPTION")) continue;
+              console.warn(`[allowance] CTF approval failed for ${spender}: ${e.message}`);
+            }
+          }
+          return jsonResult({
+            status: "allowances_set",
+            transactions: txHashes,
+            message: txHashes.length > 0 ? `Approved ${txHashes.length} contracts. You can now trade.` : "All contracts already approved."
+          });
+        } catch (e) {
+          return jsonResult({ status: "failed", message: `Set allowances failed: ${e.message}. Ensure wallet has POL/MATIC for gas fees.` });
+        }
+      }
+    },
+    // ═══ BALANCE & FUNDS ════════════════════════════════════════
+    {
+      name: "poly_get_balance",
+      description: "Get wallet USDC balance and exchange allowances. IMPORTANT: Polymarket requires USDC.e (bridged), NOT native USDC. If you have native USDC but no USDC.e, run poly_swap_to_usdce first.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected");
+        try {
+          const exchangeBalance = await client.client.getBalanceAllowance({ asset_type: "COLLATERAL" });
+          let usdceBal = "0";
+          let usdcNativeBal = "0";
+          let polBal = "0";
+          try {
+            const { ethers } = await import("ethers");
+            let provider;
+            const rpcs = ["https://polygon.drpc.org", "https://polygon-bor-rpc.publicnode.com", "https://polygon.llamarpc.com", "https://polygon-rpc.com"];
+            for (const rpc of rpcs) {
+              try {
+                provider = new ethers.JsonRpcProvider(rpc);
+                await provider.getNetwork();
+                break;
+              } catch {
+                provider = null;
+              }
+            }
+            if (!provider) throw new Error("All Polygon RPCs failed");
+            const balAbi = ["function balanceOf(address) view returns (uint256)"];
+            try {
+              const ce = new ethers.Contract(USDC_E, balAbi, provider);
+              usdceBal = (Number(await ce.balanceOf(client.address)) / 1e6).toFixed(2);
+            } catch {
+            }
+            try {
+              const cn = new ethers.Contract("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", balAbi, provider);
+              usdcNativeBal = (Number(await cn.balanceOf(client.address)) / 1e6).toFixed(2);
+            } catch {
+            }
+            try {
+              polBal = ethers.formatEther(await provider.getBalance(client.address));
+              polBal = parseFloat(polBal).toFixed(4);
+            } catch {
+            }
+          } catch {
+          }
+          const walletUSDC = (parseFloat(usdceBal) + parseFloat(usdcNativeBal)).toFixed(2);
+          const walletBal = parseFloat(walletUSDC);
+          const allAllowancesZero = Object.values(exchangeBalance?.allowances || {}).every((v) => v === "0" || v === 0);
+          const needsAllowances = walletBal > 0 && allAllowancesZero;
+          if (needsAllowances) {
+            try {
+              const creds2 = await loadWalletCredentials(agentId, db);
+              if (!creds2) throw new Error("No wallet credentials");
+              const { ethers: ethers2 } = await import("ethers");
+              let provider2;
+              for (const rpc of ["https://polygon.drpc.org", "https://polygon-bor-rpc.publicnode.com", "https://polygon.llamarpc.com", "https://polygon-rpc.com"]) {
+                try {
+                  provider2 = new ethers2.JsonRpcProvider(rpc);
+                  await provider2.getNetwork();
+                  break;
+                } catch {
+                  provider2 = null;
+                }
+              }
+              if (!provider2) throw new Error("Cannot connect to Polygon");
+              const wallet2 = new ethers2.Wallet(creds2.privateKey, provider2);
+              const MAX_ALLOWANCE = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+              const usdcs = [USDC_E, "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"];
+              const spenders = ["0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E", "0xC5d563A36AE78145C45a50134d48A1215220f80a", "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"];
+              const abi = ["function approve(address,uint256) returns (bool)", "function allowance(address,address) view returns (uint256)"];
+              for (const u of usdcs) {
+                const c = new ethers2.Contract(u, abi, wallet2);
+                for (const s of spenders) {
+                  try {
+                    const cur = await c.allowance(wallet2.address, s);
+                    if (cur > BigInt(0)) continue;
+                    const tx = await c.approve(s, MAX_ALLOWANCE);
+                    await tx.wait();
+                  } catch {
+                  }
+                }
+              }
+              const updated = await client.client.getBalanceAllowance({ asset_type: "COLLATERAL" });
+              const allApproved2 = Object.values(updated?.allowances || {}).every((v) => v !== "0" && v !== 0);
+              return jsonResult({
+                address: client.address,
+                usdc_e_bridged: usdceBal,
+                usdc_native: usdcNativeBal,
+                pol_gas: polBal,
+                wallet_usdc_total: walletUSDC,
+                exchange_balance: updated.balance,
+                trading_approved: allApproved2,
+                status: "allowances_auto_set",
+                needs_swap: parseFloat(usdceBal) === 0 && parseFloat(usdcNativeBal) > 0,
+                message: parseFloat(usdceBal) === 0 && parseFloat(usdcNativeBal) > 0 ? `\u26A0\uFE0F Wallet has $${usdcNativeBal} native USDC but $0 USDC.e. Polymarket ONLY accepts USDC.e! Run poly_swap_to_usdce to convert.` : `Wallet has $${usdceBal} USDC.e. Exchange contracts approved \u2014 you can now trade.`
+              });
+            } catch (e) {
+              return jsonResult({
+                address: client.address,
+                usdc_e_bridged: usdceBal,
+                usdc_native: usdcNativeBal,
+                pol_gas: polBal,
+                exchange_balance: exchangeBalance.balance,
+                trading_approved: false,
+                status: "needs_allowances",
+                message: `Approval failed: ${e.message}`
+              });
+            }
+          }
+          const allApproved = Object.values(exchangeBalance?.allowances || {}).every((v) => v !== "0" && v !== 0);
+          const needsSwap = parseFloat(usdceBal) === 0 && parseFloat(usdcNativeBal) > 0;
+          return jsonResult({
+            address: client.address,
+            usdc_e_bridged: usdceBal,
+            usdc_native: usdcNativeBal,
+            pol_gas: polBal,
+            wallet_usdc_total: walletUSDC,
+            exchange_balance: exchangeBalance.balance,
+            trading_approved: allApproved,
+            available_to_trade: usdceBal,
+            needs_swap: needsSwap,
+            status: needsSwap ? "needs_swap" : parseFloat(usdceBal) > 0 ? "funded" : "no_funds",
+            message: needsSwap ? `\u26A0\uFE0F You have $${usdcNativeBal} native USDC but Polymarket requires USDC.e (bridged). Run poly_swap_to_usdce to convert.` : void 0
+          });
+        } catch (e) {
+          return jsonResult({ address: client.address, status: "balance_check_failed", message: e.message });
+        }
+      }
+    },
+    {
+      name: "poly_deposit",
+      description: "Deposit instructions",
+      category: "enterprise",
+      parameters: { type: "object", properties: { amount: { type: "number" }, source_chain: { type: "string" } } },
+      async execute() {
+        const client = await getClobClient(agentId, db);
+        const addr = client?.address || "(connect wallet first)";
+        return jsonResult({
+          deposit_address: addr,
+          network: "Polygon (MATIC)",
+          token: `USDC (${USDC_E})`,
+          instructions: [
+            `1. Send USDC on Polygon to: ${addr}`,
+            "2. Wait for confirmation (~2 seconds on Polygon)",
+            "3. Funds will appear in your Polymarket balance",
+            "Note: You can also deposit via polymarket.com bridge from Ethereum, Arbitrum, Base, or Optimism."
+          ]
+        });
+      }
+    },
+    {
+      name: "poly_swap_to_usdce",
+      description: "Swap native USDC to USDC.e (bridged) on Polygon. Polymarket ONLY accepts USDC.e for trading. Uses Uniswap V3 swap router. Run this if poly_get_balance shows native USDC but no USDC.e.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        amount: { type: "number", description: "Amount in USD to swap. Leave empty to swap entire native USDC balance." }
+      } },
+      async execute(_id, p) {
+        const creds = await loadWalletCredentials(agentId, db);
+        if (!creds) return errorResult("Wallet not connected");
+        try {
+          const { ethers } = await import("ethers");
+          let provider;
+          for (const rpc of ["https://polygon.drpc.org", "https://polygon-bor-rpc.publicnode.com", "https://polygon.llamarpc.com", "https://polygon-rpc.com"]) {
+            try {
+              provider = new ethers.JsonRpcProvider(rpc);
+              await provider.getNetwork();
+              break;
+            } catch {
+              provider = null;
+            }
+          }
+          if (!provider) return errorResult("Cannot connect to Polygon RPC");
+          const wallet = new ethers.Wallet(creds.privateKey, provider);
+          const USDC_NATIVE = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+          const SWAP_ROUTER = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45";
+          const erc20Abi = [
+            "function balanceOf(address) view returns (uint256)",
+            "function approve(address,uint256) returns (bool)",
+            "function allowance(address,address) view returns (uint256)"
+          ];
+          const nativeContract = new ethers.Contract(USDC_NATIVE, erc20Abi, wallet);
+          const nativeBal = await nativeContract.balanceOf(wallet.address);
+          if (nativeBal === BigInt(0)) {
+            return jsonResult({ status: "no_native_usdc", message: "No native USDC to swap. Balance is 0." });
+          }
+          let swapAmount = nativeBal;
+          if (p.amount && p.amount > 0) {
+            swapAmount = BigInt(Math.floor(p.amount * 1e6));
+            if (swapAmount > nativeBal) swapAmount = nativeBal;
+          }
+          const swapUSD = (Number(swapAmount) / 1e6).toFixed(2);
+          const currentAllowance = await nativeContract.allowance(wallet.address, SWAP_ROUTER);
+          if (currentAllowance < swapAmount) {
+            const approveTx = await nativeContract.approve(SWAP_ROUTER, "115792089237316195423570985008687907853269984665640564039457584007913129639935");
+            await approveTx.wait();
+          }
+          const swapRouterAbi = [
+            "function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)"
+          ];
+          const router = new ethers.Contract(SWAP_ROUTER, swapRouterAbi, wallet);
+          const minOut = swapAmount * BigInt(995) / BigInt(1e3);
+          const tx = await router.exactInputSingle({
+            tokenIn: USDC_NATIVE,
+            tokenOut: USDC_E,
+            fee: 100,
+            // 0.01% fee tier for stablecoin pairs
+            recipient: wallet.address,
+            amountIn: swapAmount,
+            amountOutMinimum: minOut,
+            sqrtPriceLimitX96: BigInt(0)
+          });
+          const receipt = await tx.wait();
+          const usdceContract = new ethers.Contract(USDC_E, ["function balanceOf(address) view returns (uint256)"], provider);
+          const newBal = await usdceContract.balanceOf(wallet.address);
+          return jsonResult({
+            status: "swapped",
+            swapped_amount: swapUSD,
+            tx_hash: receipt.hash,
+            new_usdce_balance: (Number(newBal) / 1e6).toFixed(2),
+            message: `Successfully swapped $${swapUSD} native USDC \u2192 USDC.e. You can now trade on Polymarket.`
+          });
+        } catch (e) {
+          if (e.message?.includes("revert") || e.message?.includes("STF") || e.message?.includes("Too little received")) {
+            try {
+              const { ethers } = await import("ethers");
+              let provider;
+              for (const rpc of ["https://polygon.llamarpc.com", "https://polygon-bor-rpc.publicnode.com"]) {
+                try {
+                  provider = new ethers.JsonRpcProvider(rpc);
+                  await provider.getNetwork();
+                  break;
+                } catch {
+                  provider = null;
+                }
+              }
+              if (!provider) return errorResult("RPC failed on retry");
+              const wallet = new ethers.Wallet(creds.privateKey, provider);
+              const nativeContract = new ethers.Contract("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", ["function balanceOf(address) view returns (uint256)"], provider);
+              const nativeBal = await nativeContract.balanceOf(wallet.address);
+              let swapAmount = nativeBal;
+              if (p.amount && p.amount > 0) {
+                swapAmount = BigInt(Math.floor(p.amount * 1e6));
+                if (swapAmount > nativeBal) swapAmount = nativeBal;
+              }
+              const router = new ethers.Contract("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", [
+                "function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)"
+              ], wallet);
+              const minOut = swapAmount * BigInt(990) / BigInt(1e3);
+              const tx = await router.exactInputSingle({
+                tokenIn: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+                tokenOut: USDC_E,
+                fee: 500,
+                // 0.05% fee tier
+                recipient: wallet.address,
+                amountIn: swapAmount,
+                amountOutMinimum: minOut,
+                sqrtPriceLimitX96: BigInt(0)
+              });
+              const receipt = await tx.wait();
+              const usdceContract = new ethers.Contract(USDC_E, ["function balanceOf(address) view returns (uint256)"], provider);
+              const newBal = await usdceContract.balanceOf(wallet.address);
+              return jsonResult({
+                status: "swapped",
+                fee_tier: "0.05%",
+                swapped_amount: (Number(swapAmount) / 1e6).toFixed(2),
+                tx_hash: receipt.hash,
+                new_usdce_balance: (Number(newBal) / 1e6).toFixed(2),
+                message: `Swapped via 0.05% pool. You can now trade on Polymarket.`
+              });
+            } catch (e2) {
+              return errorResult(`Swap failed on both fee tiers. Error: ${e2.message}`);
+            }
+          }
+          return errorResult(`Swap failed: ${e.message}`);
+        }
+      }
+    },
+    {
+      name: "poly_withdraw",
+      description: "Withdraw USDC",
+      category: "enterprise",
+      parameters: { type: "object", properties: { amount: { type: "number" }, to_address: { type: "string" } }, required: ["amount", "to_address"] },
+      async execute(_id, p) {
+        const config = await loadConfig(agentId, db);
+        if (config.mode === "approval") {
+          return jsonResult({ status: "requires_approval", message: `Withdrawal of $${p.amount} USDC to ${p.to_address} requires human approval.` });
+        }
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected");
+        return jsonResult({ status: "requires_manual", message: `Withdraw $${p.amount} USDC to ${p.to_address}. Use polymarket.com/portfolio for manual withdrawals.` });
+      }
+    },
+    // ═══ PORTFOLIO & POSITIONS ══════════════════════════════════
+    {
+      name: "poly_get_positions",
+      description: "Get open positions",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, min_value: { type: "number" }, sort_by: { type: "string" } } },
+      async execute(_id, p) {
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected");
+        try {
+          const addr = client.funderAddress || client.address;
+          let positions = await apiFetch(`https://data-api.polymarket.com/positions?user=${addr}`).catch(() => null);
+          if (!positions) {
+            positions = await apiFetch(`${GAMMA_API}/positions?user=${addr}&limit=100`).catch(() => null);
+          }
+          if (!positions || Array.isArray(positions) && positions.length === 0) return jsonResult({ address: addr, status: "no_positions" });
+          const trimmed = positions.map((pos) => ({
+            asset: pos.asset,
+            conditionId: pos.conditionId,
+            size: pos.size,
+            avgPrice: pos.avgPrice,
+            currentPrice: pos.curPrice || pos.currentPrice,
+            title: pos.title,
+            outcome: pos.outcome,
+            market_slug: pos.market_slug || pos.slug,
+            pnl: pos.cashPnl ?? pos.pnl,
+            percentPnl: pos.percentPnl,
+            redeemable: pos.redeemable,
+            resolved: pos.resolved,
+            negRisk: pos.negRisk
+          }));
+          return jsonResult(trimmed);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_get_closed_positions",
+      description: "Get closed positions",
+      category: "enterprise",
+      parameters: { type: "object", properties: { limit: { type: "number" }, offset: { type: "number" }, market_id: { type: "string" }, won_only: { type: "boolean" }, lost_only: { type: "boolean" } } },
+      async execute(_id, p) {
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected");
+        try {
+          const addr = client.funderAddress || client.address;
+          const qs = new URLSearchParams({ user: addr, limit: String(p.limit || 50) });
+          if (p.offset) qs.set("offset", String(p.offset));
+          let positions = await apiFetch(`https://data-api.polymarket.com/positions/closed?${qs}`).catch(() => null);
+          if (!positions) {
+            positions = await apiFetch(`${GAMMA_API}/positions/closed?${qs}`).catch(() => null);
+          }
+          return jsonResult(positions || { address: addr, status: "no_closed_positions" });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_redeem",
+      description: "Redeem winning tokens from resolved markets. Checks Data API for redeemable positions and calls CTF contract redeemPositions(). Use redeem_all=true to claim ALL redeemable positions, or pass a specific condition_id.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        condition_id: { type: "string", description: "Specific conditionId to redeem" },
+        redeem_all: { type: "boolean", description: "Redeem all redeemable positions" }
+      } },
+      async execute(_id, p) {
+        try {
+          const creds = await loadWalletCredentials(agentId, db);
+          if (!creds?.privateKey) return errorResult("No wallet credentials. Set up wallet first.");
+          const wallet = creds.funderAddress;
+          if (!wallet) return errorResult("No wallet address found.");
+          const posRes = await fetch(`https://data-api.polymarket.com/positions?user=${wallet}&sizeThreshold=0`);
+          const positions = await posRes.json();
+          const redeemable = positions.filter((pos) => pos.redeemable === true);
+          if (!redeemable.length) return jsonResult({ status: "nothing_to_redeem", message: "No redeemable positions found." });
+          const toRedeem = p?.condition_id ? redeemable.filter((pos) => pos.conditionId === p.condition_id) : p?.redeem_all ? redeemable : redeemable.slice(0, 1);
+          if (!toRedeem.length) return jsonResult({ status: "not_found", message: `No redeemable position found for condition ${p.condition_id}`, available: redeemable.map((r) => ({ title: r.title, conditionId: r.conditionId, value: r.currentValue })) });
+          const { ethers } = await import("ethers");
+          const CTF_ABI = [
+            "function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] calldata indexSets) external"
+          ];
+          const rpcs = ["https://polygon-bor-rpc.publicnode.com", "https://polygon.drpc.org"];
+          let provider;
+          for (const rpc of rpcs) {
+            try {
+              provider = new ethers.JsonRpcProvider(rpc);
+              await provider.getBlockNumber();
+              break;
+            } catch {
+              continue;
+            }
+          }
+          if (!provider) return errorResult("All RPCs failed");
+          const signer = new ethers.Wallet(creds.privateKey, provider);
+          const ctf = new ethers.Contract(CTF_ADDRESS, CTF_ABI, signer);
+          const results = [];
+          for (const pos of toRedeem) {
+            try {
+              const parentCollectionId = "0x0000000000000000000000000000000000000000000000000000000000000000";
+              const indexSets = pos.negativeRisk ? [1] : [1, 2];
+              const tx = await ctf.redeemPositions(
+                USDC_E,
+                parentCollectionId,
+                pos.conditionId,
+                indexSets,
+                { gasLimit: 3e5 }
+              );
+              const receipt = await tx.wait();
+              try {
+                const { safeDbExec: safeDbExec2 } = await import("./polymarket-shared-M5ZU3HKM.js");
+                await safeDbExec2(
+                  db,
+                  `UPDATE poly_trade_log SET status = 'redeemed', pnl = $1 WHERE token_id = $2 AND agent_id = $3 AND status != 'redeemed'`,
+                  [pos.cashPnl || 0, pos.asset, agentId]
+                );
+              } catch {
+              }
+              results.push({
+                title: pos.title,
+                outcome: pos.outcome,
+                conditionId: pos.conditionId,
+                shares: pos.size,
+                value: pos.currentValue,
+                profit: pos.cashPnl,
+                txHash: receipt.hash,
+                status: "redeemed"
+              });
+            } catch (e) {
+              results.push({
+                title: pos.title,
+                conditionId: pos.conditionId,
+                status: "failed",
+                error: e.message
+              });
+            }
+          }
+          return jsonResult({
+            status: "complete",
+            redeemed: results.filter((r) => r.status === "redeemed").length,
+            failed: results.filter((r) => r.status === "failed").length,
+            total_value: results.filter((r) => r.status === "redeemed").reduce((s, r) => s + (r.value || 0), 0),
+            total_profit: results.filter((r) => r.status === "redeemed").reduce((s, r) => s + (r.profit || 0), 0),
+            details: results
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_portfolio_summary",
+      description: "Portfolio analytics",
+      category: "enterprise",
+      parameters: { type: "object", properties: { period: { type: "string" }, include_closed: { type: "boolean" }, include_charts: { type: "boolean" } } },
+      async execute(_id, p) {
+        const config = await loadConfig(agentId, db);
+        const counter = await getDailyCounter(agentId, db);
+        const paperPos = await getPaperPositions(agentId, db);
+        const client = await getClobClient(agentId, db);
+        return jsonResult({
+          wallet: client?.address || "Not connected",
+          config_mode: config.mode,
+          daily_trades: `${counter.count}/${config.maxDailyTrades}`,
+          daily_loss: `$${counter.loss}/$${config.maxDailyLoss}`,
+          circuit_breaker: counter.paused ? `PAUSED: ${counter.reason}` : "OK",
+          paper_positions: paperPos.length,
+          sdk_ready: (await ensureSDK()).ready
+        });
+      }
+    },
+    // ═══ ORDER MANAGEMENT ═══════════════════════════════════════
+    {
+      name: "poly_place_order",
+      description: "Place an order",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        side: { type: "string" },
+        price: { type: "number" },
+        size: { type: "number" },
+        order_type: { type: "string" },
+        expiration: { type: "string" },
+        max_slippage_pct: { type: "number" },
+        tick_size: { type: "string" },
+        neg_risk: { type: "boolean" },
+        market_question: { type: "string" },
+        outcome: { type: "string" },
+        rationale: { type: "string" },
+        urgency: { type: "string" }
+      }, required: ["token_id", "side", "size"] },
+      async execute(_id, p) {
+        const config = await loadConfig(agentId, db);
+        const check = preTradeChecks(agentId, config, p);
+        if (check) return errorResult(check);
+        try {
+          const unresolved = await getUnresolvedPredictions(agentId, db, void 0);
+          const hasPrediction = unresolved.some(
+            (u) => u.token_id === p.token_id || p.market_id && u.market_id === p.market_id || p.market_question && u.market_question && u.market_question.toLowerCase().includes(p.market_question.toLowerCase().slice(0, 30))
+          );
+          if (!hasPrediction && unresolved.length === 0) {
+            return errorResult(
+              "PIPELINE: No predictions recorded yet. Before placing orders, call poly_record_prediction with your analysis (token_id, predicted_outcome, predicted_probability, confidence, reasoning). This journals your trade thesis for the learning loop."
+            );
+          }
+        } catch {
+        }
+        if (config.mode === "paper") {
+          const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`).catch(() => ({ mid: p.price || 0.5 }));
+          const fillPrice = p.price || parseFloat(mid?.mid || "0.5");
+          await savePaperPosition(db, {
+            agentId,
+            tokenId: p.token_id,
+            side: p.side,
+            entryPrice: fillPrice,
+            size: p.size,
+            marketQuestion: p.market_question || "",
+            rationale: p.rationale || ""
+          });
+          await incrementDailyCounter(agentId, db);
+          const tradeId2 = `paper_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          await logTrade(db, {
+            id: tradeId2,
+            agentId,
+            tokenId: p.token_id,
+            marketQuestion: p.market_question,
+            outcome: p.outcome,
+            side: p.side,
+            price: fillPrice,
+            size: p.size,
+            fillPrice,
+            fillSize: p.size,
+            status: "paper_filled",
+            rationale: p.rationale
+          });
+          return jsonResult({
+            status: "paper_filled",
+            message: `PAPER TRADE: ${p.side} ${p.size} shares at ${fillPrice}`,
+            trade_id: tradeId2,
+            persisted: true
+          });
+        }
+        if (!p.price && p.max_slippage_pct) {
+          try {
+            const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`);
+            const midPrice = parseFloat(mid?.mid || "0.5");
+            const book = await apiFetch(`${CLOB_API}/book?token_id=${p.token_id}`);
+            const levels = p.side === "BUY" ? book?.asks || [] : book?.bids || [];
+            if (levels.length === 0) return errorResult("Order book is empty \u2014 cannot execute market order");
+            let filled = 0, cost = 0;
+            for (const level of levels) {
+              const lvlPrice = parseFloat(level.price);
+              const lvlSize = parseFloat(level.size);
+              const fill = Math.min(p.size - filled, lvlSize);
+              cost += fill * lvlPrice;
+              filled += fill;
+              if (filled >= p.size) break;
+            }
+            if (filled < p.size) return errorResult(`Insufficient liquidity: only ${filled.toFixed(2)} of ${p.size} available`);
+            const avgPrice = cost / filled;
+            const slippage = Math.abs(avgPrice - midPrice) / midPrice * 100;
+            if (slippage > p.max_slippage_pct) {
+              return errorResult(`Slippage ${slippage.toFixed(2)}% exceeds max ${p.max_slippage_pct}%. Midpoint: ${midPrice}, estimated avg fill: ${avgPrice.toFixed(4)}`);
+            }
+          } catch (e) {
+          }
+        }
+        const tradeId = `trade_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        if (config.mode === "approval") {
+          const rules = await getAutoApproveRules(agentId, db);
+          const autoApproved = rules.some(
+            (rule) => p.size <= rule.maxSize && rule.sides.includes(p.side)
+          );
+          if (autoApproved) {
+            await incrementDailyCounter(agentId, db);
+            return await executeOrder(agentId, db, tradeId, p, "auto_approved");
+          }
+          await savePendingTrade(db, {
+            id: tradeId,
+            agentId,
+            tokenId: p.token_id,
+            side: p.side,
+            price: p.price || null,
+            size: p.size,
+            orderType: p.order_type || "GTC",
+            tickSize: p.tick_size || "0.01",
+            negRisk: p.neg_risk || false,
+            marketQuestion: p.market_question || "",
+            outcome: p.outcome || "",
+            rationale: p.rationale || "",
+            urgency: p.urgency || "normal"
+          });
+          return jsonResult({
+            status: "pending_approval",
+            trade_id: tradeId,
+            message: `Trade queued for approval: ${p.side} $${p.size} of "${p.outcome || p.token_id}" at ${p.price || "market"}`,
+            persisted: true,
+            dashboard_url: "/polymarket"
+          });
+        }
+        await incrementDailyCounter(agentId, db);
+        return await executeOrder(agentId, db, tradeId, p, "autonomous");
+      }
+    },
+    {
+      name: "poly_place_batch_orders",
+      description: "Place multiple orders at once",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        orders: { type: "array", items: { type: "object" } },
+        atomic: { type: "boolean" },
+        rationale: { type: "string" }
+      }, required: ["orders"] },
+      async execute(_id, p) {
+        const config = await loadConfig(agentId, db);
+        const results = [];
+        const errors = [];
+        for (const order of p.orders || []) {
+          const check = preTradeChecks(agentId, config, order);
+          if (check) {
+            if (p.atomic) return errorResult(`Atomic batch failed: ${check}`);
+            errors.push({ order, error: check });
+            continue;
+          }
+          results.push({ ...order, status: config.mode === "approval" ? "pending_approval" : "queued" });
+        }
+        return jsonResult({
+          total: (p.orders || []).length,
+          accepted: results.length,
+          rejected: errors.length,
+          orders: results,
+          errors: errors.length > 0 ? errors : void 0,
+          note: config.mode === "approval" ? "All orders queued for approval" : "Batch execution requires SDK"
+        });
+      }
+    },
+    {
+      name: "poly_get_open_orders",
+      description: "Get open orders",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, token_id: { type: "string" } } },
+      async execute() {
+        const pending = Array.from(pendingTrades.values()).filter((t) => t.agentId === agentId);
+        return jsonResult({ pending_approvals: pending, live_orders: "requires_sdk" });
+      }
+    },
+    {
+      name: "poly_get_order",
+      description: "Get order details",
+      category: "enterprise",
+      parameters: { type: "object", properties: { order_id: { type: "string" } }, required: ["order_id"] },
+      async execute(_id, p) {
+        const pending = pendingTrades.get(p.order_id);
+        if (pending) return jsonResult({ status: "pending_approval", trade: pending });
+        return jsonResult({ status: "requires_sdk", message: "Live order lookup requires authenticated CLOB client." });
+      }
+    },
+    {
+      name: "poly_cancel_order",
+      description: "Cancel an order",
+      category: "enterprise",
+      parameters: { type: "object", properties: { order_id: { type: "string" } }, required: ["order_id"] },
+      async execute(_id, p) {
+        if (pendingTrades.has(p.order_id)) {
+          pendingTrades.delete(p.order_id);
+          return jsonResult({ status: "cancelled", type: "pending_approval", order_id: p.order_id });
+        }
+        return jsonResult({ status: "requires_sdk", message: "Cancelling live orders requires CLOB client SDK" });
+      }
+    },
+    {
+      name: "poly_cancel_orders",
+      description: "Cancel multiple orders",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        order_ids: { type: "array", items: { type: "string" } },
+        market_id: { type: "string" },
+        token_id: { type: "string" },
+        side: { type: "string" }
+      } },
+      async execute(_id, p) {
+        let cancelled = [];
+        if (p.order_ids) {
+          for (const id of p.order_ids) {
+            if (pendingTrades.delete(id)) cancelled.push(id);
+          }
+        } else {
+          for (const [id, t] of pendingTrades) {
+            if (t.agentId !== agentId) continue;
+            if (p.token_id && t.tokenId !== p.token_id) continue;
+            if (p.side && t.side !== p.side) continue;
+            pendingTrades.delete(id);
+            cancelled.push(id);
+          }
+        }
+        return jsonResult({ cancelled_count: cancelled.length, cancelled_ids: cancelled });
+      }
+    },
+    {
+      name: "poly_cancel_all",
+      description: "Cancel ALL orders (emergency)",
+      category: "enterprise",
+      parameters: { type: "object", properties: { confirm: { type: "boolean" } } },
+      async execute(_id, p) {
+        if (!p.confirm) return errorResult("Set confirm=true to cancel all orders");
+        const cancelled = [];
+        for (const [id, t] of pendingTrades) {
+          if (t.agentId === agentId) {
+            pendingTrades.delete(id);
+            cancelled.push(id);
+          }
+        }
+        return jsonResult({ status: "all_cancelled", cancelled_pending: cancelled.length, note: "Live CLOB orders require SDK to cancel" });
+      }
+    },
+    {
+      name: "poly_replace_order",
+      description: "Replace an order atomically",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        old_order_id: { type: "string" },
+        token_id: { type: "string" },
+        side: { type: "string" },
+        price: { type: "number" },
+        size: { type: "number" },
+        order_type: { type: "string" }
+      }, required: ["old_order_id", "token_id", "side", "price", "size"] },
+      async execute(_id, p) {
+        pendingTrades.delete(p.old_order_id);
+        const config = await loadConfig(agentId, db);
+        const check = preTradeChecks(agentId, config, p);
+        if (check) return errorResult(check);
+        return jsonResult({ status: "replaced", cancelled: p.old_order_id, new_order: { token_id: p.token_id, side: p.side, price: p.price, size: p.size } });
+      }
+    },
+    // ═══ TRADE HISTORY ══════════════════════════════════════════
+    {
+      name: "poly_trade_history",
+      description: "Trade history",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        limit: { type: "number" },
+        offset: { type: "number" },
+        market_id: { type: "string" },
+        side: { type: "string" },
+        start_date: { type: "string" },
+        end_date: { type: "string" },
+        min_size: { type: "number" }
+      } },
+      async execute(_id, p) {
+        const client = await getClobClient(agentId, db);
+        if (!client) return errorResult("Wallet not connected");
+        try {
+          const qs = new URLSearchParams({ maker_address: client.address, limit: String(p.limit || 50) });
+          if (p.market_id) qs.set("market", p.market_id);
+          const trades = await apiFetch(`${CLOB_API}/trades?${qs}`).catch(() => null);
+          return jsonResult(trades || { status: "requires_sdk" });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_export_trades",
+      description: "Export trade history",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        format: { type: "string" },
+        start_date: { type: "string" },
+        end_date: { type: "string" },
+        include_fees: { type: "boolean" },
+        output_path: { type: "string" }
+      } },
+      async execute() {
+        return jsonResult({ status: "requires_sdk", message: "Trade export requires authenticated CLOB client for full history access." });
+      }
+    },
+    // ═══ ANALYSIS ═══════════════════════════════════════════════
+    {
+      name: "poly_analyze_market",
+      description: "Deep market analysis",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        market_id: { type: "string" },
+        depth: { type: "string" },
+        include_news: { type: "boolean" },
+        include_whale_trades: { type: "boolean" },
+        include_book_analysis: { type: "boolean" }
+      }, required: ["market_id"] },
+      async execute(_id, p) {
+        try {
+          let marketData = await apiFetch(`${GAMMA_API}/markets/${p.market_id}`).catch(() => null);
+          if (!marketData) {
+            const arr = await apiFetch(`${GAMMA_API}/markets?slug=${p.market_id}&limit=1`).catch(() => null);
+            if (Array.isArray(arr) && arr[0]) marketData = arr[0];
+          }
+          if (!marketData && p.market_id?.startsWith("0x")) {
+            const arr = await apiFetch(`${GAMMA_API}/markets?condition_id=${p.market_id}&limit=1`).catch(() => null);
+            if (Array.isArray(arr) && arr[0]) marketData = arr[0];
+          }
+          if (!marketData) return errorResult('Market not found \u2014 try using the slug (e.g. "will-trump-win") or condition_id');
+          const timeseries = await apiFetch(`${GAMMA_API}/markets/${marketData.conditionId || p.market_id}/timeseries?fidelity=50`).catch(() => null);
+          let yesPrice = null, noPrice = null;
+          try {
+            const prices = JSON.parse(marketData.outcomePrices || "[]");
+            yesPrice = parseFloat(prices[0]);
+            noPrice = parseFloat(prices[1]);
+          } catch {
+          }
+          let bookAnalysis = null;
+          if (p.include_book_analysis !== false && marketData.clobTokenIds) {
+            try {
+              const tokenIds = JSON.parse(marketData.clobTokenIds || "[]");
+              if (tokenIds[0]) {
+                const book = await apiFetch(`${CLOB_API}/book?token_id=${tokenIds[0]}`);
+                const totalBids = (book?.bids || []).reduce((s, b) => s + parseFloat(b.size) * parseFloat(b.price), 0);
+                const totalAsks = (book?.asks || []).reduce((s, a) => s + parseFloat(a.size) * parseFloat(a.price), 0);
+                const bestBid = book?.bids?.[0]?.price;
+                const bestAsk = book?.asks?.[0]?.price;
+                bookAnalysis = {
+                  bestBid,
+                  bestAsk,
+                  spread: bestBid && bestAsk ? (parseFloat(bestAsk) - parseFloat(bestBid)).toFixed(4) : null,
+                  spreadPct: bestBid && bestAsk ? ((parseFloat(bestAsk) - parseFloat(bestBid)) / parseFloat(bestAsk) * 100).toFixed(2) + "%" : null,
+                  bidLiquidity: totalBids.toFixed(2),
+                  askLiquidity: totalAsks.toFixed(2),
+                  imbalance: totalBids + totalAsks > 0 ? ((totalBids - totalAsks) / (totalBids + totalAsks) * 100).toFixed(1) + "%" : null,
+                  bidLevels: (book?.bids || []).length,
+                  askLevels: (book?.asks || []).length
+                };
+              }
+            } catch {
+            }
+          }
+          let whaleTrades = null;
+          if (p.include_whale_trades !== false) {
+            try {
+              const tokenIds = JSON.parse(marketData.clobTokenIds || "[]");
+              if (tokenIds[0]) {
+                const trades = await apiFetch(`${CLOB_API}/trades?asset_id=${tokenIds[0]}&limit=50`);
+                const largeOnes = (Array.isArray(trades) ? trades : []).filter((t) => parseFloat(t.size || "0") >= 50).slice(0, 10);
+                if (largeOnes.length > 0) whaleTrades = largeOnes;
+              }
+            } catch {
+            }
+          }
+          let priceMovement = null;
+          if (Array.isArray(timeseries) && timeseries.length >= 2) {
+            const first = timeseries[0];
+            const last = timeseries[timeseries.length - 1];
+            const firstP = parseFloat(first?.p || first?.price || "0");
+            const lastP = parseFloat(last?.p || last?.price || "0");
+            if (firstP > 0) {
+              priceMovement = {
+                startPrice: firstP.toFixed(3),
+                currentPrice: lastP.toFixed(3),
+                changePct: ((lastP - firstP) / firstP * 100).toFixed(1) + "%",
+                dataPoints: timeseries.length
+              };
+            }
+          }
+          return jsonResult({
+            market: {
+              question: marketData.question,
+              description: marketData.description?.slice(0, 800),
+              volume: marketData.volume,
+              liquidity: marketData.liquidity,
+              endDate: marketData.endDate,
+              resolved: marketData.resolved,
+              negRisk: marketData.negRisk,
+              tickSize: marketData.minimumTickSize,
+              clobTokenIds: marketData.clobTokenIds
+            },
+            prices: { yes: yesPrice, no: noPrice },
+            impliedProbability: {
+              yes: yesPrice ? `${(yesPrice * 100).toFixed(1)}%` : null,
+              no: noPrice ? `${(noPrice * 100).toFixed(1)}%` : null,
+              overround: yesPrice && noPrice ? ((yesPrice + noPrice - 1) * 100).toFixed(2) + "%" : null
+            },
+            priceMovement,
+            orderBook: bookAnalysis,
+            whaleTrades
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_compare_markets",
+      description: "Compare markets side-by-side",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        market_ids: { type: "array", items: { type: "string" } },
+        metrics: { type: "array", items: { type: "string" } }
+      }, required: ["market_ids"] },
+      async execute(_id, p) {
+        try {
+          const results = await Promise.all(
+            (p.market_ids || []).map(async (id) => {
+              const m = await apiFetch(`${GAMMA_API}/markets/${id}`).catch(() => null);
+              if (!m) return { id, error: "not found" };
+              let prices = {};
+              try {
+                const pp = JSON.parse(m.outcomePrices || "[]");
+                prices = { yes: pp[0], no: pp[1] };
+              } catch {
+              }
+              return { id: m.conditionId || m.id, question: m.question, ...prices, volume: m.volume, liquidity: m.liquidity, endDate: m.endDate };
+            })
+          );
+          return jsonResult({ comparison: results });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_estimate_fill",
+      description: "Simulate order fill against order book",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        side: { type: "string" },
+        size: { type: "number" }
+      }, required: ["token_id", "side", "size"] },
+      async execute(_id, p) {
+        try {
+          const [book, mid] = await Promise.all([
+            apiFetch(`${CLOB_API}/book?token_id=${p.token_id}`),
+            apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`)
+          ]);
+          const levels = p.side === "BUY" ? book?.asks || [] : book?.bids || [];
+          const midPrice = parseFloat(mid?.mid || "0.5");
+          let filled = 0, totalCost = 0, levelsConsumed = 0;
+          for (const level of levels) {
+            const lvlPrice = parseFloat(level.price);
+            const lvlSize = parseFloat(level.size);
+            const fill = Math.min(p.size - filled, lvlSize);
+            totalCost += fill * lvlPrice;
+            filled += fill;
+            levelsConsumed++;
+            if (filled >= p.size) break;
+          }
+          const avgPrice = filled > 0 ? totalCost / filled : 0;
+          const slippage = midPrice > 0 ? Math.abs(avgPrice - midPrice) / midPrice * 100 : 0;
+          return jsonResult({
+            requested_size: p.size,
+            fillable_size: parseFloat(filled.toFixed(4)),
+            fully_fillable: filled >= p.size,
+            midpoint: midPrice,
+            estimated_avg_price: parseFloat(avgPrice.toFixed(6)),
+            estimated_cost: parseFloat(totalCost.toFixed(2)),
+            slippage_pct: parseFloat(slippage.toFixed(3)),
+            price_levels_consumed: levelsConsumed,
+            total_levels_available: levels.length,
+            warning: filled < p.size ? `Only ${filled.toFixed(2)} of ${p.size} can be filled at current liquidity` : void 0
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ═══ CONFIGURATION ══════════════════════════════════════════
+    {
+      name: "poly_set_config",
+      description: "Configure trading behavior",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        mode: { type: "string" },
+        max_position_size: { type: "number" },
+        max_order_size: { type: "number" },
+        max_total_exposure: { type: "number" },
+        max_daily_trades: { type: "number" },
+        max_daily_loss: { type: "number" },
+        max_drawdown_pct: { type: "number" },
+        allowed_categories: { type: "array", items: { type: "string" } },
+        blocked_categories: { type: "array", items: { type: "string" } },
+        blocked_markets: { type: "array", items: { type: "string" } },
+        min_liquidity: { type: "number" },
+        min_volume: { type: "number" },
+        max_spread_pct: { type: "number" },
+        stop_loss_pct: { type: "number" },
+        take_profit_pct: { type: "number" },
+        trailing_stop_pct: { type: "number" },
+        rebalance_interval: { type: "string" },
+        notification_channel: { type: "string" },
+        notify_on: { type: "array", items: { type: "string" } },
+        cash_reserve_pct: { type: "number" }
+      } },
+      async execute(_id, p) {
+        const existing = await loadConfig(agentId, db);
+        const updated = {
+          mode: p.mode || existing.mode,
+          maxPositionSize: p.max_position_size ?? existing.maxPositionSize,
+          maxOrderSize: p.max_order_size ?? existing.maxOrderSize,
+          maxTotalExposure: p.max_total_exposure ?? existing.maxTotalExposure,
+          maxDailyTrades: p.max_daily_trades ?? existing.maxDailyTrades,
+          maxDailyLoss: p.max_daily_loss ?? existing.maxDailyLoss,
+          maxDrawdownPct: p.max_drawdown_pct ?? existing.maxDrawdownPct,
+          allowedCategories: p.allowed_categories ?? existing.allowedCategories,
+          blockedCategories: p.blocked_categories ?? existing.blockedCategories,
+          blockedMarkets: p.blocked_markets ?? existing.blockedMarkets,
+          minLiquidity: p.min_liquidity ?? existing.minLiquidity,
+          minVolume: p.min_volume ?? existing.minVolume,
+          maxSpreadPct: p.max_spread_pct ?? existing.maxSpreadPct,
+          stopLossPct: p.stop_loss_pct ?? existing.stopLossPct,
+          takeProfitPct: p.take_profit_pct ?? existing.takeProfitPct,
+          trailingStopPct: p.trailing_stop_pct ?? existing.trailingStopPct,
+          rebalanceInterval: p.rebalance_interval ?? existing.rebalanceInterval,
+          notificationChannel: p.notification_channel ?? existing.notificationChannel,
+          notifyOn: p.notify_on ?? existing.notifyOn,
+          cashReservePct: p.cash_reserve_pct ?? existing.cashReservePct
+        };
+        await saveConfig(agentId, db, updated);
+        agentConfigs.set(agentId, updated);
+        return jsonResult({ status: "ok", config: updated, persisted: true });
+      }
+    },
+    {
+      name: "poly_get_config",
+      description: "Get current config",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        return jsonResult(await loadConfig(agentId, db));
+      }
+    },
+    {
+      name: "poly_circuit_breaker",
+      description: "Circuit breaker controls",
+      category: "enterprise",
+      parameters: { type: "object", properties: { action: { type: "string" }, reason: { type: "string" } }, required: ["action"] },
+      async execute(_id, p) {
+        switch (p.action) {
+          case "status": {
+            const counter = await getDailyCounter(agentId, db);
+            return jsonResult({ paused: counter.paused, reason: counter.reason, dailyTrades: counter.count, dailyLoss: counter.loss });
+          }
+          case "pause":
+            await pauseTrading(agentId, db, p.reason || "Manual pause");
+            circuitBreakerState.set(agentId, { paused: true, reason: p.reason || "Manual pause", pausedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            return jsonResult({ status: "paused", reason: p.reason || "Manual pause" });
+          case "resume":
+            await resumeTrading(agentId, db);
+            circuitBreakerState.set(agentId, { paused: false, reason: "" });
+            return jsonResult({ status: "resumed" });
+          case "reset_daily":
+            await resumeTrading(agentId, db);
+            dailyCounters.delete(agentId);
+            circuitBreakerState.set(agentId, { paused: false, reason: "" });
+            return jsonResult({ status: "reset", message: "Daily counters and circuit breaker reset" });
+          default:
+            return errorResult("action must be: status, pause, resume, or reset_daily");
+        }
+      }
+    },
+    // ═══ PRICE ALERTS ═══════════════════════════════════════════
+    {
+      name: "poly_set_alert",
+      description: "Set a price alert",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        market_question: { type: "string" },
+        condition: { type: "string" },
+        target_price: { type: "number" },
+        pct_change: { type: "number" },
+        repeat: { type: "boolean" },
+        auto_trade: { type: "object" }
+      }, required: ["token_id", "condition"] },
+      async execute(_id, p) {
+        try {
+          const { safeDbGet: safeDbGet2 } = await import("./polymarket-shared-M5ZU3HKM.js");
+          const watcherCount = await safeDbGet2(db, `SELECT COUNT(*) as cnt FROM poly_watchers WHERE agent_id = ? AND status = 'active'`, [agentId]);
+          if (!watcherCount || watcherCount.cnt === 0 || watcherCount.cnt === "0") {
+            return jsonResult({
+              status: "BLOCKED",
+              error: "You have ZERO active watchers. You MUST set up watchers BEFORE creating alerts.",
+              required_action: "Run poly_watcher_config action=set provider=xai model=grok-3-mini FIRST, then run poly_setup_monitors to create your monitoring suite. After watchers are active, you can create alerts.",
+              help: "Alerts are simple price triggers. Watchers are AI-powered monitors that appear on the Monitors tab. Your manager requires BOTH."
+            });
+          }
+        } catch {
+        }
+        let basePrice = 0.5;
+        try {
+          const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`);
+          basePrice = parseFloat(mid?.mid || "0.5");
+        } catch {
+        }
+        const alertId = `alert_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        await saveAlert(db, {
+          id: alertId,
+          agentId,
+          tokenId: p.token_id,
+          marketQuestion: p.market_question || "",
+          condition: p.condition,
+          targetPrice: p.target_price,
+          pctChange: p.pct_change,
+          basePrice,
+          repeat: p.repeat || false,
+          autoTrade: p.auto_trade
+        });
+        return jsonResult({ status: "created", alert_id: alertId, persisted: true, note: "Alerts are checked during heartbeat/polling." });
+      }
+    },
+    {
+      name: "poly_list_alerts",
+      description: "List price alerts",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const alerts = await getAlerts(agentId, db);
+        return jsonResult({ count: alerts.length, alerts });
+      }
+    },
+    {
+      name: "poly_delete_alert",
+      description: "Delete price alert",
+      category: "enterprise",
+      parameters: { type: "object", properties: { alert_id: { type: "string" }, delete_all: { type: "boolean" } } },
+      async execute(_id, p) {
+        if (p.delete_all) {
+          await deleteAllAlerts(agentId, db);
+          return jsonResult({ status: "all_deleted" });
+        }
+        await deleteAlert(db, p.alert_id);
+        return jsonResult({ status: "deleted" });
+      }
+    },
+    // ═══ BRACKET ORDERS (Take-Profit + Stop-Loss) ═════════════
+    {
+      name: "poly_bracket_config",
+      description: "Configure automatic bracket orders (take-profit + stop-loss) that are created on every BUY. When a BUY executes, two sell alerts are auto-created: one at +X% (take profit) and one at -Y% (stop loss). When either fires, the other is cancelled (OCO).",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        enabled: { type: "boolean", description: "Enable/disable bracket orders (default: true)" },
+        take_profit_pct: { type: "number", description: "Take-profit percentage above buy price (default: 15)" },
+        stop_loss_pct: { type: "number", description: "Stop-loss percentage below buy price (default: 10)" }
+      } },
+      async execute(_id, p) {
+        const config = await loadConfig(agentId, db) || {};
+        const bracket = config.bracket || {};
+        if (p.enabled !== void 0) bracket.enabled = p.enabled;
+        if (p.take_profit_pct !== void 0) {
+          bracket.take_profit_pct = p.take_profit_pct;
+          config.takeProfitPct = p.take_profit_pct;
+        }
+        if (p.stop_loss_pct !== void 0) {
+          bracket.stop_loss_pct = p.stop_loss_pct;
+          config.stopLossPct = p.stop_loss_pct;
+        }
+        config.bracket = bracket;
+        await saveConfig(agentId, db, config);
+        return jsonResult({
+          status: "updated",
+          bracket: {
+            enabled: bracket.enabled !== false,
+            take_profit_pct: bracket.take_profit_pct ?? config.takeProfitPct ?? 15,
+            stop_loss_pct: bracket.stop_loss_pct ?? config.stopLossPct ?? 10
+          },
+          note: "Also synced to central Trading Configuration (poly_set_config).",
+          message: bracket.enabled === false ? "Bracket orders DISABLED. BUY orders will NOT auto-create TP/SL alerts." : `Bracket orders ENABLED. Every BUY will auto-create: TP at +${bracket.take_profit_pct ?? config.takeProfitPct ?? 15}%, SL at -${bracket.stop_loss_pct ?? config.stopLossPct ?? 10}%`
+        });
+      }
+    },
+    {
+      name: "poly_list_brackets",
+      description: "List active bracket order pairs (take-profit + stop-loss groups)",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        try {
+          const rows = await (db.query || db.execute).call(
+            db,
+            `SELECT * FROM poly_price_alerts WHERE agent_id = $1 AND bracket_group IS NOT NULL AND triggered = 0 ORDER BY bracket_group, bracket_role`,
+            [agentId]
+          );
+          const alerts = rows?.rows || rows || [];
+          const groups = {};
+          for (const a of alerts) {
+            if (!groups[a.bracket_group]) groups[a.bracket_group] = { group: a.bracket_group, alerts: [] };
+            groups[a.bracket_group].alerts.push({
+              id: a.id,
+              role: a.bracket_role,
+              condition: a.condition,
+              target_price: a.target_price,
+              base_price: a.base_price,
+              token_id: a.token_id,
+              market: a.market_question
+            });
+          }
+          const bracketList = Object.values(groups);
+          return jsonResult({ count: bracketList.length, brackets: bracketList });
+        } catch {
+          return jsonResult({ count: 0, brackets: [] });
+        }
+      }
+    },
+    // ═══ APPROVAL QUEUE ═════════════════════════════════════════
+    {
+      name: "poly_pending_trades",
+      description: "List pending approvals",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const pending = await getPendingTrades(agentId, db);
+        return jsonResult({ count: pending.length, trades: pending });
+      }
+    },
+    {
+      name: "poly_approve_trade",
+      description: "Approve a trade and execute it",
+      category: "enterprise",
+      parameters: { type: "object", properties: { trade_id: { type: "string" }, modify_price: { type: "number" }, modify_size: { type: "number" } }, required: ["trade_id"] },
+      async execute(_id, p) {
+        await resolvePendingTrade(db, p.trade_id, "approved", "agent");
+        await incrementDailyCounter(agentId, db);
+        const pending = await getPendingTrades(agentId, db);
+        const trade = pending.find((t) => t.id === p.trade_id);
+        if (trade) {
+          const execResult = await executeOrder(agentId, db, p.trade_id, {
+            token_id: trade.token_id,
+            side: trade.side,
+            price: p.modify_price || trade.price,
+            size: p.modify_size || trade.size,
+            order_type: trade.order_type,
+            tick_size: trade.tick_size,
+            neg_risk: trade.neg_risk,
+            market_question: trade.market_question,
+            outcome: trade.outcome,
+            rationale: trade.rationale
+          }, "approved");
+          return execResult;
+        }
+        return jsonResult({ status: "approved", trade_id: p.trade_id, message: "Trade approved" });
+      }
+    },
+    {
+      name: "poly_reject_trade",
+      description: "Reject a trade",
+      category: "enterprise",
+      parameters: { type: "object", properties: { trade_id: { type: "string" }, reason: { type: "string" } }, required: ["trade_id"] },
+      async execute(_id, p) {
+        await resolvePendingTrade(db, p.trade_id, "rejected", p.reason || "agent");
+        return jsonResult({ status: "rejected", trade_id: p.trade_id, reason: p.reason });
+      }
+    },
+    {
+      name: "poly_auto_approve_rule",
+      description: "Auto-approve rules",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        action: { type: "string" },
+        rule_id: { type: "string" },
+        max_size: { type: "number" },
+        categories: { type: "array", items: { type: "string" } },
+        sides: { type: "array", items: { type: "string" } }
+      }, required: ["action"] },
+      async execute(_id, p) {
+        const rules = await getAutoApproveRules(agentId, db);
+        switch (p.action) {
+          case "list":
+            return jsonResult({ rules });
+          case "add": {
+            const rule = {
+              id: `rule_${Date.now()}`,
+              agentId,
+              maxSize: p.max_size || 10,
+              categories: p.categories || [],
+              sides: p.sides || ["BUY", "SELL"]
+            };
+            await saveAutoApproveRule(db, rule);
+            return jsonResult({ status: "added", rule, total_rules: rules.length + 1 });
+          }
+          case "remove": {
+            await deleteAutoApproveRule(db, p.rule_id);
+            return jsonResult({ status: "removed" });
+          }
+          default:
+            return errorResult("action must be: list, add, or remove");
+        }
+      }
+    },
+    // ═══ LEADERBOARD & SOCIAL ═══════════════════════════════════
+    {
+      name: "poly_leaderboard",
+      description: "Top traders",
+      category: "enterprise",
+      parameters: { type: "object", properties: { period: { type: "string" }, limit: { type: "number" }, sort_by: { type: "string" } } },
+      async execute(_id, p) {
+        try {
+          const data = await apiFetch(`${GAMMA_API}/leaderboard?limit=${p.limit || 20}`);
+          return jsonResult(data);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_top_holders",
+      description: "Top holders for a market",
+      category: "enterprise",
+      parameters: { type: "object", properties: { market_id: { type: "string" }, outcome: { type: "string" }, limit: { type: "number" } }, required: ["market_id"] },
+      async execute(_id, p) {
+        try {
+          const data = await apiFetch(`${GAMMA_API}/markets/${p.market_id}/holders?limit=${p.limit || 20}`);
+          return jsonResult(data);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_track_wallet",
+      description: "Track a wallet's activity",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        address: { type: "string" },
+        include_positions: { type: "boolean" },
+        include_trades: { type: "boolean" },
+        limit: { type: "number" }
+      }, required: ["address"] },
+      async execute(_id, p) {
+        try {
+          const results = { address: p.address };
+          const [positions, trades] = await Promise.all([
+            p.include_positions !== false ? apiFetch(`https://data-api.polymarket.com/positions?user=${p.address}`).catch(() => apiFetch(`${GAMMA_API}/positions?user=${p.address}&limit=${p.limit || 20}`).catch(() => null)) : null,
+            p.include_trades !== false ? apiFetch(`${CLOB_API}/trades?maker_address=${p.address}&limit=${p.limit || 20}`).catch(() => null) : null
+          ]);
+          if (positions) results.positions = positions;
+          if (trades) results.trades = trades;
+          return jsonResult(results);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ═══ PAPER TRADING ══════════════════════════════════════════
+    {
+      name: "poly_paper_trade",
+      description: "Simulate a trade",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string" },
+        side: { type: "string" },
+        price: { type: "number" },
+        size: { type: "number" },
+        market_question: { type: "string" },
+        rationale: { type: "string" }
+      }, required: ["token_id", "side", "size"] },
+      async execute(_id, p) {
+        try {
+          const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`).catch(() => ({ mid: p.price || "0.5" }));
+          const fillPrice = p.price || parseFloat(mid?.mid || "0.5");
+          await savePaperPosition(db, {
+            agentId,
+            tokenId: p.token_id,
+            side: p.side,
+            entryPrice: fillPrice,
+            size: p.size,
+            marketQuestion: p.market_question || "",
+            rationale: p.rationale || ""
+          });
+          return jsonResult({ status: "paper_filled", entry_price: fillPrice, persisted: true });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_paper_portfolio",
+      description: "Paper trading portfolio",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const positions = await getPaperPositions(agentId, db);
+        const withPnl = await Promise.all(positions.map(async (pos) => {
+          try {
+            const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${pos.token_id}`);
+            const currentPrice = parseFloat(mid?.mid || String(pos.entry_price));
+            const pnl = pos.side === "BUY" ? (currentPrice - pos.entry_price) * pos.size : (pos.entry_price - currentPrice) * pos.size;
+            return { ...pos, currentPrice, pnl: parseFloat(pnl.toFixed(2)), pnlPct: parseFloat((pnl / (pos.entry_price * pos.size) * 100).toFixed(2)) };
+          } catch {
+            return { ...pos, currentPrice: null, pnl: null };
+          }
+        }));
+        const totalPnl = withPnl.reduce((s, p) => s + (p.pnl || 0), 0);
+        const winners = withPnl.filter((p) => (p.pnl || 0) > 0).length;
+        const losers = withPnl.filter((p) => (p.pnl || 0) < 0).length;
+        return jsonResult({
+          positions: withPnl,
+          summary: {
+            totalPositions: positions.length,
+            totalPnl: parseFloat(totalPnl.toFixed(2)),
+            winners,
+            losers,
+            winRate: positions.length > 0 ? `${(winners / positions.length * 100).toFixed(0)}%` : "N/A"
+          }
+        });
+      }
+    },
+    // ═══ SYSTEM & HEALTH ════════════════════════════════════════
+    {
+      name: "poly_api_status",
+      description: "Check API health",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const start = Date.now();
+        try {
+          const [clobOk, gammaOk] = await Promise.all([
+            apiFetch(`${CLOB_API}/`, { timeoutMs: 5e3 }).then(() => true).catch(() => false),
+            apiFetch(`${GAMMA_API}/markets?limit=1`, { timeoutMs: 5e3 }).then(() => true).catch(() => false)
+          ]);
+          return jsonResult({
+            clob_api: clobOk ? "healthy" : "unreachable",
+            gamma_api: gammaOk ? "healthy" : "unreachable",
+            latency_ms: Date.now() - start,
+            chain: "Polygon (137)"
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_gas_price",
+      description: "Polygon gas price",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        try {
+          const gas = await apiFetch("https://gasstation.polygon.technology/v2");
+          return jsonResult(gas);
+        } catch (e) {
+          return jsonResult({ status: "fallback", message: "Gas API unavailable. Polygon typically costs <0.01 MATIC per tx." });
+        }
+      }
+    },
+    {
+      name: "poly_heartbeat",
+      description: "COMPREHENSIVE MARKET WATCHER \u2014 Run this periodically (every 15-30 min via cron or heartbeat). Checks: (1) all active price alerts and fires triggered ones, (2) open positions for P&L changes, (3) unresolved predictions that may have settled, (4) portfolio health and balance, (5) CLOB API status. Returns a full status report with any actions needed.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        check_alerts: { type: "boolean", description: "Check price alerts (default: true)" },
+        check_positions: { type: "boolean", description: "Check open positions (default: true)" },
+        check_predictions: { type: "boolean", description: "Check unresolved predictions (default: true)" },
+        check_balance: { type: "boolean", description: "Check wallet/exchange balance (default: true)" },
+        run_screener: { type: "boolean", description: "Run quick screener for new opportunities (default: false \u2014 set true for active scanning)" }
+      } },
+      async execute(_id, p) {
+        const report = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), actions_needed: [] };
+        try {
+          const time = await apiFetch(`${CLOB_API}/time`);
+          report.api_status = "online";
+          report.server_time = time;
+        } catch (e) {
+          report.api_status = "DOWN";
+          report.api_error = e.message;
+          report.actions_needed.push({ type: "critical", message: "CLOB API is DOWN \u2014 cannot trade" });
+        }
+        if (p.check_alerts !== false) {
+          try {
+            const triggered = await checkAlerts(agentId, db);
+            report.alerts = {
+              triggered: triggered.length,
+              details: triggered
+            };
+            for (const t of triggered) {
+              report.actions_needed.push({
+                type: "alert_triggered",
+                message: `ALERT: ${t.market} \u2014 ${t.reason}`,
+                token_id: t.token_id,
+                auto_trade: t.auto_trade
+              });
+            }
+            const remaining = await getAlerts(agentId, db);
+            report.alerts.active_count = remaining.length;
+          } catch (e) {
+            report.alerts = { error: e.message };
+          }
+        }
+        if (p.check_positions !== false) {
+          try {
+            const client = await getClobClient(agentId, db);
+            if (client) {
+              const openOrders = await apiFetch(`${CLOB_API}/orders?status=live`, {
+                headers: { Authorization: `Bearer ${client.apiKey}` }
+              }).catch(() => []);
+              const addr = client.funderAddress || client.address;
+              let positions = await apiFetch(`https://data-api.polymarket.com/positions?user=${addr}`).catch(() => null);
+              if (!positions) positions = await apiFetch(`${GAMMA_API}/positions?user=${addr}&limit=20`).catch(() => []);
+              const activePositions = (Array.isArray(positions) ? positions : []).filter(
+                (pos) => parseFloat(pos.size || "0") > 0
+              );
+              report.positions = {
+                open_orders: Array.isArray(openOrders) ? openOrders.length : 0,
+                active_positions: activePositions.length
+              };
+              for (const pos of activePositions.slice(0, 10)) {
+                try {
+                  const tokenId = pos.asset || pos.token_id;
+                  if (!tokenId) continue;
+                  const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${tokenId}`);
+                  const currentPrice = parseFloat(mid?.mid || "0");
+                  const entryPrice = parseFloat(pos.avgPrice || pos.entry_price || "0");
+                  const size = parseFloat(pos.size || "0");
+                  if (currentPrice && entryPrice && size) {
+                    const pnl = (currentPrice - entryPrice) * size;
+                    const pnlPct = (currentPrice - entryPrice) / entryPrice * 100;
+                    if (Math.abs(pnlPct) > 10) {
+                      report.actions_needed.push({
+                        type: pnl > 0 ? "take_profit" : "stop_loss",
+                        message: `Position ${pos.title || tokenId}: ${pnlPct > 0 ? "+" : ""}${pnlPct.toFixed(1)}% (${pnl > 0 ? "+" : ""}$${pnl.toFixed(2)})`,
+                        token_id: tokenId,
+                        current_price: currentPrice,
+                        entry_price: entryPrice,
+                        pnl: parseFloat(pnl.toFixed(2))
+                      });
+                    }
+                  }
+                } catch {
+                }
+              }
+            }
+          } catch (e) {
+            report.positions = { error: e.message };
+          }
+        }
+        if (p.check_predictions !== false) {
+          try {
+            const unresolved = await getUnresolvedPredictions(agentId, db, void 0);
+            report.predictions = { unresolved: unresolved.length };
+            for (const pred of unresolved.slice(0, 10)) {
+              try {
+                if (!pred.market_id) continue;
+                const market = await apiFetch(`${GAMMA_API}/markets/${pred.market_id}`).catch(() => null);
+                if (market?.resolved) {
+                  report.actions_needed.push({
+                    type: "resolve_prediction",
+                    message: `Market SETTLED: "${pred.market_question}" \u2014 resolve prediction ${pred.id}`,
+                    prediction_id: pred.id,
+                    market_id: pred.market_id,
+                    outcome: market.outcome
+                  });
+                }
+              } catch {
+              }
+            }
+          } catch (e) {
+            report.predictions = { error: e.message };
+          }
+        }
+        if (p.check_balance !== false) {
+          try {
+            const client = await getClobClient(agentId, db);
+            if (client) {
+              const bal = await client.client.getBalanceAllowance({ asset_type: "COLLATERAL" });
+              report.balance = {
+                exchange: bal?.balance || "0",
+                allowances_ok: Object.values(bal?.allowances || {}).every((v) => v !== "0" && v !== 0)
+              };
+            }
+          } catch (e) {
+            report.balance = { error: e.message };
+          }
+        }
+        if (p.run_screener) {
+          try {
+            const { screenMarkets: screenMarkets2 } = await import("./screener-JFQSJY3B.js");
+            const scan = await screenMarkets2({ strategy: "best_opportunities", limit: 5 });
+            report.opportunities = {
+              scanned: scan.scanned,
+              top_picks: scan.markets.slice(0, 3).map((s) => ({
+                question: s.market.question,
+                score: s.scores.total,
+                recommendation: s.recommendation
+              }))
+            };
+          } catch (e) {
+            report.opportunities = { error: e.message };
+          }
+        }
+        report.summary = {
+          actions_count: report.actions_needed.length,
+          status: report.actions_needed.length > 0 ? report.actions_needed.some((a) => a.type === "critical") ? "CRITICAL" : "NEEDS_ATTENTION" : "ALL_CLEAR"
+        };
+        return jsonResult(report);
+      }
+    },
+    // ═══ LEARNING & TRADE JOURNAL ═══════════════════════════════
+    {
+      name: "poly_record_prediction",
+      description: "Record a prediction BEFORE placing a trade. This is your pre-trade journal entry \u2014 write down what you think will happen, why, and how confident you are. Essential for learning from outcomes later. Call this before every poly_place_order.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        token_id: { type: "string", description: "Token being traded" },
+        market_id: { type: "string", description: "Market ID" },
+        market_question: { type: "string", description: "Market question text" },
+        predicted_outcome: { type: "string", description: 'What you predict (e.g. "Yes", "No", "price_up", "price_down")' },
+        predicted_probability: { type: "number", description: "Your estimated probability (0-1)" },
+        confidence: { type: "number", description: "How confident you are in your analysis (0-1)" },
+        reasoning: { type: "string", description: "Why you think this \u2014 be specific. Future you will review this." },
+        signals_used: { type: "array", items: { type: "string" }, description: 'Which signals/tools influenced this (e.g. ["RSI", "news_sentiment", "order_book_imbalance"])' },
+        category: { type: "string", description: 'Market category (e.g. "politics", "crypto", "sports")' }
+      }, required: ["token_id", "predicted_outcome", "predicted_probability", "confidence"] },
+      async execute(_id, p) {
+        try {
+          let marketPrice = 0.5;
+          try {
+            const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${p.token_id}`);
+            marketPrice = parseFloat(mid?.mid || "0.5");
+          } catch {
+          }
+          const predId = `pred_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          await recordPrediction(db, {
+            id: predId,
+            agentId,
+            marketId: p.market_id,
+            tokenId: p.token_id,
+            marketQuestion: p.market_question,
+            predictedOutcome: p.predicted_outcome,
+            predictedProbability: p.predicted_probability,
+            marketPrice,
+            confidence: p.confidence,
+            reasoning: p.reasoning,
+            signalsUsed: p.signals_used,
+            category: p.category
+          });
+          const edge = p.predicted_probability - marketPrice;
+          return jsonResult({
+            status: "recorded",
+            prediction_id: predId,
+            your_estimate: `${(p.predicted_probability * 100).toFixed(1)}%`,
+            market_price: `${(marketPrice * 100).toFixed(1)}%`,
+            edge: `${(edge * 100).toFixed(1)}%`,
+            confidence: `${(p.confidence * 100).toFixed(0)}%`,
+            message: "Prediction journaled. After the market resolves, use poly_resolve_prediction to log the outcome and learn."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_resolve_prediction",
+      description: "Resolve a prediction after a market settles. Records whether you were right or wrong, calculates P&L, and updates your calibration scores and strategy stats. This is the feedback loop \u2014 without it, you cannot learn.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        prediction_id: { type: "string", description: "ID from poly_record_prediction" },
+        actual_outcome: { type: "string", description: 'What actually happened (e.g. "Yes", "No")' },
+        pnl: { type: "number", description: "Profit/loss in USDC from this trade" }
+      }, required: ["prediction_id", "actual_outcome"] },
+      async execute(_id, p) {
+        try {
+          await resolvePrediction(db, p.prediction_id, p.actual_outcome, p.pnl || 0);
+          return jsonResult({
+            status: "resolved",
+            prediction_id: p.prediction_id,
+            actual_outcome: p.actual_outcome,
+            pnl: p.pnl || 0,
+            message: "Prediction resolved. Calibration and strategy stats updated. Run poly_trade_review to extract lessons."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_trade_review",
+      description: "Review recent resolved trades to extract lessons learned. This is your retrospective \u2014 look at what went right and wrong, identify patterns in your mistakes, and record actionable lessons. Do this regularly (daily or after every batch of resolutions). The lessons you record here will be recalled before future trades.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        limit: { type: "number", description: "How many resolved trades to review (default: 10)" }
+      } },
+      async execute(_id, p) {
+        try {
+          const resolved = await getResolvedPredictions(agentId, db, p.limit || 10);
+          if (resolved.length === 0) return jsonResult({ message: "No unreviewed trades. Either no trades have resolved or all have been reviewed." });
+          const correct = resolved.filter((r) => r.was_correct);
+          const wrong = resolved.filter((r) => !r.was_correct);
+          const totalPnl = resolved.reduce((s, r) => s + (r.pnl || 0), 0);
+          return jsonResult({
+            trades_to_review: resolved.length,
+            summary: {
+              correct: correct.length,
+              wrong: wrong.length,
+              win_rate: `${(correct.length / resolved.length * 100).toFixed(0)}%`,
+              total_pnl: totalPnl.toFixed(2)
+            },
+            wrong_predictions: wrong.map((w) => ({
+              id: w.id,
+              market: w.market_question,
+              predicted: w.predicted_outcome,
+              actual: w.actual_outcome,
+              confidence: `${(w.confidence * 100).toFixed(0)}%`,
+              reasoning: w.reasoning,
+              your_probability: `${(w.predicted_probability * 100).toFixed(1)}%`,
+              market_price: `${(w.market_price_at_prediction * 100).toFixed(1)}%`,
+              pnl: w.pnl
+            })),
+            correct_predictions: correct.map((c) => ({
+              id: c.id,
+              market: c.market_question,
+              confidence: `${(c.confidence * 100).toFixed(0)}%`,
+              pnl: c.pnl
+            })),
+            instructions: "Review the wrong predictions carefully. For each one, ask: Why was I wrong? Was my reasoning flawed, or was it bad luck? Then call poly_record_lesson with your insights. After review, these trades will be marked as reviewed.",
+            prediction_ids: resolved.map((r) => r.id)
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_record_lesson",
+      description: 'Record a lesson learned from reviewing trades. These lessons persist in the database and are recalled before future trades to prevent repeating mistakes. Be specific and actionable \u2014 "I was wrong about X because Y, next time I should Z."',
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        lesson: { type: "string", description: 'The lesson. Be specific: "I overweighted news sentiment for crypto markets \u2014 price already moved before I saw the news. Use order flow signals instead."' },
+        category: { type: "string", description: 'Market category this applies to (e.g. "politics", "crypto", "sports", "general")', default: "general" },
+        source_prediction_ids: { type: "array", items: { type: "string" }, description: "Prediction IDs that led to this lesson" },
+        importance: { type: "string", enum: ["critical", "high", "normal", "low"], default: "normal" }
+      }, required: ["lesson"] },
+      async execute(_id, p) {
+        try {
+          const lessonId = `lesson_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          await storeLesson(db, {
+            id: lessonId,
+            agentId,
+            lesson: p.lesson,
+            category: p.category || "general",
+            sourcePredictionIds: p.source_prediction_ids,
+            importance: p.importance
+          });
+          if (p.source_prediction_ids?.length) {
+            await markLessonsExtracted(db, p.source_prediction_ids);
+          }
+          return jsonResult({
+            status: "recorded",
+            lesson_id: lessonId,
+            message: "Lesson stored. It will be recalled before future trades in this category."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_recall_lessons",
+      description: "Recall lessons learned from past trades. Call this BEFORE making a new trade to avoid repeating mistakes. Returns relevant lessons filtered by market category.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        category: { type: "string", description: 'Market category to recall lessons for (e.g. "politics", "crypto"). Omit for all lessons.' }
+      } },
+      async execute(_id, p) {
+        try {
+          const lessons = await recallLessons(agentId, db, p.category);
+          if (lessons.length === 0) return jsonResult({ message: "No lessons recorded yet. Trade, review, and learn." });
+          return jsonResult({
+            count: lessons.length,
+            lessons: lessons.map((l) => ({
+              lesson: l.lesson,
+              category: l.category,
+              importance: l.importance,
+              times_applied: l.times_applied,
+              recorded_at: l.created_at
+            }))
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_calibration",
+      description: 'Check your prediction calibration \u2014 are you overconfident or underconfident? Shows your accuracy at each confidence level. A well-calibrated predictor who says "70% confident" should be right ~70% of the time. Use this to adjust your confidence levels.',
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        try {
+          const calibration = await getCalibration(agentId, db);
+          if (calibration.length === 0) return jsonResult({ message: "No resolved predictions yet. Record and resolve predictions to build calibration data." });
+          const totalPreds = calibration.reduce((s, c) => s + c.predictions, 0);
+          const totalCorrect = calibration.reduce((s, c) => s + c.correct, 0);
+          let brierSum = 0;
+          for (const bucket of calibration) {
+            const midpoint = parseInt(bucket.bucket) / 100 + 0.05;
+            const actualRate = bucket.predictions > 0 ? bucket.correct / bucket.predictions : 0;
+            brierSum += bucket.predictions * (midpoint - actualRate) ** 2;
+          }
+          const avgCalibrationError = totalPreds > 0 ? Math.sqrt(brierSum / totalPreds) : 0;
+          return jsonResult({
+            overall: {
+              total_predictions: totalPreds,
+              total_correct: totalCorrect,
+              overall_accuracy: `${(totalCorrect / (totalPreds || 1) * 100).toFixed(1)}%`,
+              calibration_error: `${(avgCalibrationError * 100).toFixed(1)}%`,
+              assessment: avgCalibrationError < 0.05 ? "WELL_CALIBRATED" : avgCalibrationError < 0.1 ? "SLIGHTLY_OFF" : avgCalibrationError < 0.2 ? "POORLY_CALIBRATED" : "SEVERELY_MISCALIBRATED"
+            },
+            buckets: calibration.map((c) => {
+              const actualRate = c.predictions > 0 ? (c.correct / c.predictions * 100).toFixed(1) : "0.0";
+              const expected = parseInt(c.bucket) + 5;
+              return {
+                confidence_range: c.bucket,
+                predictions: c.predictions,
+                correct: c.correct,
+                actual_accuracy: `${actualRate}%`,
+                expected_accuracy: `~${expected}%`,
+                bias: parseFloat(actualRate) > expected ? "UNDERCONFIDENT (good \u2014 means you have more edge than you think)" : parseFloat(actualRate) < expected - 10 ? "OVERCONFIDENT (bad \u2014 reduce confidence or be more selective)" : "CALIBRATED"
+              };
+            })
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_strategy_performance",
+      description: "See which trading signals/strategies are actually working for you and which are losing money. Rankings by win rate and P&L. Use this to stop using bad signals and double down on good ones.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        try {
+          const strategies = await getStrategyPerformance(agentId, db);
+          if (strategies.length === 0) return jsonResult({ message: "No strategy data yet. Record predictions with signals_used to track performance by strategy." });
+          return jsonResult({
+            strategies: strategies.map((s) => ({
+              name: s.strategy_name,
+              trades: s.total_predictions,
+              wins: s.correct_predictions,
+              win_rate: `${s.win_rate}%`,
+              total_pnl: `$${s.total_pnl.toFixed(2)}`,
+              avg_confidence: `${(s.avg_confidence * 100).toFixed(0)}%`,
+              verdict: s.win_rate > 60 ? "KEEP \u2014 this signal works" : s.win_rate > 45 ? "NEUTRAL \u2014 needs more data" : "CONSIDER DROPPING \u2014 losing signal"
+            })),
+            recommendation: "Weight future trades toward your best-performing signals. Drop or reduce weight on consistently losing strategies."
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "poly_unresolved_predictions",
+      description: "List predictions that havent been resolved yet. Use this to check which markets you have open predictions on, and resolve them when the market settles.",
+      category: "enterprise",
+      parameters: { type: "object", properties: {
+        market_id: { type: "string", description: "Filter by market ID" }
+      } },
+      async execute(_id, p) {
+        try {
+          const unresolved = await getUnresolvedPredictions(agentId, db, p.market_id);
+          return jsonResult({
+            count: unresolved.length,
+            predictions: unresolved.map((u) => ({
+              id: u.id,
+              market: u.market_question,
+              predicted: u.predicted_outcome,
+              your_probability: `${(u.predicted_probability * 100).toFixed(1)}%`,
+              market_price_then: `${(u.market_price_at_prediction * 100).toFixed(1)}%`,
+              confidence: `${(u.confidence * 100).toFixed(0)}%`,
+              created: u.created_at
+            }))
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+  try {
+    tools.push(..._screenerTools);
+    tools.push(..._pipelineTools);
+  } catch (e) {
+    console.warn("[polymarket] Screener tools not loaded:", e.message);
+  }
+  try {
+    const watcherTools = createWatcherTools({ db: { getEngineDB: () => db }, agentId });
+    for (const wt of watcherTools) {
+      tools.push({
+        name: wt.name,
+        description: wt.description,
+        category: "enterprise",
+        parameters: wt.parameters,
+        async execute(_id, p) {
+          try {
+            const result = await wt.handler(p);
+            return jsonResult(result);
+          } catch (e) {
+            return errorResult(e.message);
+          }
+        }
+      });
+    }
+  } catch (e) {
+    console.warn("[polymarket] Watcher tools not loaded:", e.message);
+  }
+  const extensions = [
+    { name: "Execution", fn: createPolymarketExecutionTools },
+    { name: "Social", fn: createPolymarketSocialTools },
+    { name: "Feeds", fn: createPolymarketFeedsTools },
+    { name: "OnChain", fn: createPolymarketOnchainTools },
+    { name: "Analytics", fn: createPolymarketAnalyticsTools },
+    { name: "Portfolio", fn: createPolymarketPortfolioTools },
+    { name: "Quant", fn: createPolymarketQuantTools },
+    { name: "Counterintel", fn: createPolymarketCounterintelTools }
+  ];
+  for (const ext of extensions) {
+    try {
+      const extTools = ext.fn(options);
+      tools.push(...extTools);
+    } catch (e) {
+      console.warn(`[polymarket] ${ext.name} tools not loaded:`, e.message);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (let i = tools.length - 1; i >= 0; i--) {
+    const name = tools[i].name;
+    if (!seen.has(name)) {
+      seen.add(name);
+      deduped.unshift(tools[i]);
+    }
+  }
+  return deduped;
+}
+
+export {
+  createPolymarketExecutionTools,
+  createPolymarketSocialTools,
+  createPolymarketFeedsTools,
+  createPolymarketOnchainTools,
+  createPolymarketAnalyticsTools,
+  createPolymarketPortfolioTools,
+  createPolymarketCounterintelTools,
+  executeOrder,
+  createPolymarketTools
+};