@agenticmail/enterprise 0.5.443 → 0.5.445

package/dist/chunk-46UEEFMW.js

@@ -0,0 +1,2214 @@
+// src/agent-tools/tools/polymarket-watcher.ts
+var WATCHER_TABLES = [
+  `CREATE TABLE IF NOT EXISTS poly_watchers (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    name TEXT,
+    config TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'active',
+    interval_ms INTEGER NOT NULL DEFAULT 60000,
+    last_run TEXT,
+    last_alert TEXT,
+    alert_count INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  `CREATE TABLE IF NOT EXISTS poly_watcher_events (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    watcher_id TEXT,
+    type TEXT NOT NULL,
+    severity TEXT NOT NULL DEFAULT 'info',
+    title TEXT NOT NULL,
+    summary TEXT,
+    data TEXT DEFAULT '{}',
+    acknowledged INTEGER DEFAULT 0,
+    routed INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  `CREATE TABLE IF NOT EXISTS poly_price_cache (
+    token_id TEXT PRIMARY KEY,
+    price REAL,
+    prev_price REAL,
+    volume_24h REAL,
+    updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  `CREATE TABLE IF NOT EXISTS poly_crypto_cache (
+    symbol TEXT PRIMARY KEY,
+    price REAL,
+    change_24h REAL,
+    updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  // AI analysis cache — avoid re-analyzing the same content
+  `CREATE TABLE IF NOT EXISTS poly_analysis_cache (
+    content_hash TEXT PRIMARY KEY,
+    analysis TEXT NOT NULL,
+    model TEXT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  // Watcher engine config — per-agent model settings
+  `CREATE TABLE IF NOT EXISTS poly_watcher_config (
+    agent_id TEXT PRIMARY KEY,
+    ai_model TEXT DEFAULT 'grok-3-mini',
+    ai_provider TEXT DEFAULT 'xai',
+    ai_api_key TEXT,
+    use_org_key INTEGER DEFAULT 1,
+    analysis_budget_daily INTEGER DEFAULT 100,
+    analysis_count_today INTEGER DEFAULT 0,
+    analysis_date TEXT,
+    max_spawn_per_hour INTEGER DEFAULT 6,
+    enabled INTEGER DEFAULT 1,
+    config TEXT DEFAULT '{}',
+    updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  // Sentiment history — tracks sentiment trends over time
+  `CREATE TABLE IF NOT EXISTS poly_sentiment_history (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    topic TEXT NOT NULL,
+    sentiment REAL NOT NULL,
+    confidence REAL,
+    source TEXT,
+    analysis TEXT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`,
+  // Signal correlation buffer — stores recent signals for cross-correlation
+  `CREATE TABLE IF NOT EXISTS poly_signal_buffer (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    signal_type TEXT NOT NULL,
+    topic TEXT NOT NULL,
+    data TEXT DEFAULT '{}',
+    sentiment REAL,
+    impact TEXT,
+    expires_at TEXT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  )`
+];
+async function initWatcherTables(edb) {
+  if (!edb) return;
+  for (const sql of WATCHER_TABLES) {
+    try {
+      await edb.run(sql);
+    } catch {
+    }
+  }
+  try {
+    await edb.run(`ALTER TABLE poly_watcher_config ADD COLUMN use_org_key INTEGER DEFAULT 1`);
+  } catch {
+  }
+}
+function dateAgo(hours) {
+  return new Date(Date.now() - hours * 36e5).toISOString();
+}
+function dateAgoMin(minutes) {
+  return new Date(Date.now() - minutes * 6e4).toISOString();
+}
+function dateAhead(hours) {
+  return new Date(Date.now() + hours * 36e5).toISOString();
+}
+async function callAnalysisLLM(prompt, config, opts) {
+  const baseUrls = {
+    xai: "https://api.x.ai/v1",
+    openai: "https://api.openai.com/v1",
+    groq: "https://api.groq.com/openai/v1",
+    cerebras: "https://api.cerebras.ai/v1",
+    together: "https://api.together.xyz/v1",
+    openrouter: "https://openrouter.ai/api/v1",
+    deepseek: "https://api.deepseek.com/v1",
+    fireworks: "https://api.fireworks.ai/inference/v1",
+    anthropic: "https://api.anthropic.com"
+  };
+  const isAnthropic = config.provider === "anthropic";
+  const baseUrl = baseUrls[config.provider] || baseUrls.openai;
+  let res;
+  if (isAnthropic) {
+    res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: config.model,
+        max_tokens: opts?.maxTokens || 500,
+        messages: [{ role: "user", content: prompt }]
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs || 15e3)
+    });
+  } else {
+    res = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify({
+        model: config.model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: opts?.maxTokens || 500,
+        temperature: opts?.temperature || 0.3
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs || 15e3)
+    });
+  }
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`LLM API error ${res.status}: ${err.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  if (isAnthropic) {
+    return data.content?.[0]?.text || "";
+  }
+  return data.choices?.[0]?.message?.content || "";
+}
+async function getAIConfig(agentId, edb) {
+  try {
+    const cfg = await edb.get(`SELECT * FROM poly_watcher_config WHERE agent_id = ?`, [agentId]);
+    if (!cfg) return null;
+    const apiKey = cfg.ai_api_key || "";
+    if (!apiKey) return null;
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (cfg.analysis_date !== today) {
+      await edb.run(`UPDATE poly_watcher_config SET analysis_count_today = 0, analysis_date = ? WHERE agent_id = ?`, [today, agentId]);
+      return { provider: cfg.ai_provider, model: cfg.ai_model, apiKey, budgetRemaining: cfg.analysis_budget_daily || 100 };
+    }
+    const remaining = (cfg.analysis_budget_daily || 100) - (cfg.analysis_count_today || 0);
+    if (remaining <= 0) return null;
+    return { provider: cfg.ai_provider, model: cfg.ai_model, apiKey, budgetRemaining: remaining };
+  } catch {
+    return null;
+  }
+}
+async function incrementAnalysisCount(agentId, edb) {
+  try {
+    await edb.run(`UPDATE poly_watcher_config SET analysis_count_today = analysis_count_today + 1, updated_at = CURRENT_TIMESTAMP WHERE agent_id = ?`, [agentId]);
+  } catch {
+  }
+}
+async function getCachedAnalysis(contentHash, edb) {
+  try {
+    const row = await edb.get(`SELECT analysis FROM poly_analysis_cache WHERE content_hash = ? AND created_at > ?`, [contentHash, dateAgo(1)]);
+    if (row) return JSON.parse(row.analysis);
+  } catch {
+  }
+  return null;
+}
+async function cacheAnalysis(contentHash, analysis, model, edb) {
+  try {
+    await edb.run(
+      `INSERT OR REPLACE INTO poly_analysis_cache (content_hash, analysis, model, created_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)`,
+      [contentHash, JSON.stringify(analysis), model]
+    );
+  } catch {
+  }
+}
+function hashContent(content) {
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const chr = content.charCodeAt(i);
+    hash = (hash << 5) - hash + chr;
+    hash |= 0;
+  }
+  return "h" + Math.abs(hash).toString(36);
+}
+async function analyzeWithAI(content, context, agentId, edb) {
+  const aiConfig = await getAIConfig(agentId, edb);
+  if (!aiConfig) return null;
+  const hash = hashContent(content + JSON.stringify(context));
+  const cached = await getCachedAnalysis(hash, edb);
+  if (cached) return cached;
+  const marketContext = context.watchedMarkets?.length ? `
+Agent is currently watching/trading these Polymarket markets:
+${context.watchedMarkets.map((m) => `- ${m}`).join("\n")}` : "";
+  const positionContext = context.positions?.length ? `
+Agent has open positions in:
+${context.positions.map((p) => `- ${p}`).join("\n")}` : "";
+  const prompt = `You are a quantitative market intelligence analyst for a prediction market trading system (Polymarket).
+
+Analyze the following content and assess its potential impact on prediction markets.
+${marketContext}${positionContext}
+
+CONTENT TO ANALYZE:
+${content}
+
+Respond in EXACT JSON format (no markdown, no code blocks):
+{
+  "impact": "none|low|medium|high|critical",
+  "sentiment": <float -1.0 to 1.0, negative=bearish, positive=bullish>,
+  "confidence": <float 0.0 to 1.0, how confident in this assessment>,
+  "reasoning": "<1-2 sentence explanation of WHY this matters for prediction markets>",
+  "affected_markets": ["<list of market topics/questions this could affect>"],
+  "recommended_action": "<what should the trader do: buy/sell/hedge/monitor/ignore>",
+  "predicted_outcome": "<what you think will happen based on this signal>",
+  "time_horizon": "<how soon: immediate/hours/days/weeks>"
+}`;
+  try {
+    const response = await callAnalysisLLM(prompt, {
+      provider: aiConfig.provider,
+      model: aiConfig.model,
+      apiKey: aiConfig.apiKey
+    }, { maxTokens: 400, temperature: 0.2 });
+    await incrementAnalysisCount(agentId, edb);
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const analysis = JSON.parse(jsonStr);
+    await cacheAnalysis(hash, analysis, aiConfig.model, edb);
+    return analysis;
+  } catch (e) {
+    return null;
+  }
+}
+async function analyzeGeopolitical(headlines, watchedTopics, agentId, edb) {
+  const aiConfig = await getAIConfig(agentId, edb);
+  if (!aiConfig) return null;
+  const hash = hashContent(headlines.map((h) => h.title).join("|") + watchedTopics.join(","));
+  const cached = await getCachedAnalysis(hash, edb);
+  if (cached) return cached;
+  const prompt = `You are a geopolitical intelligence analyst working for a prediction market hedge fund.
+
+Your job: Identify patterns in current events that predict future outcomes relevant to prediction markets (Polymarket).
+
+CURRENT HEADLINES:
+${headlines.map((h, i) => `${i + 1}. ${h.title}${h.source ? ` (${h.source})` : ""}${h.date ? ` [${h.date}]` : ""}`).join("\n")}
+
+TOPICS THE TRADER IS WATCHING:
+${watchedTopics.map((t) => `- ${t}`).join("\n")}
+
+ANALYSIS REQUIRED:
+1. Connect dots between these headlines \u2014 what patterns emerge?
+2. What events do these patterns predict could happen soon?
+3. Which prediction markets would be most affected?
+4. What's the confidence level and time horizon?
+
+Think like a CIA analyst briefing a trader. Focus on ACTIONABLE intelligence.
+
+Respond in EXACT JSON format (no markdown, no code blocks):
+{
+  "impact": "none|low|medium|high|critical",
+  "sentiment": <float -1.0 to 1.0>,
+  "confidence": <float 0.0 to 1.0>,
+  "reasoning": "<2-3 sentence analysis connecting the dots between events and predicting what happens next>",
+  "affected_markets": ["<specific prediction market topics this affects>"],
+  "recommended_action": "<specific trading recommendation>",
+  "predicted_outcome": "<what the analyst predicts will happen based on patterns>",
+  "time_horizon": "<immediate/hours/days/weeks>"
+}`;
+  try {
+    const response = await callAnalysisLLM(prompt, {
+      provider: aiConfig.provider,
+      model: aiConfig.model,
+      apiKey: aiConfig.apiKey
+    }, { maxTokens: 500, temperature: 0.3 });
+    await incrementAnalysisCount(agentId, edb);
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const analysis = JSON.parse(jsonStr);
+    await cacheAnalysis(hash, analysis, aiConfig.model, edb);
+    return analysis;
+  } catch {
+    return null;
+  }
+}
+async function analyzeSignalCorrelation(signals, agentId, edb) {
+  const aiConfig = await getAIConfig(agentId, edb);
+  if (!aiConfig || signals.length < 2) return null;
+  const hash = hashContent(signals.map((s) => s.type + s.topic + s.summary).join("|"));
+  const cached = await getCachedAnalysis(hash, edb);
+  if (cached) return cached;
+  const prompt = `You are a quantitative signal correlation analyst for a prediction market fund.
+
+Multiple independent signals have fired within a short timeframe. Your job: determine if they're connected and what they predict together.
+
+RECENT SIGNALS:
+${signals.map((s, i) => `${i + 1}. [${s.type.toUpperCase()}] ${s.topic}: ${s.summary}${s.sentiment != null ? ` (sentiment: ${s.sentiment.toFixed(2)})` : ""}${s.impact ? ` (impact: ${s.impact})` : ""}`).join("\n")}
+
+ANALYSIS:
+1. Are these signals correlated? What's the common thread?
+2. Does the convergence increase confidence in any direction?
+3. Is this a cascade pattern (one event causing the others)?
+4. What's the combined signal saying that individual signals miss?
+
+Respond in EXACT JSON format (no markdown, no code blocks):
+{
+  "impact": "none|low|medium|high|critical",
+  "sentiment": <float -1.0 to 1.0, combined signal direction>,
+  "confidence": <float 0.0 to 1.0, how confident the signals are correlated>,
+  "reasoning": "<2-3 sentences explaining the correlation pattern and prediction>",
+  "affected_markets": ["<markets where the combined signal is actionable>"],
+  "recommended_action": "<trading action based on signal convergence>",
+  "predicted_outcome": "<what the combined signal predicts>",
+  "time_horizon": "<immediate/hours/days/weeks>"
+}`;
+  try {
+    const response = await callAnalysisLLM(prompt, {
+      provider: aiConfig.provider,
+      model: aiConfig.model,
+      apiKey: aiConfig.apiKey
+    }, { maxTokens: 400, temperature: 0.2 });
+    await incrementAnalysisCount(agentId, edb);
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const analysis = JSON.parse(jsonStr);
+    await cacheAnalysis(hash, analysis, aiConfig.model, edb);
+    return analysis;
+  } catch {
+    return null;
+  }
+}
+var TICK_MS = 15e3;
+var IDLE_CHECK_MS = 6e4;
+var GAMMA_API = "https://gamma-api.polymarket.com";
+var CLOB_API = "https://clob.polymarket.com";
+var engineInterval = null;
+var idleInterval = null;
+var lastCryptoFetch = 0;
+var cryptoCache = {};
+var _engineDb = null;
+var _engineOpts = null;
+var _engineStartedAt = null;
+var _engineTickCount = 0;
+var _engineEventCount = 0;
+var _engineAnalysisCount = 0;
+var _spawnCount = 0;
+var _lastAlertCheckMs = 0;
+var _lastExitCheckMs = 0;
+var _lastProactiveCheckMs = 0;
+var _lastSpawnByAgent = {};
+var SPAWN_COOLDOWN_MS = 5 * 6e4;
+var MAX_BATCH_EVENTS = 10;
+function getWatcherEngineStatus() {
+  return {
+    running: !!engineInterval,
+    idle: !!idleInterval && !engineInterval,
+    startedAt: _engineStartedAt,
+    tickCount: _engineTickCount,
+    eventCount: _engineEventCount,
+    analysisCount: _engineAnalysisCount,
+    spawnCount: _spawnCount,
+    tickMs: TICK_MS,
+    idleCheckMs: IDLE_CHECK_MS,
+    spawnCooldownMs: SPAWN_COOLDOWN_MS
+  };
+}
+function startWatcherEngine(db, opts) {
+  _engineDb = db;
+  _engineOpts = opts || {};
+  const log = opts?.log || console.log;
+  if (idleInterval || engineInterval) return;
+  log("[poly-watcher] AI-powered engine registered \u2014 will activate when watchers exist");
+  const checkAndToggle = async () => {
+    const edb = db.getEngineDB?.();
+    if (!edb) return;
+    try {
+      const row = await edb.get(`SELECT COUNT(*) as cnt FROM poly_watchers WHERE status = 'active'`);
+      const count = row?.cnt || 0;
+      if (count > 0 && !engineInterval) {
+        _startFastLoop(db, _engineOpts);
+      } else if (count === 0 && engineInterval) {
+        _stopFastLoop(log);
+      }
+    } catch {
+    }
+  };
+  checkAndToggle();
+  idleInterval = setInterval(checkAndToggle, IDLE_CHECK_MS);
+}
+function setWatcherRuntime(getRuntime, getAgentConfig) {
+  if (_engineOpts) {
+    _engineOpts.getRuntime = getRuntime;
+    if (getAgentConfig) _engineOpts.getAgentConfig = getAgentConfig;
+    const log = _engineOpts.log || console.log;
+    log("[poly-watcher] Runtime reference injected \u2014 agent wake enabled");
+  }
+}
+function _startFastLoop(db, opts) {
+  if (engineInterval) return;
+  const log = opts.log || console.log;
+  log("[poly-watcher] Active watchers found \u2014 starting 15s tick loop");
+  _engineStartedAt = Date.now();
+  engineInterval = setInterval(async () => {
+    const edb = db.getEngineDB?.();
+    if (!edb) return;
+    _engineTickCount++;
+    try {
+      const now = Date.now();
+      const watchers = await edb.all(
+        `SELECT * FROM poly_watchers WHERE status = 'active'`
+      ) || [];
+      if (watchers.length === 0) {
+        _stopFastLoop(log);
+        return;
+      }
+      const eventsByAgent = {};
+      const priceCache = {};
+      for (const w of watchers) {
+        const lastRun = w.last_run ? new Date(w.last_run).getTime() : 0;
+        if (now - lastRun < (w.interval_ms || 6e4)) continue;
+        try {
+          const config = JSON.parse(w.config || "{}");
+          const events = await runWatcher(w.type, config, w.agent_id, edb);
+          for (const evt of events) {
+            const id = crypto.randomUUID();
+            if (config.auto_action && evt.severity !== "info") {
+              try {
+                const aa = config.auto_action;
+                const tokenId = aa.token_id || evt.data?.token_id;
+                if (tokenId && (aa.side || aa.action)) {
+                  const { executeOrder } = await import("./polymarket-ZVUDH7EV.js");
+                  const tradeId = `watcher_${w.id}_${Date.now()}`;
+                  let tradePrice = aa.price || evt.data?.current_price || 0;
+                  if (!tradePrice || tradePrice <= 0) {
+                    try {
+                      const mid = await fetch(`${CLOB_API}/midpoint?token_id=${tokenId}`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.json());
+                      tradePrice = parseFloat(mid?.mid || "0");
+                    } catch {
+                    }
+                  }
+                  if (!tradePrice || tradePrice <= 0) {
+                    log(`[watcher] Auto-trade skipped for ${w.name}: could not resolve price for token ${tokenId}`);
+                    continue;
+                  }
+                  if (tradePrice >= 0.99 || tradePrice <= 0.01) {
+                    const sellSide = (aa.side || String(aa.action).toUpperCase()) === "SELL";
+                    if (sellSide) {
+                      log(`[watcher] Auto-trade skipped for ${w.name}: market appears resolved (price=${tradePrice})`);
+                      evt.data = evt.data || {};
+                      evt.data.skipped = `Market resolved (price=${tradePrice}), SELL not executed`;
+                      continue;
+                    }
+                  }
+                  const tradeParams = {
+                    token_id: tokenId,
+                    side: aa.side || (String(aa.action).toUpperCase() === "SELL" ? "SELL" : "BUY"),
+                    size: aa.size || aa.shares || 0,
+                    price: tradePrice,
+                    market_question: aa.market_question || evt.title || "Auto-trade from watcher",
+                    order_type: "GTC"
+                  };
+                  const dbCompat = edb.query ? edb : { query: edb.all?.bind(edb), execute: edb.run?.bind(edb), run: edb.run?.bind(edb), get: edb.get?.bind(edb), all: edb.all?.bind(edb) };
+                  log(`[watcher] Auto-executing trade for watcher ${w.name}: ${tradeParams.side} ${tradeParams.size} @ ${tradeParams.price}`);
+                  const result = await executeOrder(w.agent_id, dbCompat, tradeId, tradeParams, "auto_watcher");
+                  evt.data = evt.data || {};
+                  evt.data.auto_trade_result = result;
+                  evt.summary = (evt.summary || "") + ` | Auto-trade: ${tradeParams.side} ${tradeParams.size} shares`;
+                  log(`[watcher] Auto-trade result for watcher ${w.name}: ${JSON.stringify(result).slice(0, 200)}`);
+                }
+              } catch (atErr) {
+                log(`[watcher] Auto-trade failed for watcher ${w.name}: ${atErr.message}`);
+                evt.data = evt.data || {};
+                evt.data.auto_trade_error = atErr.message;
+              }
+            }
+            await edb.run(
+              `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+              [id, w.agent_id, w.id, evt.type, evt.severity, evt.title, evt.summary || "", JSON.stringify(evt.data || {})]
+            );
+            _engineEventCount++;
+            if (!eventsByAgent[w.agent_id]) {
+              eventsByAgent[w.agent_id] = { events: [], maxSeverity: "info" };
+            }
+            const batch = eventsByAgent[w.agent_id];
+            batch.events.push(evt);
+            if (evt.severity === "critical") batch.maxSeverity = "critical";
+            else if (evt.severity === "warning" && batch.maxSeverity !== "critical") batch.maxSeverity = "warning";
+            if (opts.onEvent) {
+              try {
+                opts.onEvent(w.agent_id, evt);
+              } catch {
+              }
+            }
+          }
+          await edb.run(
+            `UPDATE poly_watchers SET last_run = CURRENT_TIMESTAMP, alert_count = alert_count + ? WHERE id = ?`,
+            [events.length, w.id]
+          );
+          if (events.length > 0) {
+            await edb.run(`UPDATE poly_watchers SET last_alert = CURRENT_TIMESTAMP WHERE id = ?`, [w.id]);
+          }
+        } catch (e) {
+        }
+      }
+      if (now - _lastAlertCheckMs < 6e4) {
+      } else try {
+        _lastAlertCheckMs = now;
+        const activeAlerts = await edb.all(
+          `SELECT * FROM poly_price_alerts WHERE triggered = 0`
+        ).catch(() => []) || [];
+        for (const alert of activeAlerts) {
+          try {
+            let currentPrice = priceCache[alert.token_id];
+            if (currentPrice === void 0) {
+              const mid = await fetch(`${CLOB_API}/midpoint?token_id=${alert.token_id}`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.json());
+              currentPrice = parseFloat(mid?.mid || "0");
+              priceCache[alert.token_id] = currentPrice;
+            }
+            if (!currentPrice || currentPrice <= 0) {
+              try {
+                const marketInfo = await fetch(`${GAMMA_API}/markets?clob_token_ids=${alert.token_id}&limit=1`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.ok ? r.json() : null).then((arr) => Array.isArray(arr) ? arr[0] : arr).catch(() => null);
+                const isClosed = marketInfo?.closed || marketInfo?.resolved || marketInfo?.active === false;
+                if (isClosed || !marketInfo) {
+                  const reason2 = marketInfo?.resolved ? "resolved" : marketInfo?.closed ? "closed" : "unavailable";
+                  log(`[alerts] Market ${reason2} for alert ${alert.id} (${alert.market_question || alert.token_id.slice(0, 16)}). Auto-cancelling.`);
+                  await edb.run(`UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE id = ?`, [alert.id]);
+                  if (alert.bracket_group) {
+                    await edb.run(
+                      `UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE bracket_group = ? AND id != ? AND triggered = 0`,
+                      [alert.bracket_group, alert.id]
+                    );
+                    log(`[bracket] Market ${reason2} \u2014 cancelled entire bracket group ${alert.bracket_group}`);
+                  }
+                  const evtId = crypto.randomUUID();
+                  await edb.run(
+                    `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?,?,?,?,?,?,?,?)`,
+                    [
+                      evtId,
+                      alert.agent_id,
+                      "alert_" + alert.id,
+                      "market_resolved",
+                      "warning",
+                      `Market ${reason2}: ${alert.market_question || alert.token_id.slice(0, 16)}`,
+                      `Alert auto-cancelled because market is ${reason2}. ${alert.bracket_group ? "Bracket group also cancelled." : ""}`,
+                      JSON.stringify({ alert_id: alert.id, token_id: alert.token_id, reason: reason2, bracket_group: alert.bracket_group || null })
+                    ]
+                  );
+                  _engineEventCount++;
+                  if (!eventsByAgent[alert.agent_id]) eventsByAgent[alert.agent_id] = { events: [], maxSeverity: "info" };
+                  eventsByAgent[alert.agent_id].events.push({
+                    type: "market_resolved",
+                    severity: "warning",
+                    title: `Market ${reason2}: ${alert.market_question || alert.token_id.slice(0, 16)}`,
+                    summary: `Alert auto-cancelled. Market is ${reason2}.`,
+                    data: { alert_id: alert.id, reason: reason2 }
+                  });
+                  if (eventsByAgent[alert.agent_id].maxSeverity === "info") eventsByAgent[alert.agent_id].maxSeverity = "warning";
+                }
+              } catch {
+              }
+              continue;
+            }
+            if (currentPrice >= 0.99 || currentPrice <= 0.01) {
+              try {
+                const marketInfo = await fetch(`${GAMMA_API}/markets?clob_token_ids=${alert.token_id}&limit=1`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.ok ? r.json() : null).then((arr) => Array.isArray(arr) ? arr[0] : arr).catch(() => null);
+                if (marketInfo?.resolved || marketInfo?.closed) {
+                  const reason2 = marketInfo.resolved ? "resolved" : "closed";
+                  const winning = currentPrice >= 0.99;
+                  log(`[alerts] Market ${reason2} (${winning ? "YES won" : "NO won"}) for alert ${alert.id}. Auto-cancelling.`);
+                  await edb.run(`UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE id = ?`, [alert.id]);
+                  if (alert.bracket_group) {
+                    await edb.run(
+                      `UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE bracket_group = ? AND id != ? AND triggered = 0`,
+                      [alert.bracket_group, alert.id]
+                    );
+                  }
+                  const evtId = crypto.randomUUID();
+                  await edb.run(
+                    `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?,?,?,?,?,?,?,?)`,
+                    [
+                      evtId,
+                      alert.agent_id,
+                      "alert_" + alert.id,
+                      "market_resolved",
+                      "critical",
+                      `Market ${reason2}: ${alert.market_question || alert.token_id.slice(0, 16)}`,
+                      `Market ${reason2} at ${(currentPrice * 100).toFixed(1)}\xA2. ${winning ? "Position WON" : "Position LOST"}. All alerts cancelled.`,
+                      JSON.stringify({ alert_id: alert.id, token_id: alert.token_id, reason: reason2, final_price: currentPrice, bracket_group: alert.bracket_group || null })
+                    ]
+                  );
+                  _engineEventCount++;
+                  if (!eventsByAgent[alert.agent_id]) eventsByAgent[alert.agent_id] = { events: [], maxSeverity: "info" };
+                  eventsByAgent[alert.agent_id].events.push({
+                    type: "market_resolved",
+                    severity: "critical",
+                    title: `Market ${reason2}: ${alert.market_question || alert.token_id.slice(0, 16)}`,
+                    summary: `Resolved at ${(currentPrice * 100).toFixed(1)}\xA2. ${winning ? "WON" : "LOST"}.`,
+                    data: { alert_id: alert.id, reason: reason2, final_price: currentPrice }
+                  });
+                  eventsByAgent[alert.agent_id].maxSeverity = "critical";
+                  continue;
+                }
+              } catch {
+              }
+            }
+            let fire = false;
+            let reason = "";
+            if (alert.condition === "above" && alert.target_price && currentPrice >= alert.target_price) {
+              fire = true;
+              reason = `Price ${(currentPrice * 100).toFixed(1)}\xA2 crossed above target ${(alert.target_price * 100).toFixed(1)}\xA2`;
+            } else if (alert.condition === "below" && alert.target_price && currentPrice <= alert.target_price) {
+              fire = true;
+              reason = `Price ${(currentPrice * 100).toFixed(1)}\xA2 dropped below target ${(alert.target_price * 100).toFixed(1)}\xA2`;
+            } else if (alert.condition === "pct_change" && alert.pct_change && alert.base_price) {
+              const change = Math.abs(currentPrice - alert.base_price) / alert.base_price * 100;
+              if (change >= alert.pct_change) {
+                fire = true;
+                const dir = currentPrice > alert.base_price ? "up" : "down";
+                reason = `Price moved ${dir} ${change.toFixed(1)}% (threshold: ${alert.pct_change}%)`;
+              }
+            }
+            if (fire) {
+              const recentDup = await edb.all(
+                `SELECT id FROM poly_watcher_events WHERE watcher_id = ? AND created_at > ?`,
+                ["alert_" + alert.id, dateAgoMin(5)]
+              ).catch(() => []);
+              if (recentDup && recentDup.length > 0) continue;
+              const label = alert.market_question || alert.token_id.slice(0, 16) + "\u2026";
+              const evt = {
+                type: "price_alert",
+                severity: "critical",
+                // Alerts always wake the agent — they are explicit user-set triggers
+                title: `[ALERT] ${label}`,
+                summary: reason,
+                data: { alert_id: alert.id, token_id: alert.token_id, current_price: currentPrice, condition: alert.condition, target_price: alert.target_price, source: "poly_set_alert" }
+              };
+              const evtId = crypto.randomUUID();
+              await edb.run(
+                `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+                [evtId, alert.agent_id, "alert_" + alert.id, evt.type, evt.severity, evt.title, evt.summary, JSON.stringify(evt.data)]
+              );
+              _engineEventCount++;
+              if (!eventsByAgent[alert.agent_id]) {
+                eventsByAgent[alert.agent_id] = { events: [], maxSeverity: "info" };
+              }
+              eventsByAgent[alert.agent_id].events.push(evt);
+              eventsByAgent[alert.agent_id].maxSeverity = "critical";
+              if (alert.auto_trade_config) {
+                try {
+                  const atc = typeof alert.auto_trade_config === "string" ? JSON.parse(alert.auto_trade_config) : alert.auto_trade_config;
+                  if (atc && (atc.side || atc.action)) {
+                    const tokenId = atc.token_id || alert.token_id;
+                    let marketResolved = false;
+                    if (currentPrice >= 0.99 || currentPrice <= 0.01) {
+                      marketResolved = true;
+                    }
+                    if (marketResolved && (atc.side || atc.action)?.toUpperCase() === "SELL") {
+                      log(`[watcher] Skipping auto-trade for alert ${alert.id}: market appears resolved (price=${currentPrice}). Cancelling alert.`);
+                      await edb.run(`UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE id = ?`, [alert.id]);
+                      evt.data = evt.data || {};
+                      evt.data.skipped = `Market resolved (price=${currentPrice}), trade not executed`;
+                      evt.summary += ` | Skipped: market resolved`;
+                      continue;
+                    }
+                    const { executeOrder } = await import("./polymarket-ZVUDH7EV.js");
+                    const tradeId = `auto_${alert.id}_${Date.now()}`;
+                    const tradeParams = {
+                      token_id: tokenId,
+                      side: atc.side || (String(atc.action).toUpperCase() === "SELL" ? "SELL" : "BUY"),
+                      size: atc.size || atc.shares || 0,
+                      price: atc.price || currentPrice,
+                      market_question: alert.market_question || "Auto-trade from alert",
+                      order_type: "GTC"
+                    };
+                    const dbCompat = edb.query ? edb : { query: edb.all?.bind(edb), execute: edb.run?.bind(edb), run: edb.run?.bind(edb), get: edb.get?.bind(edb), all: edb.all?.bind(edb) };
+                    console.log(`[watcher] Auto-executing trade for alert ${alert.id}: ${tradeParams.side} ${tradeParams.size} @ ${tradeParams.price}`);
+                    const result = await executeOrder(alert.agent_id, dbCompat, tradeId, tradeParams, "auto_alert");
+                    evt.data = evt.data || {};
+                    evt.data.auto_trade_result = result;
+                    evt.summary += ` | Auto-trade: ${tradeParams.side} ${tradeParams.size} shares`;
+                    console.log(`[watcher] Auto-trade result for alert ${alert.id}:`, JSON.stringify(result).slice(0, 200));
+                  }
+                } catch (atErr) {
+                  console.error(`[watcher] Auto-trade failed for alert ${alert.id}:`, atErr.message);
+                  evt.data = evt.data || {};
+                  evt.data.auto_trade_error = atErr.message;
+                }
+              }
+              if (evt.data?.auto_trade_result || evt.data?.auto_trade_error) {
+                await edb.run(
+                  `UPDATE poly_watcher_events SET summary = ?, data = ? WHERE id = ?`,
+                  [evt.summary, JSON.stringify(evt.data), evtId]
+                ).catch(() => {
+                });
+              }
+              if (alert.repeat_alert) {
+                await edb.run(`UPDATE poly_price_alerts SET base_price = ? WHERE id = ?`, [currentPrice, alert.id]);
+              } else {
+                await edb.run(`UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE id = ?`, [alert.id]);
+              }
+              if (alert.bracket_group) {
+                try {
+                  const { cancelBracketSibling } = await import("./polymarket-runtime-6LTI2BL7.js");
+                  const dbCompat2 = edb.query ? edb : { query: edb.all?.bind(edb), execute: edb.run?.bind(edb), run: edb.run?.bind(edb), get: edb.get?.bind(edb), all: edb.all?.bind(edb) };
+                  const cancelledId = await cancelBracketSibling(dbCompat2, alert.id, alert.bracket_group);
+                  if (cancelledId) {
+                    const role = alert.bracket_role === "take_profit" ? "Take-Profit" : "Stop-Loss";
+                    const siblingRole = alert.bracket_role === "take_profit" ? "Stop-Loss" : "Take-Profit";
+                    evt.summary += ` | ${role} hit \u2192 cancelled ${siblingRole} (${cancelledId})`;
+                    log(`[bracket] ${role} fired (${alert.id}), cancelled ${siblingRole} (${cancelledId}) in group ${alert.bracket_group}`);
+                  }
+                } catch (bracketErr) {
+                  log(`[bracket] Failed to cancel sibling for ${alert.id}: ${bracketErr.message}`);
+                }
+                try {
+                  await edb.run(
+                    `UPDATE poly_exit_rules SET status = 'bracket_exited' WHERE agent_id = ? AND token_id = ? AND status = 'active'`,
+                    [alert.agent_id, alert.token_id]
+                  );
+                  log(`[bracket\u2192exit] Deactivated exit rules for token ${alert.token_id} (bracket fired)`);
+                } catch {
+                }
+              }
+              if (!alert.bracket_group && alert.auto_trade_config) {
+                try {
+                  const atc = typeof alert.auto_trade_config === "string" ? JSON.parse(alert.auto_trade_config) : alert.auto_trade_config;
+                  if (atc?.side === "SELL" || atc?.action === "SELL") {
+                    await edb.run(
+                      `UPDATE poly_exit_rules SET status = 'alert_exited' WHERE agent_id = ? AND token_id = ? AND status = 'active'`,
+                      [alert.agent_id, alert.token_id]
+                    );
+                    log(`[alert\u2192exit] Deactivated exit rules for token ${alert.token_id} (alert auto-sell fired)`);
+                  }
+                } catch {
+                }
+              }
+              if (opts.onEvent) {
+                try {
+                  opts.onEvent(alert.agent_id, evt);
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      for (const [agentId, batch] of Object.entries(eventsByAgent)) {
+        if (batch.maxSeverity === "critical") {
+          await _maybeSpawnAgent(agentId, batch.events, edb, opts, log);
+        } else if (batch.maxSeverity === "warning") {
+          await _maybeSpawnAgent(agentId, batch.events, edb, opts, log);
+        }
+      }
+      if (now - (_lastExitCheckMs || 0) < 6e4) {
+      } else try {
+        _lastExitCheckMs = now;
+        const exitRules = await edb.all(
+          `SELECT * FROM poly_exit_rules WHERE status = 'active'`
+        ).catch(() => []) || [];
+        for (const rule of exitRules) {
+          try {
+            let currentPrice = priceCache?.[rule.token_id];
+            if (currentPrice === void 0) {
+              const mid = await fetch(`${CLOB_API}/midpoint?token_id=${rule.token_id}`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.json());
+              currentPrice = parseFloat(mid?.mid || "0");
+            }
+            if (!currentPrice) {
+              try {
+                const marketInfo = await fetch(`${GAMMA_API}/markets?clob_token_ids=${rule.token_id}&limit=1`, { signal: AbortSignal.timeout(5e3) }).then((r) => r.ok ? r.json() : null).then((arr) => Array.isArray(arr) ? arr[0] : arr).catch(() => null);
+                if (marketInfo?.resolved || marketInfo?.closed || !marketInfo) {
+                  await edb.run(`UPDATE poly_exit_rules SET status = 'market_resolved' WHERE id = ?`, [rule.id]);
+                  log(`[exit-rules] Market resolved/closed \u2014 deactivated exit rule ${rule.id}`);
+                }
+              } catch {
+              }
+              continue;
+            }
+            if (currentPrice > (rule.highest_price || 0)) {
+              await edb.run(`UPDATE poly_exit_rules SET highest_price = ? WHERE id = ?`, [currentPrice, rule.id]).catch(() => {
+              });
+            }
+            let fireType = "";
+            let fireReason = "";
+            let sellPrice = currentPrice;
+            if (rule.trailing_stop_pct && rule.highest_price) {
+              const highestForTrail = Math.max(rule.highest_price, currentPrice);
+              const trailPrice = highestForTrail * (1 - rule.trailing_stop_pct / 100);
+              if (currentPrice <= trailPrice) {
+                fireType = "TRAILING_STOP";
+                fireReason = `Price ${(currentPrice * 100).toFixed(1)}\xA2 dropped ${rule.trailing_stop_pct}% from high of ${(highestForTrail * 100).toFixed(1)}\xA2 (trail trigger: ${(trailPrice * 100).toFixed(1)}\xA2)`;
+                sellPrice = currentPrice;
+              }
+            }
+            if (!fireType && rule.time_exit) {
+              const exitTime = new Date(rule.time_exit).getTime();
+              if (Date.now() >= exitTime) {
+                fireType = "TIME_EXIT";
+                fireReason = `Time-based exit triggered (deadline: ${rule.time_exit}). Current price: ${(currentPrice * 100).toFixed(1)}\xA2`;
+                sellPrice = currentPrice;
+              }
+            }
+            if (!fireType && rule.take_profit && currentPrice >= rule.take_profit) {
+              fireType = "TAKE_PROFIT";
+              fireReason = `Take-profit hit: ${(currentPrice * 100).toFixed(1)}\xA2 >= ${(rule.take_profit * 100).toFixed(1)}\xA2`;
+              sellPrice = currentPrice;
+            }
+            if (!fireType && rule.stop_loss && currentPrice <= rule.stop_loss) {
+              fireType = "STOP_LOSS";
+              fireReason = `Stop-loss hit: ${(currentPrice * 100).toFixed(1)}\xA2 <= ${(rule.stop_loss * 100).toFixed(1)}\xA2`;
+              sellPrice = currentPrice;
+            }
+            if (fireType) {
+              const recentDup = await edb.all(
+                `SELECT id FROM poly_watcher_events WHERE watcher_id = ? AND created_at > ?`,
+                ["exit_" + rule.id, dateAgoMin(5)]
+              ).catch(() => []);
+              if (recentDup && recentDup.length > 0) continue;
+              log(`[exit-rules] ${fireType} fired for ${rule.token_id}: ${fireReason}`);
+              let autoTradeResult = null;
+              let autoTradeError = null;
+              const sellSize = rule.position_size || 0;
+              if (sellSize > 0 && (currentPrice >= 0.99 || currentPrice <= 0.01)) {
+                log(`[exit-rules] Skipping auto-sell for ${rule.id}: market resolved (price=${currentPrice}). Deactivating rule.`);
+                await edb.run(`UPDATE poly_exit_rules SET status = 'cancelled' WHERE id = ?`, [rule.id]);
+                continue;
+              }
+              if (sellSize > 0) {
+                try {
+                  const { executeOrder } = await import("./polymarket-ZVUDH7EV.js");
+                  const tradeId = `exit_${rule.id}_${Date.now()}`;
+                  const tradeParams = {
+                    token_id: rule.token_id,
+                    side: "SELL",
+                    size: sellSize,
+                    price: sellPrice,
+                    market_question: `Auto-exit (${fireType}) \u2014 ${fireReason}`,
+                    order_type: "GTC"
+                  };
+                  const dbCompat = edb.query ? edb : { query: edb.all?.bind(edb), execute: edb.run?.bind(edb), run: edb.run?.bind(edb), get: edb.get?.bind(edb), all: edb.all?.bind(edb) };
+                  log(`[exit-rules] Auto-selling: ${sellSize} shares @ ${sellPrice}`);
+                  autoTradeResult = await executeOrder(rule.agent_id, dbCompat, tradeId, tradeParams, "auto_exit_" + fireType.toLowerCase());
+                  log(`[exit-rules] Auto-sell result: ${JSON.stringify(autoTradeResult).slice(0, 200)}`);
+                } catch (e) {
+                  autoTradeError = e.message;
+                  log(`[exit-rules] Auto-sell FAILED: ${e.message}`);
+                }
+              }
+              await edb.run(`UPDATE poly_exit_rules SET status = 'triggered' WHERE id = ?`, [rule.id]);
+              try {
+                const relatedBrackets = await edb.all(
+                  `SELECT id, bracket_group FROM poly_price_alerts WHERE agent_id = ? AND token_id = ? AND bracket_group IS NOT NULL AND triggered = 0`,
+                  [rule.agent_id, rule.token_id]
+                ).catch(() => []);
+                if (relatedBrackets && relatedBrackets.length > 0) {
+                  await edb.run(
+                    `UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE agent_id = ? AND token_id = ? AND bracket_group IS NOT NULL AND triggered = 0`,
+                    [rule.agent_id, rule.token_id]
+                  );
+                  log(`[exit-rules] Cross-cancelled ${relatedBrackets.length} bracket alert(s) for token ${rule.token_id}`);
+                }
+              } catch {
+              }
+              try {
+                await edb.run(
+                  `UPDATE poly_price_alerts SET triggered = 1, triggered_at = CURRENT_TIMESTAMP WHERE agent_id = ? AND token_id = ? AND bracket_group IS NULL AND triggered = 0 AND (condition = 'above' OR condition = 'below')`,
+                  [rule.agent_id, rule.token_id]
+                );
+              } catch {
+              }
+              const evtId = crypto.randomUUID();
+              const evt = {
+                type: "exit_triggered",
+                severity: "critical",
+                title: `[EXIT ${fireType}] ${rule.token_id.slice(0, 16)}\u2026`,
+                summary: `${fireReason}${autoTradeResult ? ` | Auto-SELL: ${sellSize} shares` : ""}${autoTradeError ? ` | SELL FAILED: ${autoTradeError}` : ""}`,
+                data: { exit_rule_id: rule.id, token_id: rule.token_id, fire_type: fireType, current_price: currentPrice, entry_price: rule.entry_price, auto_trade_result: autoTradeResult, auto_trade_error: autoTradeError }
+              };
+              await edb.run(
+                `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?,?,?,?,?,?,?,?)`,
+                [evtId, rule.agent_id, "exit_" + rule.id, evt.type, evt.severity, evt.title, evt.summary, JSON.stringify(evt.data)]
+              );
+              _engineEventCount++;
+              if (!eventsByAgent[rule.agent_id]) eventsByAgent[rule.agent_id] = { events: [], maxSeverity: "info" };
+              eventsByAgent[rule.agent_id].events.push(evt);
+              eventsByAgent[rule.agent_id].maxSeverity = "critical";
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      for (const [agentId, batch] of Object.entries(eventsByAgent)) {
+        if (batch.maxSeverity === "critical" || batch.maxSeverity === "warning") {
+          await _maybeSpawnAgent(agentId, batch.events, edb, opts, log);
+        }
+      }
+      const PROACTIVE_INTERVAL_MS = 15 * 6e4;
+      const proactiveElapsed = now - (_lastProactiveCheckMs || 0);
+      if (proactiveElapsed >= PROACTIVE_INTERVAL_MS) {
+        _lastProactiveCheckMs = now;
+        try {
+          const traderAgents = [...new Set(watchers.map((w) => w.agent_id))];
+          for (const agentId of traderAgents) {
+            const todayTrades = await edb.get(
+              `SELECT COUNT(*) as cnt FROM poly_trade_log WHERE agent_id = ? AND created_at > ?`,
+              [agentId, dateAgo(24)]
+            ).catch(() => ({ cnt: 0 }));
+            const tradeCount = parseInt(todayTrades?.cnt || "0");
+            const goal = await edb.get(
+              `SELECT target_value FROM poly_goals WHERE type = 'min_trades_daily' AND enabled = 1`,
+              []
+            ).catch(() => null);
+            const targetTrades = goal?.target_value || 15;
+            if (tradeCount < targetTrades) {
+              try {
+                const walletRow = await edb.get(`SELECT address FROM poly_wallets WHERE agent_id = ?`, [agentId]).catch(() => null);
+                if (walletRow?.address) {
+                  const balRes = await fetch(`https://rpc.ankr.com/polygon`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [{ to: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", data: "0x70a08231000000000000000000000000" + walletRow.address.slice(2).toLowerCase() }, "latest"] }),
+                    signal: AbortSignal.timeout(5e3)
+                  });
+                  const balData = await balRes.json();
+                  const balUSDC = parseInt(balData?.result || "0", 16) / 1e6;
+                  if (balUSDC < 5) {
+                    log(`[poly-watcher] Proactive: skipped agent ${agentId.slice(0, 8)} \u2014 balance $${balUSDC.toFixed(2)} < $5 minimum`);
+                    continue;
+                  }
+                }
+              } catch {
+              }
+              const lastSpawn = _lastSpawnByAgent[agentId] || 0;
+              if (now - lastSpawn >= SPAWN_COOLDOWN_MS) {
+                const agentRow = await edb.get(
+                  `SELECT config FROM managed_agents WHERE id = ?`,
+                  [agentId]
+                ).catch(() => null);
+                const agentConfig = typeof agentRow?.config === "string" ? JSON.parse(agentRow.config) : agentRow?.config;
+                const dep = agentConfig?.deployment;
+                const port = dep?.port || dep?.config?.local?.port || 3101;
+                const secret = process.env.AGENT_RUNTIME_SECRET || "";
+                const wakeMsg = `[PROACTIVE TRADING CHECK] You have ${tradeCount}/${targetTrades} trades today \u2014 ${targetTrades - tradeCount} more needed.
+
+MANDATORY SEQUENCE (do ALL of these IN ORDER before placing any new trades):
+
+1. poly_watcher_events action=check \u2014 Check for unread signals first
+2. poly_goals action=check \u2014 Review your performance targets
+3. poly_drawdown_monitor action=check \u2014 Check portfolio-level risk. HALT if drawdown > 15%
+4. poly_calibration \u2014 Review your prediction accuracy. Are you over/under-confident?
+5. poly_pnl_attribution \u2014 Which strategies and categories are making/losing money?
+6. poly_strategy_performance \u2014 Which strategies are actually profitable? Double down on winners.
+7. poly_get_positions \u2014 Review all open positions, check P&L drift
+8. poly_exit_strategy action=check \u2014 Check if any exit conditions triggered
+
+ONLY AFTER completing the above analysis:
+9. poly_screen_markets with strategies: high_volume, momentum, contested, closing_soon
+10. poly_search_markets for sports: NBA, MLB, Premier League, Champions League, UFC
+11. For EACH candidate: run poly_quick_analysis + poly_resolution_risk + poly_manipulation_detector
+12. Use poly_kelly_criterion for position sizing \u2014 do NOT just buy random $5 positions
+13. For orders > $50: use poly_scale_in (TWAP/VWAP), NOT market orders
+14. For time-sensitive opportunities: use poly_sniper with trailing limits
+15. Consider poly_hedge for correlated positions
+
+QUALITY > QUANTITY. Each trade must have analysis backing it. No blind trades.`;
+                const messaging = agentConfig?.messagingChannels || {};
+                const managerName = agentConfig?.manager?.name || agentConfig?.managerName || "Manager";
+                const managerEmail = agentConfig?.manager?.email || agentConfig?.managerEmail || "";
+                let wakeSource = "system";
+                let wakeSenderId = "watcher@system";
+                let wakeSpaceId = "watcher_proactive";
+                if (messaging.telegram?.chatId) {
+                  wakeSource = "telegram";
+                  wakeSenderId = messaging.telegram.chatId;
+                  wakeSpaceId = messaging.telegram.chatId;
+                } else if (messaging.whatsapp?.phoneNumber) {
+                  wakeSource = "whatsapp";
+                  wakeSenderId = messaging.whatsapp.phoneNumber;
+                  wakeSpaceId = messaging.whatsapp.phoneNumber;
+                } else if (messaging.google_chat?.spaceId) {
+                  wakeSource = "google_chat";
+                  wakeSenderId = managerEmail || "watcher@system";
+                  wakeSpaceId = messaging.google_chat.spaceId;
+                } else if (managerEmail) {
+                  wakeSource = "email";
+                  wakeSenderId = managerEmail;
+                  wakeSpaceId = managerEmail;
+                }
+                try {
+                  const resp = await fetch(`http://127.0.0.1:${port}/api/runtime/chat`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${secret}` },
+                    body: JSON.stringify({
+                      source: wakeSource,
+                      senderName: managerName,
+                      senderEmail: wakeSenderId,
+                      spaceName: "DM",
+                      spaceId: wakeSpaceId,
+                      threadId: "",
+                      isDM: true,
+                      messageText: wakeMsg,
+                      isManager: true
+                    }),
+                    signal: AbortSignal.timeout(1e4)
+                  });
+                  if (resp.ok) {
+                    log(`[poly-watcher] Proactive trading: woke agent ${agentId.slice(0, 8)} (${tradeCount}/${targetTrades} trades today)`);
+                    _lastSpawnByAgent[agentId] = now;
+                  } else {
+                    const body = await resp.text().catch(() => "");
+                    log(`[poly-watcher] Proactive: wake failed (${resp.status}): ${body.slice(0, 200)}`);
+                  }
+                } catch (e) {
+                  log(`[poly-watcher] Proactive: wake error: ${e.message}`);
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      await edb.run(`DELETE FROM poly_watcher_events WHERE acknowledged = 1 AND created_at < ?`, [dateAgo(168)]).catch(() => {
+      });
+      await edb.run(`DELETE FROM poly_analysis_cache WHERE created_at < ?`, [dateAgo(24)]).catch(() => {
+      });
+      await edb.run(`DELETE FROM poly_signal_buffer WHERE expires_at < ?`, [(/* @__PURE__ */ new Date()).toISOString()]).catch(() => {
+      });
+      await edb.run(`DELETE FROM poly_price_alerts WHERE triggered = 1 AND triggered_at < ?`, [dateAgo(720)]).catch(() => {
+      });
+    } catch (e) {
+    }
+  }, TICK_MS);
+}
+async function _maybeSpawnAgent(agentId, events, edb, opts, log) {
+  const getRuntime = opts.getRuntime;
+  if (!getRuntime) return;
+  const runtime = getRuntime();
+  if (!runtime) return;
+  const lastSpawn = _lastSpawnByAgent[agentId] || 0;
+  const now = Date.now();
+  if (now - lastSpawn < SPAWN_COOLDOWN_MS) {
+    log(`[poly-watcher] Spawn cooldown for ${agentId} (${Math.ceil((SPAWN_COOLDOWN_MS - (now - lastSpawn)) / 1e3)}s)`);
+    return;
+  }
+  try {
+    const activeSessions = await runtime.listSessions?.(agentId, { status: "active", limit: 1 });
+    if (activeSessions && activeSessions.length > 0) {
+      const sessionId = activeSessions[0].id;
+      const msg = _buildWakeMessage(events);
+      try {
+        await runtime.sendMessage(sessionId, msg);
+        log(`[poly-watcher] Sent ${events.length} signals to active session ${sessionId}`);
+        _lastSpawnByAgent[agentId] = now;
+        _spawnCount++;
+      } catch (e) {
+        log(`[poly-watcher] Failed to send to session: ${e.message}`);
+      }
+      return;
+    }
+  } catch {
+  }
+  try {
+    let orgId = "default";
+    if (opts.getAgentConfig) {
+      const cfg = opts.getAgentConfig(agentId);
+      if (cfg?.org_id) orgId = cfg.org_id;
+    }
+    const msg = _buildWakeMessage(events);
+    const session = await runtime.spawnSession({ agentId, orgId, message: msg });
+    _lastSpawnByAgent[agentId] = now;
+    _spawnCount++;
+    log(`[poly-watcher] [ALERT] Spawned session ${session.id} for ${agentId} \u2014 ${events.length} signals`);
+    await edb.run(
+      `INSERT INTO poly_watcher_events (id, agent_id, watcher_id, type, severity, title, summary, data) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        crypto.randomUUID(),
+        agentId,
+        null,
+        "agent_spawn",
+        "info",
+        `Agent session spawned with ${events.length} signals`,
+        `Session ${session.id}`,
+        JSON.stringify({ sessionId: session.id, eventCount: events.length, events: events.slice(0, 5).map((e) => e.title) })
+      ]
+    ).catch(() => {
+    });
+  } catch (e) {
+    log(`[poly-watcher] Spawn failed for ${agentId}: ${e.message}`);
+  }
+}
+function _buildWakeMessage(events) {
+  const critical = events.filter((e) => e.severity === "critical");
+  const warning = events.filter((e) => e.severity === "warning");
+  const info = events.filter((e) => e.severity === "info");
+  let msg = `[ALERT] WATCHER ALERT \u2014 ${events.length} signal${events.length > 1 ? "s" : ""} detected:
+
+`;
+  const autoTrades = events.filter((e) => e.data?.auto_trade_result || e.data?.auto_trade_error);
+  if (autoTrades.length > 0) {
+    msg += `\u26A1 AUTO-TRADES EXECUTED (${autoTrades.length}):
+`;
+    for (const e of autoTrades) {
+      if (e.data?.auto_trade_result) {
+        msg += `  \u2705 ${e.title} \u2014 Trade placed. REVIEW THIS IMMEDIATELY.
+`;
+      } else if (e.data?.auto_trade_error) {
+        msg += `  \u274C ${e.title} \u2014 Trade FAILED: ${e.data.auto_trade_error}. Manual action needed.
+`;
+      }
+    }
+    msg += `
+You were woken because trades were auto-executed. IMPORTANT ACTIONS:
+`;
+    msg += `1. Check positions with poly_get_positions and verify the trades are correct.
+`;
+    msg += `2. Check your USDC balance \u2014 if you have idle cash from sells, REINVEST IT. Find new opportunities with poly_search_markets and deploy capital.
+`;
+    msg += `3. Set up new bracket orders (TP/SL) for any new positions.
+
+`;
+  }
+  if (critical.length > 0) {
+    msg += `CRITICAL (${critical.length}):
+`;
+    for (const e of critical.slice(0, MAX_BATCH_EVENTS)) {
+      msg += `  \u2022 ${e.title}${e.summary ? " \u2014 " + e.summary : ""}
+`;
+      if (e.data?.reasoning) msg += `    AI Analysis: ${e.data.reasoning}
+`;
+      if (e.data?.recommended_action) msg += `    Recommended: ${e.data.recommended_action}
+`;
+    }
+    msg += "\n";
+  }
+  if (warning.length > 0) {
+    msg += `WARNING (${warning.length}):
+`;
+    for (const e of warning.slice(0, MAX_BATCH_EVENTS)) {
+      msg += `  \u2022 ${e.title}${e.summary ? " \u2014 " + e.summary : ""}
+`;
+    }
+    msg += "\n";
+  }
+  if (info.length > 0) {
+    msg += `INFO (${info.length}):
+`;
+    for (const e of info.slice(0, 3)) msg += `  \u2022 ${e.title}
+`;
+    if (info.length > 3) msg += `  ... and ${info.length - 3} more
+`;
+    msg += "\n";
+  }
+  const hasNews = events.some((e) => e.type === "news_intelligence" || e.type === "geopolitical");
+  if (hasNews && !autoTrades.length) {
+    msg += `
+\u{1F4F0} NEWS INTELLIGENCE DETECTED \u2014 ACTION REQUIRED:
+`;
+    msg += `1. Read the headlines above carefully. Extract key topics, names, events.
+`;
+    msg += `2. Use poly_search_markets to find Polymarket markets related to these headlines.
+`;
+    msg += `3. For each relevant market: check the odds, assess if the news shifts probability, and evaluate if there's an edge.
+`;
+    msg += `4. If you find a market with a clear edge (news makes an outcome more/less likely than current odds suggest), place a trade.
+`;
+    msg += `5. Check your USDC balance with poly_get_balance \u2014 deploy idle cash into high-conviction opportunities.
+`;
+    msg += `6. Information is power in prediction markets. Headlines that move real-world probabilities before the market prices them in = alpha.
+`;
+    msg += `
+Do NOT just acknowledge this. RESEARCH and ACT on the intelligence.
+`;
+  } else {
+    msg += `
+Run poly_watcher_events action=check for full details. Assess and act.
+`;
+    msg += `ALWAYS check your USDC balance \u2014 idle cash should be deployed into new positions. Money sitting is money wasted.
+`;
+  }
+  return msg;
+}
+function _stopFastLoop(log) {
+  if (engineInterval) {
+    clearInterval(engineInterval);
+    engineInterval = null;
+    log("[poly-watcher] No active watchers \u2014 paused (idle polling continues)");
+  }
+}
+function controlWatcherEngine(action) {
+  const log = _engineOpts?.log || console.log;
+  if (action === "stop") {
+    _stopFastLoop(log);
+    if (idleInterval) {
+      clearInterval(idleInterval);
+      idleInterval = null;
+    }
+    log("[poly-watcher] Engine fully stopped");
+  } else if (action === "start" && _engineDb) {
+    startWatcherEngine(_engineDb, _engineOpts || void 0);
+  }
+}
+function stopWatcherEngine() {
+  if (engineInterval) {
+    clearInterval(engineInterval);
+    engineInterval = null;
+  }
+  if (idleInterval) {
+    clearInterval(idleInterval);
+    idleInterval = null;
+  }
+  _engineStartedAt = null;
+}
+async function runWatcher(type, config, agentId, edb) {
+  switch (type) {
+    case "price_level":
+      return checkPriceLevel(config);
+    case "price_change":
+      return checkPriceChange(config, edb);
+    case "market_scan":
+      return checkMarketScan(config, edb);
+    case "news_intelligence":
+      return checkNewsIntelligence(config, agentId, edb);
+    case "news_monitor":
+      return checkNewsIntelligence(config, agentId, edb);
+    // Alias for backward compat
+    case "crypto_price":
+      return checkCryptoPrice(config);
+    case "resolution_watch":
+      return checkResolution(config);
+    case "portfolio_drift":
+      return checkPortfolioDrift(config, agentId, edb);
+    case "volume_surge":
+      return checkVolumeSurge(config, edb);
+    case "geopolitical":
+      return checkGeopolitical(config, agentId, edb);
+    case "cross_signal":
+      return checkCrossSignal(config, agentId, edb);
+    case "arbitrage_scan":
+      return checkArbitrageScan(config);
+    case "sentiment_shift":
+      return checkSentimentShift(config, agentId, edb);
+    default:
+      return [];
+  }
+}
+async function checkPriceLevel(config) {
+  const { token_id, direction, threshold, market_question } = config;
+  if (!token_id || !threshold) return [];
+  try {
+    const res = await fetch(`${CLOB_API}/midpoint?token_id=${token_id}`, { signal: AbortSignal.timeout(5e3) });
+    const data = await res.json();
+    const price = parseFloat(data.mid || data.price || "0");
+    if (!price) return [];
+    const label = market_question || token_id.slice(0, 12) + "\u2026";
+    if (direction === "above" && price >= threshold) {
+      return [{
+        type: "price_level",
+        severity: "warning",
+        title: `[UP] ${label} crossed ${threshold}`,
+        summary: `Current: ${price.toFixed(4)} (threshold: ${threshold})`,
+        data: { token_id, price, threshold, direction }
+      }];
+    }
+    if (direction === "below" && price <= threshold) {
+      return [{
+        type: "price_level",
+        severity: "warning",
+        title: `[DOWN] ${label} dropped below ${threshold}`,
+        summary: `Current: ${price.toFixed(4)} (threshold: ${threshold})`,
+        data: { token_id, price, threshold, direction }
+      }];
+    }
+  } catch {
+  }
+  return [];
+}
+async function checkPriceChange(config, edb) {
+  const { token_id, pct_threshold, market_question } = config;
+  if (!token_id || !pct_threshold) return [];
+  try {
+    const res = await fetch(`${CLOB_API}/midpoint?token_id=${token_id}`, { signal: AbortSignal.timeout(5e3) });
+    const data = await res.json();
+    const price = parseFloat(data.mid || data.price || "0");
+    if (!price) return [];
+    const cached = await edb.get(`SELECT * FROM poly_price_cache WHERE token_id = ?`, [token_id]);
+    await edb.run(
+      `INSERT INTO poly_price_cache (token_id, price, prev_price, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(token_id) DO UPDATE SET prev_price = price, price = ?, updated_at = CURRENT_TIMESTAMP`,
+      [token_id, price, cached?.price || price, price]
+    );
+    if (cached?.price && cached.price > 0) {
+      const changePct = (price - cached.price) / cached.price * 100;
+      if (Math.abs(changePct) >= pct_threshold) {
+        const label = market_question || token_id.slice(0, 12) + "\u2026";
+        return [{
+          type: "price_change",
+          severity: Math.abs(changePct) >= pct_threshold * 2 ? "critical" : "warning",
+          title: `${changePct > 0 ? "[UP]" : "[DOWN]"} ${label} moved ${changePct > 0 ? "+" : ""}${changePct.toFixed(1)}%`,
+          summary: `${cached.price.toFixed(4)} \u2192 ${price.toFixed(4)}`,
+          data: { token_id, price, prev_price: cached.price, change_pct: changePct }
+        }];
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+async function checkMarketScan(config, edb) {
+  const { keywords, min_volume, min_liquidity } = config;
+  if (!keywords || !keywords.length) return [];
+  try {
+    const q = encodeURIComponent(keywords.join(" "));
+    const res = await fetch(`${GAMMA_API}/markets?closed=false&limit=10&order=volume24hr&ascending=false&search=${q}`, { signal: AbortSignal.timeout(8e3) });
+    const markets = await res.json();
+    const events = [];
+    for (const m of markets.slice(0, 5)) {
+      if (min_volume && (m.volume24hr || 0) < min_volume) continue;
+      if (min_liquidity && (m.liquidityClob || 0) < min_liquidity) continue;
+      const existing = await edb.get(
+        `SELECT id FROM poly_watcher_events WHERE type = 'market_scan' AND data LIKE ? AND created_at > ?`,
+        ["%" + m.conditionId + "%", dateAgo(24)]
+      ).catch(() => null);
+      if (existing) continue;
+      events.push({
+        type: "market_scan",
+        severity: "info",
+        title: `[SCAN] New market: ${m.question?.slice(0, 80)}`,
+        summary: `Volume: $${(m.volume24hr || 0).toFixed(0)} | Liquidity: $${(m.liquidityClob || 0).toFixed(0)}`,
+        data: { condition_id: m.conditionId, question: m.question, volume: m.volume24hr, liquidity: m.liquidityClob }
+      });
+    }
+    return events;
+  } catch {
+  }
+  return [];
+}
+async function checkNewsIntelligence(config, agentId, edb) {
+  const { keywords, sources, watched_markets } = config;
+  if (!keywords || !keywords.length) return [];
+  try {
+    const newsPromises = [];
+    const q = encodeURIComponent(keywords.join(" OR "));
+    newsPromises.push(
+      fetch(`https://news.google.com/rss/search?q=${q}&hl=en-US&gl=US&ceid=US:en`, { signal: AbortSignal.timeout(8e3) }).then((r) => r.text()).then((xml) => {
+        const items = xml.split("<item>").slice(1, 8);
+        return items.map((item) => {
+          const titleMatch = item.match(/<title><!\[CDATA\[(.*?)\]\]><\/title>|<title>(.*?)<\/title>/);
+          const linkMatch = item.match(/<link>(.*?)<\/link>/);
+          const pubMatch = item.match(/<pubDate>(.*?)<\/pubDate>/);
+          return {
+            title: titleMatch?.[1] || titleMatch?.[2] || "",
+            source: "Google News",
+            url: linkMatch?.[1] || "",
+            date: pubMatch?.[1] || ""
+          };
+        }).filter((n) => n.title);
+      }).catch(() => [])
+    );
+    newsPromises.push(
+      fetch("https://rsshub.app/apnews/topics/world-news", { signal: AbortSignal.timeout(8e3) }).then((r) => r.text()).then((xml) => {
+        const items = xml.split("<item>").slice(1, 6);
+        return items.map((item) => {
+          const titleMatch = item.match(/<title><!\[CDATA\[(.*?)\]\]><\/title>|<title>(.*?)<\/title>/);
+          const linkMatch = item.match(/<link>(.*?)<\/link>/);
+          return { title: titleMatch?.[1] || titleMatch?.[2] || "", source: "AP News", url: linkMatch?.[1] || "" };
+        }).filter((n) => n.title);
+      }).catch(() => [])
+    );
+    newsPromises.push(
+      fetch("https://rsshub.app/reuters/world", { signal: AbortSignal.timeout(8e3) }).then((r) => r.text()).then((xml) => {
+        const items = xml.split("<item>").slice(1, 6);
+        return items.map((item) => {
+          const titleMatch = item.match(/<title><!\[CDATA\[(.*?)\]\]><\/title>|<title>(.*?)<\/title>/);
+          const linkMatch = item.match(/<link>(.*?)<\/link>/);
+          return { title: titleMatch?.[1] || titleMatch?.[2] || "", source: "Reuters", url: linkMatch?.[1] || "" };
+        }).filter((n) => n.title);
+      }).catch(() => [])
+    );
+    const allNews = (await Promise.all(newsPromises)).flat();
+    if (allNews.length === 0) return [];
+    const now = Date.now();
+    const relevant = allNews.filter((n) => {
+      if (n.date) {
+        const age = now - new Date(n.date).getTime();
+        if (age > 6 * 60 * 60 * 1e3) return false;
+      }
+      const lower = n.title.toLowerCase();
+      return keywords.some((k) => lower.includes(k.toLowerCase()));
+    });
+    if (relevant.length === 0) return [];
+    const fresh = [];
+    for (const n of relevant) {
+      const titleKey = n.title.slice(0, 50).replace(/[%_\\]/g, "\\$&");
+      const existing = await edb.get(
+        `SELECT id FROM poly_watcher_events WHERE agent_id = ? AND title LIKE ? AND created_at > ?`,
+        [agentId, "%" + titleKey + "%", dateAgo(6)]
+      ).catch(() => null);
+      if (!existing) fresh.push(n);
+    }
+    if (fresh.length === 0) return [];
+    const analysis = await analyzeWithAI(
+      `Recent headlines relevant to prediction markets:
+${fresh.map((n) => `- ${n.title} (${n.source})`).join("\n")}`,
+      { watchedMarkets: watched_markets },
+      agentId,
+      edb
+    );
+    if (analysis) _engineAnalysisCount++;
+    const events = [];
+    const impactToSeverity = {
+      none: "info",
+      low: "info",
+      medium: "warning",
+      high: "warning",
+      critical: "critical"
+    };
+    let severity = analysis ? impactToSeverity[analysis.impact] || "info" : "info";
+    if (analysis && analysis.impact === "none") {
+      return [];
+    }
+    if (severity === "info" && watched_markets?.length) {
+      const headlineText = fresh.map((n) => n.title.toLowerCase()).join(" ");
+      const positionKeywords = ["iran", "invade", "invasion", "military", "troops", "nfl", "bills", "saints", "eu", "withdraw", "gta", "milan", "inter"];
+      const matches = positionKeywords.filter((k) => headlineText.includes(k));
+      if (matches.length > 0) {
+        severity = "warning";
+      }
+    }
+    events.push({
+      type: "news_intelligence",
+      severity,
+      title: `[NEWS] ${fresh[0].title.slice(0, 80)}${fresh.length > 1 ? ` (+${fresh.length - 1} more)` : ""}`,
+      summary: analysis ? `AI Impact: ${analysis.impact.toUpperCase()} | Sentiment: ${analysis.sentiment > 0 ? "+" : ""}${analysis.sentiment.toFixed(2)} | ${analysis.reasoning}` : `${fresh.length} relevant headlines found. Keywords: ${keywords.join(", ")}`,
+      data: {
+        headlines: fresh.slice(0, 5).map((n) => ({ title: n.title, source: n.source, url: n.url })),
+        content_hash: hashContent(fresh.map((n) => n.title).join("|")),
+        ...analysis || {}
+      }
+    });
+    if (analysis && analysis.impact !== "none") {
+      await edb.run(
+        `INSERT INTO poly_signal_buffer (id, agent_id, signal_type, topic, data, sentiment, impact, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [crypto.randomUUID(), agentId, "news", keywords.join(","), JSON.stringify({ headlines: fresh.slice(0, 3).map((n) => n.title), analysis }), analysis.sentiment, analysis.impact, dateAhead(2)]
+      ).catch(() => {
+      });
+    }
+    return events;
+  } catch {
+  }
+  return [];
+}
+async function checkGeopolitical(config, agentId, edb) {
+  const { regions, topics, watched_markets } = config;
+  const searchTerms = [
+    ...regions || ["us", "china", "russia", "ukraine", "iran", "israel", "north korea"],
+    ...topics || ["sanctions", "military", "trade war", "election", "tariff", "nato", "diplomacy"]
+  ];
+  try {
+    const queries = [
+      searchTerms.slice(0, 4).join(" OR "),
+      "geopolitics " + (regions || ["world"]).join(" "),
+      "breaking international " + (topics || ["conflict"]).join(" ")
+    ];
+    const allHeadlines = [];
+    for (const query of queries) {
+      try {
+        const q = encodeURIComponent(query);
+        const res = await fetch(`https://news.google.com/rss/search?q=${q}&hl=en-US&gl=US&ceid=US:en`, { signal: AbortSignal.timeout(8e3) });
+        const xml = await res.text();
+        const items = xml.split("<item>").slice(1, 6);
+        for (const item of items) {
+          const titleMatch = item.match(/<title><!\[CDATA\[(.*?)\]\]><\/title>|<title>(.*?)<\/title>/);
+          const pubMatch = item.match(/<pubDate>(.*?)<\/pubDate>/);
+          const headline = titleMatch?.[1] || titleMatch?.[2] || "";
+          if (!headline) continue;
+          if (pubMatch?.[1]) {
+            const age = Date.now() - new Date(pubMatch[1]).getTime();
+            if (age > 12 * 60 * 60 * 1e3) continue;
+          }
+          allHeadlines.push({ title: headline, source: "Google News", date: pubMatch?.[1] });
+        }
+      } catch {
+      }
+    }
+    if (allHeadlines.length === 0) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const unique = allHeadlines.filter((h) => {
+      const key = h.title.toLowerCase().slice(0, 50);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    const watcherTopics = watched_markets || [];
+    const positions = await edb.all(
+      `SELECT DISTINCT market_question FROM poly_paper_positions WHERE agent_id = ? AND closed = 0`,
+      [agentId]
+    ).catch(() => []) || [];
+    const positionTopics = positions.map((p) => p.market_question).filter(Boolean);
+    const analysis = await analyzeGeopolitical(
+      unique.slice(0, 10),
+      [...watcherTopics, ...positionTopics],
+      agentId,
+      edb
+    );
+    if (!analysis || analysis.impact === "none" || analysis.impact === "low") return [];
+    _engineAnalysisCount++;
+    const impactToSeverity = {
+      medium: "warning",
+      high: "warning",
+      critical: "critical"
+    };
+    await edb.run(
+      `INSERT INTO poly_signal_buffer (id, agent_id, signal_type, topic, data, sentiment, impact, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        crypto.randomUUID(),
+        agentId,
+        "geopolitical",
+        (regions || ["world"]).join(","),
+        JSON.stringify({ headlines: unique.slice(0, 5).map((h) => h.title), analysis }),
+        analysis.sentiment,
+        analysis.impact,
+        dateAhead(4)
+      ]
+    ).catch(() => {
+    });
+    return [{
+      type: "geopolitical",
+      severity: impactToSeverity[analysis.impact] || "warning",
+      title: `[GEO] Geopolitical: ${analysis.predicted_outcome?.slice(0, 80) || "Significant development detected"}`,
+      summary: `Impact: ${analysis.impact.toUpperCase()} | ${analysis.reasoning}`,
+      data: {
+        headlines: unique.slice(0, 5).map((h) => h.title),
+        ...analysis
+      }
+    }];
+  } catch {
+  }
+  return [];
+}
+async function checkCrossSignal(config, agentId, edb) {
+  const { min_signals, correlation_window_hours } = config;
+  const minSignals = min_signals || 3;
+  const windowHours = correlation_window_hours || 2;
+  try {
+    const signals = await edb.all(
+      `SELECT * FROM poly_signal_buffer WHERE agent_id = ? AND created_at > ? ORDER BY created_at DESC`,
+      [agentId, dateAgo(windowHours)]
+    ) || [];
+    if (signals.length < minSignals) return [];
+    const signalIds = signals.map((s) => s.id).sort().join(",");
+    const hash = hashContent(signalIds);
+    const existing = await edb.get(
+      `SELECT id FROM poly_watcher_events WHERE agent_id = ? AND type = 'cross_signal' AND data LIKE ? AND created_at > ?`,
+      [agentId, "%" + hash + "%", dateAgo(1)]
+    ).catch(() => null);
+    if (existing) return [];
+    const signalSummaries = signals.map((s) => {
+      const data = JSON.parse(s.data || "{}");
+      return {
+        type: s.signal_type,
+        topic: s.topic,
+        sentiment: s.sentiment,
+        impact: s.impact,
+        summary: data.analysis?.reasoning || data.headlines?.join("; ") || s.topic
+      };
+    });
+    const analysis = await analyzeSignalCorrelation(signalSummaries, agentId, edb);
+    if (!analysis || analysis.impact === "none" || analysis.impact === "low") return [];
+    _engineAnalysisCount++;
+    const impactToSeverity = {
+      medium: "warning",
+      high: "critical",
+      critical: "critical"
+    };
+    return [{
+      type: "cross_signal",
+      severity: impactToSeverity[analysis.impact] || "warning",
+      title: `[CORR] Signal convergence: ${signals.length} correlated signals`,
+      summary: `Impact: ${analysis.impact.toUpperCase()} | ${analysis.reasoning}`,
+      data: {
+        signal_count: signals.length,
+        signal_types: [...new Set(signals.map((s) => s.signal_type))],
+        correlation_hash: hash,
+        ...analysis
+      }
+    }];
+  } catch {
+  }
+  return [];
+}
+async function checkSentimentShift(config, agentId, edb) {
+  const { topic, keywords, shift_threshold } = config;
+  if (!topic && (!keywords || !keywords.length)) return [];
+  const threshold = shift_threshold || 0.3;
+  const searchTopic = topic || keywords.join(" ");
+  try {
+    const q = encodeURIComponent(searchTopic);
+    const res = await fetch(`https://news.google.com/rss/search?q=${q}&hl=en-US&gl=US&ceid=US:en`, { signal: AbortSignal.timeout(8e3) });
+    const xml = await res.text();
+    const items = xml.split("<item>").slice(1, 8);
+    const headlines = [];
+    for (const item of items) {
+      const titleMatch = item.match(/<title><!\[CDATA\[(.*?)\]\]><\/title>|<title>(.*?)<\/title>/);
+      const pubMatch = item.match(/<pubDate>(.*?)<\/pubDate>/);
+      const headline = titleMatch?.[1] || titleMatch?.[2] || "";
+      if (!headline) continue;
+      if (pubMatch?.[1]) {
+        const age = Date.now() - new Date(pubMatch[1]).getTime();
+        if (age > 12 * 60 * 60 * 1e3) continue;
+      }
+      headlines.push(headline);
+    }
+    if (headlines.length === 0) return [];
+    const analysis = await analyzeWithAI(
+      `Analyze overall sentiment for "${searchTopic}" based on these headlines:
+${headlines.map((h) => `- ${h}`).join("\n")}
+
+Focus on: Is sentiment shifting? Which direction? How fast?`,
+      { topic: searchTopic },
+      agentId,
+      edb
+    );
+    if (!analysis) return [];
+    _engineAnalysisCount++;
+    const prevSentiment = await edb.get(
+      `SELECT sentiment, created_at FROM poly_sentiment_history WHERE agent_id = ? AND topic = ? ORDER BY created_at DESC LIMIT 1`,
+      [agentId, searchTopic]
+    ).catch(() => null);
+    await edb.run(
+      `INSERT INTO poly_sentiment_history (id, agent_id, topic, sentiment, confidence, source, analysis) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [crypto.randomUUID(), agentId, searchTopic, analysis.sentiment, analysis.confidence, "news", analysis.reasoning]
+    ).catch(() => {
+    });
+    if (!prevSentiment) return [];
+    const shift = Math.abs(analysis.sentiment - prevSentiment.sentiment);
+    if (shift < threshold) return [];
+    const direction = analysis.sentiment > prevSentiment.sentiment ? "positive" : "negative";
+    await edb.run(
+      `INSERT INTO poly_signal_buffer (id, agent_id, signal_type, topic, data, sentiment, impact, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        crypto.randomUUID(),
+        agentId,
+        "sentiment_shift",
+        searchTopic,
+        JSON.stringify({ prev: prevSentiment.sentiment, current: analysis.sentiment, shift, direction, analysis }),
+        analysis.sentiment,
+        shift >= threshold * 2 ? "high" : "medium",
+        dateAhead(2)
+      ]
+    ).catch(() => {
+    });
+    return [{
+      type: "sentiment_shift",
+      severity: shift >= threshold * 2 ? "critical" : "warning",
+      title: `${direction === "positive" ? "[UP]" : "[DOWN]"} Sentiment shift on "${searchTopic}": ${direction} (${shift > 0 ? "+" : ""}${shift.toFixed(2)})`,
+      summary: `${prevSentiment.sentiment.toFixed(2)} \u2192 ${analysis.sentiment.toFixed(2)} | ${analysis.reasoning}`,
+      data: {
+        topic: searchTopic,
+        prev_sentiment: prevSentiment.sentiment,
+        current_sentiment: analysis.sentiment,
+        shift,
+        direction,
+        ...analysis
+      }
+    }];
+  } catch {
+  }
+  return [];
+}
+async function checkCryptoPrice(config) {
+  const { symbols, pct_threshold } = config;
+  const coins = symbols || ["bitcoin", "ethereum"];
+  const threshold = pct_threshold || 3;
+  try {
+    if (Date.now() - lastCryptoFetch < 12e4 && Object.keys(cryptoCache).length > 0) return [];
+    const ids = coins.join(",");
+    const res = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd&include_24hr_change=true`, { signal: AbortSignal.timeout(5e3) });
+    const data = await res.json();
+    lastCryptoFetch = Date.now();
+    const events = [];
+    for (const coin of coins) {
+      const info = data[coin];
+      if (!info) continue;
+      const price = info.usd;
+      const change = info.usd_24h_change || 0;
+      const prev = cryptoCache[coin];
+      cryptoCache[coin] = { price, change_24h: change };
+      if (prev && Math.abs(change) >= threshold) {
+        events.push({
+          type: "crypto_price",
+          severity: Math.abs(change) >= threshold * 2 ? "critical" : "warning",
+          title: `${change > 0 ? "[UP]" : "[DOWN]"} ${coin.toUpperCase()} ${change > 0 ? "+" : ""}${change.toFixed(1)}% (24h)`,
+          summary: `$${price.toLocaleString()} | Threshold: \xB1${threshold}%`,
+          data: { coin, price, change_24h: change }
+        });
+      }
+    }
+    return events;
+  } catch {
+  }
+  return [];
+}
+async function checkResolution(config) {
+  const { hours_before, categories } = config;
+  const hoursThreshold = hours_before || 48;
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const cutoff = new Date(now.getTime() + hoursThreshold * 60 * 60 * 1e3).toISOString();
+    let url = `${GAMMA_API}/markets?closed=false&end_date_max=${cutoff}&limit=10&order=endDate&ascending=true`;
+    if (categories?.length) url += "&tag=" + categories[0];
+    const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+    const markets = await res.json();
+    const events = [];
+    for (const m of markets.slice(0, 5)) {
+      if (!m.endDate) continue;
+      const hoursLeft = (new Date(m.endDate).getTime() - now.getTime()) / (60 * 60 * 1e3);
+      if (hoursLeft < 0 || hoursLeft > hoursThreshold) continue;
+      events.push({
+        type: "resolution_watch",
+        severity: hoursLeft < 6 ? "critical" : hoursLeft < 24 ? "warning" : "info",
+        title: `[TIME] Resolving in ${hoursLeft < 1 ? Math.round(hoursLeft * 60) + "m" : Math.round(hoursLeft) + "h"}: ${m.question?.slice(0, 80)}`,
+        summary: `End: ${new Date(m.endDate).toLocaleString()}`,
+        data: { condition_id: m.conditionId, question: m.question, end_date: m.endDate, hours_left: hoursLeft }
+      });
+    }
+    return events;
+  } catch {
+  }
+  return [];
+}
+async function checkPortfolioDrift(config, agentId, edb) {
+  const { pnl_threshold_pct, pnl_threshold_usd } = config;
+  if (!pnl_threshold_pct && !pnl_threshold_usd) return [];
+  try {
+    const positions = await edb.all(
+      `SELECT * FROM poly_paper_positions WHERE agent_id = ? AND closed = 0`,
+      [agentId]
+    ) || [];
+    if (positions.length === 0) return [];
+    let totalInvested = 0, totalPnl = 0;
+    for (const p of positions) {
+      totalInvested += (p.entry_price || 0) * (p.size || 0);
+      totalPnl += p.pnl || 0;
+    }
+    const driftPct = totalInvested > 0 ? totalPnl / totalInvested * 100 : 0;
+    if (pnl_threshold_pct && Math.abs(driftPct) >= pnl_threshold_pct) {
+      return [{
+        type: "portfolio_drift",
+        severity: driftPct < 0 ? "critical" : "warning",
+        title: `${driftPct < 0 ? "[LOSS]" : "[GAIN]"} Portfolio ${driftPct > 0 ? "+" : ""}${driftPct.toFixed(1)}% drift`,
+        summary: `P&L: $${totalPnl.toFixed(2)} across ${positions.length} positions`,
+        data: { total_pnl: totalPnl, drift_pct: driftPct, position_count: positions.length }
+      }];
+    }
+    if (pnl_threshold_usd && Math.abs(totalPnl) >= pnl_threshold_usd) {
+      return [{
+        type: "portfolio_drift",
+        severity: totalPnl < 0 ? "critical" : "warning",
+        title: `${totalPnl < 0 ? "[LOSS]" : "[GAIN]"} Portfolio P&L hit $${Math.abs(totalPnl).toFixed(2)}`,
+        summary: `Threshold: $${pnl_threshold_usd} | Positions: ${positions.length}`,
+        data: { total_pnl: totalPnl, threshold: pnl_threshold_usd }
+      }];
+    }
+  } catch {
+  }
+  return [];
+}
+async function checkVolumeSurge(config, edb) {
+  const { token_id, surge_multiplier, market_question } = config;
+  if (!token_id) return [];
+  const multiplier = surge_multiplier || 3;
+  try {
+    const res = await fetch(`${GAMMA_API}/markets?condition_id=${token_id}&limit=1`, { signal: AbortSignal.timeout(5e3) });
+    const markets = await res.json();
+    const m = markets?.[0];
+    if (!m) return [];
+    const vol = m.volume24hr || 0;
+    const cached = await edb.get(`SELECT * FROM poly_price_cache WHERE token_id = ?`, [token_id]);
+    const prevVol = cached?.volume_24h || 0;
+    await edb.run(
+      `INSERT INTO poly_price_cache (token_id, price, volume_24h, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(token_id) DO UPDATE SET volume_24h = ?, updated_at = CURRENT_TIMESTAMP`,
+      [token_id, m.outcomePrices ? JSON.parse(m.outcomePrices)[0] : 0, vol, vol]
+    );
+    if (prevVol > 0 && vol >= prevVol * multiplier) {
+      const label = market_question || m.question?.slice(0, 60) || token_id.slice(0, 12);
+      return [{
+        type: "volume_surge",
+        severity: "warning",
+        title: `[VOL] Volume surge on ${label}: ${(vol / prevVol).toFixed(1)}x`,
+        summary: `$${prevVol.toFixed(0)} \u2192 $${vol.toFixed(0)} (${multiplier}x threshold)`,
+        data: { token_id, volume: vol, prev_volume: prevVol, multiplier: vol / prevVol }
+      }];
+    }
+  } catch {
+  }
+  return [];
+}
+async function checkArbitrageScan(config) {
+  const { min_edge_pct, categories } = config;
+  const minEdge = min_edge_pct || 2;
+  try {
+    let url = `${GAMMA_API}/markets?closed=false&limit=20&order=volume24hr&ascending=false`;
+    if (categories?.length) url += "&tag=" + categories[0];
+    const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+    const markets = await res.json();
+    const events = [];
+    for (const m of markets) {
+      if (!m.outcomePrices) continue;
+      try {
+        const prices = JSON.parse(m.outcomePrices);
+        const sum = prices.reduce((s, p) => s + p, 0);
+        const edge = Math.abs(1 - sum) * 100;
+        if (edge >= minEdge) {
+          events.push({
+            type: "arbitrage_scan",
+            severity: edge >= minEdge * 2 ? "warning" : "info",
+            title: `[ARB] Arbitrage: ${edge.toFixed(1)}% edge on ${m.question?.slice(0, 60)}`,
+            summary: `Outcome prices sum: ${sum.toFixed(4)} (ideal: 1.0000)`,
+            data: { condition_id: m.conditionId, question: m.question, prices, edge_pct: edge }
+          });
+        }
+      } catch {
+      }
+    }
+    return events.slice(0, 3);
+  } catch {
+  }
+  return [];
+}
+function createWatcherTools(deps) {
+  return [
+    {
+      name: "poly_watcher",
+      description: "Manage automated market monitors with AI-powered analysis. Create watchers that run 24/7, analyze news with LLM intelligence, detect geopolitical patterns, and generate actionable signals.\n\nActions:\n- create: Set up a new watcher\n- list: View all watchers\n- delete: Remove a watcher\n- pause/resume: Toggle watcher\n\nTypes:\n- price_level: Alert when token price crosses threshold\n- price_change: Alert on % price movement\n- market_scan: Discover new markets matching keywords\n- news_intelligence: AI-analyzed news with market impact assessment\n- crypto_price: BTC/ETH price tracker\n- resolution_watch: Markets approaching resolution\n- portfolio_drift: P&L exceeds threshold\n- volume_surge: Unusual volume detection\n- geopolitical: AI scans geopolitical developments, predicts market impact\n- cross_signal: AI correlates multiple signals to detect emerging patterns\n- arbitrage_scan: Cross-market mispricing\n- sentiment_shift: Tracks sentiment changes over time with AI",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["create", "list", "delete", "pause", "resume"], description: "Action to perform" },
+          id: { type: "string", description: "Watcher ID (for delete/pause/resume)" },
+          watcher_type: { type: "string", enum: ["price_level", "price_change", "market_scan", "news_intelligence", "crypto_price", "resolution_watch", "portfolio_drift", "volume_surge", "geopolitical", "cross_signal", "arbitrage_scan", "sentiment_shift"], description: "Type of watcher" },
+          name: { type: "string", description: "Friendly name for the watcher" },
+          config: { type: "object", description: "Watcher configuration (varies by type)" },
+          interval_minutes: { type: "number", description: "Check interval in minutes" }
+        },
+        required: ["action"]
+      },
+      handler: async (args) => {
+        const edb = deps.db.getEngineDB?.();
+        if (!edb) return { error: "Database not available" };
+        if (args.action === "list") {
+          const rows = await edb.all(`SELECT * FROM poly_watchers WHERE agent_id = ? ORDER BY created_at DESC`, [deps.agentId]) || [];
+          return { watchers: rows.map((r) => ({ ...r, config: JSON.parse(r.config || "{}") })) };
+        }
+        if (args.action === "create") {
+          if (!args.watcher_type) return { error: "watcher_type required" };
+          const defaultIntervals = {
+            price_level: 3e4,
+            price_change: 6e4,
+            market_scan: 3e5,
+            news_intelligence: 3e5,
+            crypto_price: 12e4,
+            resolution_watch: 9e5,
+            portfolio_drift: 6e4,
+            volume_surge: 3e5,
+            geopolitical: 6e5,
+            cross_signal: 3e5,
+            arbitrage_scan: 6e5,
+            sentiment_shift: 9e5
+          };
+          const intervalMs = args.interval_minutes ? args.interval_minutes * 6e4 : defaultIntervals[args.watcher_type] || 6e4;
+          const id = crypto.randomUUID();
+          await edb.run(
+            `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+            [id, deps.agentId, args.watcher_type, args.name || args.watcher_type, JSON.stringify(args.config || {}), intervalMs]
+          );
+          const needsAI = ["news_intelligence", "geopolitical", "cross_signal", "sentiment_shift"].includes(args.watcher_type);
+          let aiNote = "";
+          if (needsAI) {
+            const aiCfg = await getAIConfig(deps.agentId, edb);
+            if (!aiCfg) {
+              aiNote = "\n\u26A0\uFE0F AI analysis NOT configured. This watcher requires an AI model. Run poly_watcher_config to set up a model (e.g., Grok for real-time X/Twitter intelligence, GPT-4o-mini for cheap analysis).";
+            }
+          }
+          return { success: true, id, interval_seconds: intervalMs / 1e3, requires_ai: needsAI, message: `Watcher '${args.name || args.watcher_type}' created.${aiNote}` };
+        }
+        if (args.action === "delete") {
+          if (!args.id) return { error: "id required" };
+          await edb.run(`DELETE FROM poly_watchers WHERE id = ? AND agent_id = ?`, [args.id, deps.agentId]);
+          return { success: true };
+        }
+        if (args.action === "pause" || args.action === "resume") {
+          if (!args.id) return { error: "id required" };
+          await edb.run(
+            `UPDATE poly_watchers SET status = ? WHERE id = ? AND agent_id = ?`,
+            [args.action === "pause" ? "paused" : "active", args.id, deps.agentId]
+          );
+          return { success: true, status: args.action === "pause" ? "paused" : "active" };
+        }
+        return { error: "Unknown action: " + args.action };
+      }
+    },
+    {
+      name: "poly_watcher_config",
+      description: "Configure the AI model used for background market analysis. The watcher engine uses a separate, cheap model for continuous intelligence gathering.\n\nRecommended models:\n- xai/grok-3-mini: Best for real-time analysis (has X/Twitter access)\n- openai/gpt-4o-mini: Cheap, fast, good general analysis\n- groq/llama-3.3-70b-versatile: Free tier available, fast\n- deepseek/deepseek-chat: Very cheap, good reasoning\n\nActions:\n- get: View current config\n- set: Update config\n- stats: View analysis budget usage",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["get", "set", "stats"], description: "Action to perform" },
+          ai_provider: { type: "string", enum: ["xai", "openai", "groq", "cerebras", "together", "openrouter", "deepseek", "fireworks"], description: "AI provider" },
+          ai_model: { type: "string", description: "Model ID (e.g., grok-3-mini, gpt-4o-mini, llama-3.3-70b-versatile)" },
+          ai_api_key: { type: "string", description: "API key for the AI provider" },
+          analysis_budget_daily: { type: "number", description: "Max AI analysis calls per day (default: 100)" },
+          max_spawn_per_hour: { type: "number", description: "Max agent session spawns per hour (default: 6)" }
+        },
+        required: ["action"]
+      },
+      handler: async (args) => {
+        const edb = deps.db.getEngineDB?.();
+        if (!edb) return { error: "Database not available" };
+        if (args.action === "get") {
+          const cfg = await edb.get(`SELECT * FROM poly_watcher_config WHERE agent_id = ?`, [deps.agentId]);
+          if (!cfg) return { configured: false, message: "No AI config set. Run poly_watcher_config action=set to configure a model for background analysis." };
+          return {
+            configured: true,
+            provider: cfg.ai_provider,
+            model: cfg.ai_model,
+            has_api_key: !!cfg.ai_api_key,
+            budget_daily: cfg.analysis_budget_daily,
+            used_today: cfg.analysis_count_today,
+            remaining_today: (cfg.analysis_budget_daily || 100) - (cfg.analysis_count_today || 0),
+            max_spawn_per_hour: cfg.max_spawn_per_hour
+          };
+        }
+        if (args.action === "set") {
+          const existing = await edb.get(`SELECT * FROM poly_watcher_config WHERE agent_id = ?`, [deps.agentId]);
+          if (existing) {
+            const updates = [];
+            const vals = [];
+            if (args.ai_provider) {
+              updates.push("ai_provider = ?");
+              vals.push(args.ai_provider);
+            }
+            if (args.ai_model) {
+              updates.push("ai_model = ?");
+              vals.push(args.ai_model);
+            }
+            if (args.ai_api_key) {
+              updates.push("ai_api_key = ?");
+              vals.push(args.ai_api_key);
+            }
+            if (args.analysis_budget_daily) {
+              updates.push("analysis_budget_daily = ?");
+              vals.push(args.analysis_budget_daily);
+            }
+            if (args.max_spawn_per_hour) {
+              updates.push("max_spawn_per_hour = ?");
+              vals.push(args.max_spawn_per_hour);
+            }
+            updates.push("updated_at = CURRENT_TIMESTAMP");
+            vals.push(deps.agentId);
+            await edb.run(`UPDATE poly_watcher_config SET ${updates.join(", ")} WHERE agent_id = ?`, vals);
+          } else {
+            await edb.run(
+              `INSERT INTO poly_watcher_config (agent_id, ai_provider, ai_model, ai_api_key, analysis_budget_daily, max_spawn_per_hour) VALUES (?, ?, ?, ?, ?, ?)`,
+              [deps.agentId, args.ai_provider || "xai", args.ai_model || "grok-3-mini", args.ai_api_key || "", args.analysis_budget_daily || 100, args.max_spawn_per_hour || 6]
+            );
+          }
+          return { success: true, message: `AI config updated. Provider: ${args.ai_provider || "xai"}, Model: ${args.ai_model || "grok-3-mini"}. Background analysis is now enabled.` };
+        }
+        if (args.action === "stats") {
+          const cfg = await edb.get(`SELECT * FROM poly_watcher_config WHERE agent_id = ?`, [deps.agentId]);
+          const totalAnalyses = await edb.get(`SELECT COUNT(*) as cnt FROM poly_analysis_cache`).catch(() => ({ cnt: 0 }));
+          const sentimentRecords = await edb.get(`SELECT COUNT(*) as cnt FROM poly_sentiment_history WHERE agent_id = ?`, [deps.agentId]).catch(() => ({ cnt: 0 }));
+          const signalBuffer = await edb.get(`SELECT COUNT(*) as cnt FROM poly_signal_buffer WHERE agent_id = ?`, [deps.agentId]).catch(() => ({ cnt: 0 }));
+          return {
+            provider: cfg?.ai_provider || "not configured",
+            model: cfg?.ai_model || "not configured",
+            budget_daily: cfg?.analysis_budget_daily || 0,
+            used_today: cfg?.analysis_count_today || 0,
+            cached_analyses: totalAnalyses?.cnt || 0,
+            sentiment_records: sentimentRecords?.cnt || 0,
+            active_signals: signalBuffer?.cnt || 0,
+            engine_total_analyses: _engineAnalysisCount
+          };
+        }
+        return { error: "Unknown action" };
+      }
+    },
+    {
+      name: "poly_watcher_events",
+      description: "Check automation signals generated by your watchers. ALWAYS check this at the start of every session.\n\nActions:\n- check: Get unacknowledged signals (most important)\n- list: Get all recent signals\n- acknowledge: Mark a signal as read\n- acknowledge_all: Mark all as read",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["check", "list", "acknowledge", "acknowledge_all"] },
+          id: { type: "string", description: "Event ID (for acknowledge)" },
+          severity: { type: "string", enum: ["critical", "warning", "info"] },
+          limit: { type: "number", description: "Max events (default: 50)" }
+        },
+        required: ["action"]
+      },
+      handler: async (args) => {
+        const edb = deps.db.getEngineDB?.();
+        if (!edb) return { error: "Database not available" };
+        if (args.action === "check") {
+          const events = await edb.all(
+            `SELECT * FROM poly_watcher_events WHERE agent_id = ? AND acknowledged = 0 ORDER BY severity DESC, created_at DESC LIMIT ?`,
+            [deps.agentId, args.limit || 50]
+          ) || [];
+          const critical = events.filter((e) => e.severity === "critical").length;
+          const warning = events.filter((e) => e.severity === "warning").length;
+          return {
+            total_unread: events.length,
+            critical,
+            warning,
+            events: events.map((e) => ({ ...e, data: JSON.parse(e.data || "{}") })),
+            summary: events.length === 0 ? "No new signals. All clear." : `${events.length} unread (${critical} critical, ${warning} warning). Review critical signals immediately.`
+          };
+        }
+        if (args.action === "list") {
+          let sql = `SELECT * FROM poly_watcher_events WHERE agent_id = ?`;
+          const params = [deps.agentId];
+          if (args.severity) {
+            sql += ` AND severity = ?`;
+            params.push(args.severity);
+          }
+          sql += ` ORDER BY created_at DESC LIMIT ?`;
+          params.push(args.limit || 50);
+          const events = await edb.all(sql, params) || [];
+          return { events: events.map((e) => ({ ...e, data: JSON.parse(e.data || "{}") })) };
+        }
+        if (args.action === "acknowledge") {
+          if (!args.id) return { error: "id required" };
+          await edb.run(`UPDATE poly_watcher_events SET acknowledged = 1 WHERE id = ? AND agent_id = ?`, [args.id, deps.agentId]);
+          return { success: true };
+        }
+        if (args.action === "acknowledge_all") {
+          await edb.run(`UPDATE poly_watcher_events SET acknowledged = 1 WHERE agent_id = ? AND acknowledged = 0`, [deps.agentId]);
+          return { success: true };
+        }
+        return { error: "Unknown action" };
+      }
+    },
+    {
+      name: "poly_setup_monitors",
+      description: "Quick setup: Create a comprehensive monitoring suite for your trading operation. Sets up price alerts, AI news intelligence, geopolitical scanner, cross-signal correlation, and more.\n\nRequires: AI config (run poly_watcher_config first to set up a model).",
+      parameters: {
+        type: "object",
+        properties: {
+          keywords: { type: "array", items: { type: "string" }, description: 'Keywords to monitor (e.g. ["bitcoin", "trump", "fed", "ukraine"])' },
+          regions: { type: "array", items: { type: "string" }, description: "Geopolitical regions to watch (default: major powers)" },
+          crypto_threshold_pct: { type: "number", description: "Crypto change % to alert (default: 3)" },
+          portfolio_drift_pct: { type: "number", description: "Portfolio P&L % to alert (default: 5)" },
+          sentiment_topics: { type: "array", items: { type: "string" }, description: 'Topics to track sentiment shifts (e.g. ["bitcoin", "fed policy"])' }
+        },
+        required: []
+      },
+      handler: async (args) => {
+        const edb = deps.db.getEngineDB?.();
+        if (!edb) return { error: "Database not available" };
+        const created = [];
+        const mkId = () => crypto.randomUUID();
+        const aiCfg = await getAIConfig(deps.agentId, edb);
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "crypto_price", "BTC/ETH Tracker", JSON.stringify({
+            symbols: ["bitcoin", "ethereum"],
+            pct_threshold: args.crypto_threshold_pct || 3
+          }), 12e4]
+        );
+        created.push("BTC/ETH price tracker (2m interval, \xB1" + (args.crypto_threshold_pct || 3) + "%)");
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "resolution_watch", "Expiring Markets", JSON.stringify({ hours_before: 48 }), 9e5]
+        );
+        created.push("Resolution watcher (15m interval, 48h horizon)");
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "portfolio_drift", "Portfolio P&L Alert", JSON.stringify({
+            pnl_threshold_pct: args.portfolio_drift_pct || 5
+          }), 6e4]
+        );
+        created.push("Portfolio drift alert (1m interval, \xB1" + (args.portfolio_drift_pct || 5) + "%)");
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "arbitrage_scan", "Arbitrage Scanner", JSON.stringify({ min_edge_pct: 2 }), 6e5]
+        );
+        created.push("Arbitrage scanner (10m interval, \u22652% edge)");
+        if (args.keywords?.length) {
+          await edb.run(
+            `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+            [mkId(), deps.agentId, "news_intelligence", "AI News Scanner", JSON.stringify({
+              keywords: args.keywords,
+              watched_markets: args.keywords
+            }), 3e5]
+          );
+          created.push("AI news intelligence (5m interval, keywords: " + args.keywords.join(", ") + ")" + (!aiCfg ? " \u26A0\uFE0F AI not configured" : ""));
+        }
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "geopolitical", "Geopolitical Scanner", JSON.stringify({
+            regions: args.regions || ["us", "china", "russia", "ukraine", "iran", "israel", "north korea"],
+            topics: ["sanctions", "military", "trade war", "election", "tariff", "nato", "diplomacy", "war", "attack"],
+            watched_markets: args.keywords || []
+          }), 6e5]
+        );
+        created.push("Geopolitical scanner (10m interval)" + (!aiCfg ? " \u26A0\uFE0F AI not configured" : ""));
+        await edb.run(
+          `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+          [mkId(), deps.agentId, "cross_signal", "Signal Correlator", JSON.stringify({
+            min_signals: 3,
+            correlation_window_hours: 2
+          }), 3e5]
+        );
+        created.push("Cross-signal correlator (5m interval, min 3 signals)" + (!aiCfg ? " \u26A0\uFE0F AI not configured" : ""));
+        const sentimentTopics = args.sentiment_topics || args.keywords?.slice(0, 3) || [];
+        for (const topic of sentimentTopics) {
+          await edb.run(
+            `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+            [mkId(), deps.agentId, "sentiment_shift", "Sentiment: " + topic, JSON.stringify({
+              topic,
+              keywords: [topic],
+              shift_threshold: 0.3
+            }), 9e5]
+          );
+          created.push('Sentiment tracker: "' + topic + '" (15m interval)' + (!aiCfg ? " \u26A0\uFE0F AI not configured" : ""));
+        }
+        const positions = await edb.all(
+          `SELECT * FROM poly_paper_positions WHERE agent_id = ? AND closed = 0`,
+          [deps.agentId]
+        ).catch(() => []) || [];
+        for (const p of positions) {
+          const entry = p.entry_price || 0;
+          if (!entry || !p.token_id) continue;
+          await edb.run(
+            `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+            [mkId(), deps.agentId, "price_level", "SL: " + (p.market_question || p.token_id).slice(0, 30), JSON.stringify({
+              token_id: p.token_id,
+              direction: p.side === "BUY" ? "below" : "above",
+              threshold: p.side === "BUY" ? entry * 0.85 : entry * 1.15,
+              market_question: p.market_question
+            }), 3e4]
+          );
+          await edb.run(
+            `INSERT INTO poly_watchers (id, agent_id, type, name, config, interval_ms) VALUES (?, ?, ?, ?, ?, ?)`,
+            [mkId(), deps.agentId, "price_level", "TP: " + (p.market_question || p.token_id).slice(0, 30), JSON.stringify({
+              token_id: p.token_id,
+              direction: p.side === "BUY" ? "above" : "below",
+              threshold: p.side === "BUY" ? entry * 1.25 : entry * 0.75,
+              market_question: p.market_question
+            }), 3e4]
+          );
+          created.push("SL/TP: " + (p.market_question || p.token_id).slice(0, 40));
+        }
+        return {
+          success: true,
+          monitors_created: created.length,
+          ai_configured: !!aiCfg,
+          details: created,
+          message: `\u2705 ${created.length} monitors active.${!aiCfg ? "\n\n\u26A0\uFE0F AI analysis not configured. AI-powered watchers (news, geopolitical, correlation, sentiment) will run WITHOUT intelligence. Run poly_watcher_config action=set to enable AI analysis." : " AI intelligence enabled (" + aiCfg.provider + "/" + aiCfg.model + ")."}`
+        };
+      }
+    }
+  ];
+}
+
+export {
+  initWatcherTables,
+  getAIConfig,
+  analyzeWithAI,
+  getWatcherEngineStatus,
+  startWatcherEngine,
+  setWatcherRuntime,
+  controlWatcherEngine,
+  stopWatcherEngine,
+  createWatcherTools
+};