@senpi/runtime 3.0.0-dev.runtime-phase-2.20260623210537 → 3.0.0-dev.runtime-phase-2.20260625112547

package/examples/strategies/turbine/scanners/scoring.py

@@ -0,0 +1,190 @@
+"""TURBINE — pure rotation/direction/spread functions (port of turbine-producer.py v3.2.2).
+
+Ported VERBATIM from senpi-skills/turbine/scripts/turbine-producer.py (choose_direction,
+pick_rotation_asset, spread parsing) and turbine_config.py (normalize_coin_key). No I/O, no
+MCP, no daemon — pure and unit-testable. `scan.py` fetches per-asset market data via
+ctx.senpi_mcp and hands it to these helpers.
+
+Both turbine legs (volume + runners) share THIS scoring module: the source ran the identical
+volume-rotation alpha on both wallets and let the wallet boundary (DSL preset + sizing) select
+behavior. So there is no per-leg branch here — only sizing/exit differ, and those live in the
+recipe YAMLs, not in the signal logic.
+
+Source thresholds preserved exactly:
+  - Universe MAIN = [BTC, ETH, SOL, HYPE]; XYZ = [xyz:BRENTOIL, xyz:GOLD, xyz:SPX].
+  - Direction = funding fade: LONG_CROWDED/LONG_HEAVY -> SHORT (funding_fade_short),
+    SHORT_CROWDED/SHORT_HEAVY -> LONG (funding_fade_long), else random LONG/SHORT
+    (alternate_neutral).
+  - Rotation: probabilistic pool pick (random.random() < xyz_weight -> XYZ pool, else MAIN),
+    then a deterministic rotation index inside the pool; skip held + 90s post-close cooldown;
+    fall through to the OTHER pool if the chosen one is exhausted.
+  - Spread gate: main <= spread_main_bps (3), xyz <= spread_xyz_bps (10). spread_bps from the
+    top-of-book mid: ((ask - bid) / mid) * 10000.
+"""
+
+import random
+import time
+
+
+# ── Universe (shared by both wallets) ──
+
+VOLUME_XYZ = ["xyz:BRENTOIL", "xyz:GOLD", "xyz:SPX"]
+VOLUME_MAIN = ["BTC", "ETH", "SOL", "HYPE"]
+
+POST_CLOSE_COOLDOWN_SECONDS = 90
+
+
+def is_xyz(asset):
+    return asset.startswith("xyz:")
+
+
+def normalize_coin_key(coin):
+    """Canonicalize a coin string for held_keys / cooldown sets.
+
+    Port of turbine_config.normalize_coin_key (v3.2.2): preserve the xyz: prefix so that
+    main:HYPE and xyz:HYPE are distinct slot occupiers. Lowercase the prefix, uppercase the
+    symbol; bare symbols are uppercased.
+    """
+    if not coin:
+        return ""
+    s = coin.strip()
+    if ":" in s:
+        prefix, _, symbol = s.partition(":")
+        return f"{prefix.lower()}:{symbol.upper()}"
+    return s.upper()
+
+
+def safe_float(v, d=0.0):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return d
+
+
+# ── Direction: funding fade (verbatim from producer.choose_direction) ──
+
+def choose_direction(regime, rng=random):
+    """Funding fade. Crowded longs -> SHORT, crowded shorts -> LONG, flat -> coin flip.
+
+    Returns (direction, thesis). `rng` is injectable for deterministic tests; the source used
+    the module-level `random`.
+    """
+    r = (regime or "").upper()
+    if r in ("LONG_CROWDED", "LONG_HEAVY"):
+        return "SHORT", "funding_fade_short"
+    if r in ("SHORT_CROWDED", "SHORT_HEAVY"):
+        return "LONG", "funding_fade_long"
+    return rng.choice(["LONG", "SHORT"]), "alternate_neutral"
+
+
+# ── Spread parsing (verbatim from producer.query_asset_data) ──
+
+def _lvl_px(lvl):
+    if isinstance(lvl, dict):
+        return safe_float(lvl.get("px", lvl.get("price", 0)))
+    if isinstance(lvl, list) and lvl:
+        return safe_float(lvl[0])
+    return 0.0
+
+
+def parse_asset_data(resp):
+    """Extract bid/ask/mid/spread_bps + funding regime from a market_get_asset_data response.
+
+    Returns a dict or None when the order book is missing / one-sided / non-positive (the
+    source treated all of these as 'skip this asset'). Mirrors producer.query_asset_data
+    exactly: top-of-book levels, mid = (bid+ask)/2, spread_bps = ((ask-bid)/mid)*10000.
+    """
+    if not resp or not isinstance(resp, dict):
+        return None
+    ad = resp.get("data", resp)
+    if not isinstance(ad, dict):
+        return None
+    ob = ad.get("order_book") or ad.get("orderBook") or {}
+    levels = ob.get("levels", [])
+    if not isinstance(levels, list) or len(levels) < 2:
+        return None
+    bids, asks = levels[0], levels[1]
+    if not bids or not asks:
+        return None
+    bid = _lvl_px(bids[0])
+    ask = _lvl_px(asks[0])
+    if bid <= 0 or ask <= 0:
+        return None
+    mid = (bid + ask) / 2.0
+    spread_bps = ((ask - bid) / mid) * 10000 if mid > 0 else 999
+
+    funding_regime = (
+        ad.get("funding_regime") or ad.get("fundingRegime") or "UNKNOWN"
+    ).upper()
+    funding_annualized_pct = safe_float(
+        ad.get("funding_annualized_pct") or ad.get("fundingAnnualizedPct") or 0
+    )
+    return {
+        "bid": bid,
+        "ask": ask,
+        "mid": mid,
+        "spread_bps": round(spread_bps, 3),
+        "funding_regime": funding_regime,
+        "funding_annualized_pct": funding_annualized_pct,
+    }
+
+
+def spread_ok(asset, spread_bps, spread_main_bps, spread_xyz_bps):
+    """Spread gate: xyz assets get the wider xyz cap, everything else the main cap."""
+    max_spread = spread_xyz_bps if is_xyz(asset) else spread_main_bps
+    return spread_bps <= max_spread
+
+
+# ── Rotation pick (verbatim from producer.pick_rotation_asset) ──
+
+def pick_rotation_asset(rot_idx, xyz_weight, held_set, last_closed, now=None, rng=random):
+    """Pick the next rotation asset.
+
+    Probabilistic pool pick (random.random() < xyz_weight -> XYZ pool, else MAIN) + a
+    deterministic rotation index inside the chosen pool. Skips assets already held and assets
+    closed within POST_CLOSE_COOLDOWN_SECONDS (90s). Falls through to the OTHER pool if the
+    chosen one is exhausted. Returns (asset|None, new_rot_idx).
+
+    `now`/`rng` are injectable for deterministic tests; the source used time.time() / random.
+    """
+    if now is None:
+        now = time.time()
+
+    def _try_pool(pool, idx):
+        n = len(pool)
+        for _ in range(n):
+            candidate = pool[idx % n]
+            idx = (idx + 1) % n
+            coin_key = normalize_coin_key(candidate)
+            if coin_key in held_set:
+                continue
+            last = last_closed.get(coin_key, {})
+            if last and (now - last.get("ts", 0)) < POST_CLOSE_COOLDOWN_SECONDS:
+                continue
+            return candidate, idx
+        return None, idx
+
+    use_xyz = rng.random() < xyz_weight
+    pool = VOLUME_XYZ if use_xyz else VOLUME_MAIN
+    asset, rot_idx = _try_pool(pool, rot_idx)
+    if asset is not None:
+        return asset, rot_idx
+
+    other = VOLUME_MAIN if use_xyz else VOLUME_XYZ
+    asset, rot_idx = _try_pool(other, rot_idx)
+    return asset, rot_idx
+
+
+def clamp_leverage(desired, venue_max):
+    """Clamp desired leverage to the asset's Hyperliquid venue max.
+
+    Turbine's source used a fixed 5x and relied on the runtime to clamp per-asset. We carry the
+    same defensive clamp the spider port uses so a low-venue-cap asset never over-levers.
+    """
+    try:
+        venue = int(venue_max)
+    except (TypeError, ValueError):
+        venue = desired
+    if venue <= 0:
+        venue = desired
+    return max(1, min(int(desired), venue))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senpi/runtime",
-  "version": "3.0.0-dev.runtime-phase-2.20260623210537",
+  "version": "3.0.0-dev.runtime-phase-2.20260625112547",
   "description": "Senpi runtime plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",

package/dist/scanners/external/liquidation-watchdog/README.md

@@ -1,107 +0,0 @@
-# External liquidation-watchdog producer
-
-A real, standalone watchdog scanner that runs as an external producer:
-
-1. Pulls clearinghouse state from the live Senpi MCP server.
-2. Computes margin / liquidation-distance / ROE alerts using a self-contained
-   port of the watchdog logic (no dependency on the runtime's internal
-   `liquidationWatchdogScanner`).
-3. Pushes resulting signals into a running runtime via
-   `openclaw senpi external-scanner ingest` (gateway RPC `senpi.ingestExternalScannerData`).
-
-## Files
-
-- `recipe.yaml` — runtime recipe declaring the matching `external_scanner`
-  (`external_liquidation_watchdog`) and a downstream LLM action wired to
-  `{{signal_external_liquidation_watchdog}}`.
-- `producer.mjs` — the external producer entrypoint.
-
-## Prereqs
-
-1. Build the project so the MCP provider bridge is available:
-   ```bash
-   npm run build
-   ```
-2. Install the runtime from `recipe.yaml` for your strategy wallet and start it:
-   ```bash
-   openclaw senpi runtime create -p src/scanners/external/liquidation-watchdog/recipe.yaml
-   ```
-3. Ensure `openclaw` is on `PATH` and authenticated against the host running
-   that runtime.
-4. Export Senpi MCP credentials and the target wallet:
-   ```bash
-   export SENPI_API_KEY="..."
-   export SENPI_MCP_URL="https://mcp.prod.senpi.ai/mcp"
-   export STRATEGY_ADDRESS="0x..."
-   ```
-
-## Run
-
-```bash
-node src/scanners/external/liquidation-watchdog/producer.mjs
-```
-
-The producer fetches one clearinghouse snapshot, derives signals, and pushes
-them. It exits non-zero on any rejection or signal-count mismatch. Re-run
-(or wrap in `watch`/cron) for continuous monitoring.
-
-## Env
-
-| Var | Default | Purpose |
-|---|---|---|
-| `SENPI_API_KEY` | _required_ | Senpi MCP auth |
-| `SENPI_MCP_URL` | _required_ | Senpi MCP endpoint |
-| `STRATEGY_ADDRESS` | _required_ | Target wallet — must match the installed runtime |
-| `EXTERNAL_SCANNER_NAME` | `external_liquidation_watchdog` | Must match `scanners[].name` in the recipe |
-| `OPENCLAW_BIN` | `openclaw` | Path/name of the OpenClaw CLI binary |
-| `BUFFER_WARNING_PCT` | `50` | Margin buffer % below which a WARNING alert fires |
-| `BUFFER_CRITICAL_PCT` | `30` | Margin buffer % below which CRITICAL + WATCHDOG_CLOSE fire |
-| `LIQ_DISTANCE_WARNING_PCT` | `30` | Per-position liq distance % warning threshold |
-| `ROE_DANGER_PCT` | `-15` | ROE % below which a position is flagged |
-
-## Expected response
-
-```json
-{
-  "accepted": true,
-  "address": "0x...",
-  "scanner": "external_liquidation_watchdog",
-  "timestamp": 1775680200000,
-  "signalCount": 3,
-  "contextUpdated": false
-}
-```
-
-## Live test: force a watchdog close
-
-To verify the end-to-end close path on a real open position, loosen the
-producer thresholds so any healthy position trips `WATCHDOG_CLOSE`. The
-shipped `recipe.yaml` intentionally has no `exit.dsl` block, so the watchdog
-is the only exit path — a close is unambiguously attributable to the producer.
-
-```bash
-BUFFER_WARNING_PCT=99 \
-BUFFER_CRITICAL_PCT=95 \
-LIQ_DISTANCE_WARNING_PCT=99 \
-ROE_DANGER_PCT=100 \
-node src/scanners/external/liquidation-watchdog/producer.mjs
-```
-
-Expect `accepted: true` with `signalCount >= 1` and the `watchdog_close`
-action firing on the runtime. Revert the env values (and re-add a DSL preset)
-before running unattended — without DSL, nothing else will close a position
-between producer runs.
-
-## Manual e2e checklist
-
-- Happy path: live wallet with healthy positions → producer prints `0` signals
-  and skips the ingest.
-- Triggered path: wallet with a tight liq distance or low buffer → producer
-  emits `WATCHDOG_ALERT` (and `WATCHDOG_CLOSE` for critical buffer); gateway
-  returns `accepted: true` with matching `signalCount`.
-- Unknown wallet: change `STRATEGY_ADDRESS` to a wallet without an installed
-  runtime → expect `NOT_FOUND`.
-- Disabled scanner: stop the runtime or rename the scanner in the recipe →
-  expect `INVALID_REQUEST`.
-- Schema rejection: edit `toExternalBatchItem` in `producer.mjs` to drop
-  `sourceMeta` → expect a validation `INVALID_REQUEST`.

package/dist/scanners/external/liquidation-watchdog/liquidation-watchdog.yaml

@@ -1,48 +0,0 @@
-name: external-liquidation-watchdog
-version: 1.0.0
-description: >
-  External producer variant of the liquidation watchdog. Margin / liq-distance /
-  ROE alerts are computed by an out-of-process producer (see producer.mjs) and
-  pushed in via senpi.ingestExternalScannerData. Watchdog signals drive an
-  emergency CLOSE_POSITION; DSL handles normal trailing exits.
-
-strategy:
-  wallet: "${WALLET_ADDRESS}"
-  budget: 1000
-  slots: 3
-  margin_per_slot: 300
-  trading_risk: moderate
-  enabled: true
-
-scanners:
-  # External scanner: signals are pushed by producer.mjs, no internal interval.
-  # `fields` documents the payload shape the gateway will accept from the producer.
-  - name: external_liquidation_watchdog
-    type: external_scanner
-    outputs:
-      signals: true
-      context: false
-    config:
-      fields:
-        sourceScannerId: { type: string, required: true }
-        sourceSignalType: { type: string, required: true }
-        sourceTimestamp: { type: number, required: true }
-        sourceFactors: { type: object, required: true }
-        sourceMeta: { type: object, required: true }
-
-actions:
-  # Emergency close on margin danger — rule-based, no LLM in the hot path.
-  - name: watchdog_close
-    action_type: CLOSE_POSITION
-    decision_mode: rule
-    scanners: [external_liquidation_watchdog]
-    min_confidence: 1
-
-# ── NOTIFICATIONS ──
-notifications:
-  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
-
-
-# No `exit:` block: for a live test we want the external watchdog to be the
-# ONLY exit path, so a triggered close is unambiguously attributable to the
-# producer. Re-add a DSL preset before running this recipe unattended.

package/dist/scanners/external/liquidation-watchdog/producer.mjs

@@ -1,336 +0,0 @@
-/**
- * External liquidation-watchdog producer.
- *
- * A real, standalone watchdog scanner that:
- *   1. Pulls clearinghouse state + active positions from the live Senpi MCP server.
- *   2. Computes margin/liquidation/ROE alerts using the migrated watchdog logic
- *      below (no dependency on the runtime's internal scanner).
- *   3. Pushes resulting signals into a running runtime via the
- *      `openclaw senpi external-scanner ingest` CLI command.
- *
- * Prereqs:
- *   - `npm run build` so dist/ is current (used only for the MCP provider bridge).
- *   - A runtime installed from ./recipe.yaml is running for STRATEGY_ADDRESS.
- *   - `openclaw` CLI on PATH and authenticated against that runtime.
- *   - SENPI_API_KEY and SENPI_MCP_URL env vars set.
- *
- * Run:  node src/scanners/external/liquidation-watchdog/producer.mjs
- */
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { createSenpiScannerProviders } from "../../../../dist/scanners/index.js";
-import { pushScannerSignals } from "../shared/ingest.mjs";
-
-// ─── Config ─────────────────────────────────────────────────────────────────
-
-const SENPI_API_KEY = process.env.SENPI_API_KEY;
-const SENPI_MCP_URL = process.env.SENPI_MCP_URL;
-const STRATEGY_ADDRESS = process.env.STRATEGY_ADDRESS;
-const SCANNER_NAME =
-  process.env.EXTERNAL_SCANNER_NAME ?? "external_liquidation_watchdog";
-const OPENCLAW_BIN = process.env.OPENCLAW_BIN ?? "openclaw";
-const SCANNER_ID = "external-liquidation-watchdog-producer";
-
-const config = {
-  bufferWarningPct: numEnv("BUFFER_WARNING_PCT", 50),
-  bufferCriticalPct: numEnv("BUFFER_CRITICAL_PCT", 30),
-  liqDistanceWarningPct: numEnv("LIQ_DISTANCE_WARNING_PCT", 30),
-  roeDangerPct: numEnv("ROE_DANGER_PCT", -15),
-};
-
-if (!SENPI_API_KEY || !SENPI_MCP_URL || !STRATEGY_ADDRESS) {
-  console.error(
-    "Missing required env vars. Set SENPI_API_KEY, SENPI_MCP_URL, and STRATEGY_ADDRESS.\n" +
-      "  export SENPI_API_KEY='...'\n" +
-      "  export SENPI_MCP_URL='https://mcp.prod.senpi.ai/mcp'\n" +
-      "  export STRATEGY_ADDRESS='0x...'",
-  );
-  process.exit(1);
-}
-
-function numEnv(name, fallback) {
-  const raw = process.env[name];
-  if (raw === undefined || raw === "") return fallback;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Env ${name} must be a finite number, got "${raw}"`);
-  }
-  return parsed;
-}
-
-// ─── MCP → SenpiToolClient bridge ───────────────────────────────────────────
-
-function createSenpiToolClient(mcpClient) {
-  return {
-    async callTool(name, args) {
-      const result = await mcpClient.callTool({ name, arguments: args });
-
-      if (result.isError) {
-        const errorText =
-          Array.isArray(result.content) &&
-          result.content.length > 0 &&
-          result.content[0].type === "text"
-            ? result.content[0].text
-            : JSON.stringify(result.content);
-        throw new Error(`MCP tool "${name}" returned error: ${errorText}`);
-      }
-
-      if (result.structuredContent !== undefined) {
-        return result.structuredContent;
-      }
-
-      if (Array.isArray(result.content) && result.content.length > 0) {
-        const first = result.content[0];
-        if (first.type === "text") {
-          try {
-            return JSON.parse(first.text);
-          } catch {
-            return first.text;
-          }
-        }
-      }
-
-      return result.content;
-    },
-  };
-}
-
-// ─── Migrated watchdog logic ────────────────────────────────────────────────
-// Ported from src/scanners/implementations/liquidation-watchdog.ts.
-// Kept self-contained so this producer has no dependency on the internal
-// scanner implementation.
-
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
-function resolveDirection(szi) {
-  return szi >= 0 ? "LONG" : "SHORT";
-}
-
-function computeMarkPrice(position) {
-  if (position.szi === 0) return position.entryPx;
-  return position.entryPx + position.unrealizedPnl / position.szi;
-}
-
-function normalizeRoe(returnOnEquity) {
-  return returnOnEquity * 100;
-}
-
-function normalizeWatchdogPosition(position) {
-  return {
-    asset: position.coin,
-    direction: resolveDirection(position.szi),
-    size: Math.abs(position.szi),
-    entryPrice: position.entryPx,
-    markPrice: computeMarkPrice(position),
-    liquidationPrice: position.liquidationPx,
-    unrealizedPnl: position.unrealizedPnl,
-    roe: normalizeRoe(position.returnOnEquity),
-    leverage: position.leverage,
-  };
-}
-
-function computeMarginBuffer(accountValue, withdrawable) {
-  if (accountValue <= 0) return 0;
-  return (withdrawable / accountValue) * 100;
-}
-
-function computeLiqDistance(markPrice, liqPrice, direction) {
-  if (liqPrice === null || liqPrice === undefined) return null;
-  if (liqPrice <= 0 || markPrice <= 0) return null;
-  if (direction === "LONG") {
-    return ((markPrice - liqPrice) / markPrice) * 100;
-  }
-  return ((liqPrice - markPrice) / markPrice) * 100;
-}
-
-function analyzeMarginHealth(chState, cfg) {
-  const alerts = [];
-  let lowestRoePosition = null;
-  let lowestRoe = Infinity;
-
-  const buffer = computeMarginBuffer(chState.accountValue, chState.withdrawable);
-
-  if (buffer < cfg.bufferCriticalPct) {
-    alerts.push({
-      level: "CRITICAL",
-      message: `Margin buffer CRITICAL: ${buffer.toFixed(1)}% (threshold: ${cfg.bufferCriticalPct}%)`,
-      value: buffer,
-      threshold: cfg.bufferCriticalPct,
-    });
-  } else if (buffer < cfg.bufferWarningPct) {
-    alerts.push({
-      level: "WARNING",
-      message: `Margin buffer WARNING: ${buffer.toFixed(1)}% (threshold: ${cfg.bufferWarningPct}%)`,
-      value: buffer,
-      threshold: cfg.bufferWarningPct,
-    });
-  }
-
-  for (const rawPosition of chState.positions ?? []) {
-    const pos = normalizeWatchdogPosition(rawPosition);
-
-    if (pos.roe < lowestRoe) {
-      lowestRoe = pos.roe;
-      lowestRoePosition = pos;
-    }
-
-    const liqDist = computeLiqDistance(
-      pos.markPrice,
-      pos.liquidationPrice,
-      pos.direction,
-    );
-    if (liqDist !== null && liqDist < cfg.liqDistanceWarningPct) {
-      alerts.push({
-        level: liqDist < cfg.liqDistanceWarningPct / 2 ? "CRITICAL" : "WARNING",
-        message: `Liquidation distance ${pos.asset} ${pos.direction}: ${liqDist.toFixed(1)}% (threshold: ${cfg.liqDistanceWarningPct}%)`,
-        asset: pos.asset,
-        value: liqDist,
-        threshold: cfg.liqDistanceWarningPct,
-      });
-    }
-
-    if (pos.roe < cfg.roeDangerPct) {
-      alerts.push({
-        level: "WARNING",
-        message: `ROE danger ${pos.asset}: ${pos.roe.toFixed(1)}% (threshold: ${cfg.roeDangerPct}%)`,
-        asset: pos.asset,
-        value: pos.roe,
-        threshold: cfg.roeDangerPct,
-      });
-    }
-  }
-
-  return { alerts, lowestRoePosition, marginBuffer: buffer };
-}
-
-function buildSignals({ chState, alerts, lowestRoePosition, marginBuffer, now }) {
-  const signals = [];
-
-  const hasCriticalBuffer = alerts.some(
-    (a) => a.level === "CRITICAL" && a.message.includes("Margin buffer"),
-  );
-
-  if (hasCriticalBuffer && lowestRoePosition) {
-    signals.push({
-      scannerId: SCANNER_ID,
-      signalType: "WATCHDOG_CLOSE",
-      asset: lowestRoePosition.asset,
-      direction: lowestRoePosition.direction,
-      score: clamp01(0.95),
-      timestamp: now,
-      factors: { critical_buffer: true, lowest_roe: true },
-      meta: {
-        reason: "critical_margin_buffer",
-        roe: lowestRoePosition.roe,
-        asset: lowestRoePosition.asset,
-        buffer: marginBuffer,
-        alerts: alerts.map((a) => a.message),
-      },
-    });
-  }
-
-  for (const alert of alerts) {
-    signals.push({
-      scannerId: SCANNER_ID,
-      signalType: "WATCHDOG_ALERT",
-      asset: alert.asset ?? "ACCOUNT",
-      direction: "LONG",
-      score: clamp01(alert.level === "CRITICAL" ? 0.9 : 0.5),
-      timestamp: now,
-      factors: {
-        critical: alert.level === "CRITICAL",
-        warning: alert.level === "WARNING",
-      },
-      meta: {
-        alertLevel: alert.level,
-        message: alert.message,
-        value: alert.value,
-        threshold: alert.threshold,
-      },
-    });
-  }
-
-  return signals;
-}
-
-// ─── Main ───────────────────────────────────────────────────────────────────
-
-async function main() {
-  console.log(`External watchdog producer`);
-  console.log(`  MCP:      ${SENPI_MCP_URL}`);
-  console.log(`  address:  ${STRATEGY_ADDRESS}`);
-  console.log(`  scanner:  ${SCANNER_NAME}`);
-  console.log(`  config:   ${JSON.stringify(config)}`);
-
-  const transport = new StreamableHTTPClientTransport(new URL(SENPI_MCP_URL), {
-    requestInit: { headers: { Authorization: `Bearer ${SENPI_API_KEY}` } },
-  });
-  const mcpClient = new Client({
-    name: "external-liquidation-watchdog",
-    version: "0.0.1",
-  });
-  await mcpClient.connect(transport);
-
-  const providers = createSenpiScannerProviders({
-    client: createSenpiToolClient(mcpClient),
-    logLevel: "warn",
-    cacheTtlMs: { instruments: 0, smData: 0, candles: 0 },
-    retries: 2,
-  });
-
-  try {
-    const chState = await providers.getClearingHouseState(STRATEGY_ADDRESS);
-    if (!chState) {
-      console.warn("Clearinghouse state unavailable — skipping ingest.");
-      return;
-    }
-
-    console.log(
-      `\nClearinghouse: accountValue=$${chState.accountValue}, ` +
-        `withdrawable=$${chState.withdrawable}, positions=${chState.positions?.length ?? 0}`,
-    );
-
-    const { alerts, lowestRoePosition, marginBuffer } = analyzeMarginHealth(
-      chState,
-      config,
-    );
-    const signals = buildSignals({
-      chState,
-      alerts,
-      lowestRoePosition,
-      marginBuffer,
-      now: Date.now(),
-    });
-
-    console.log(`\nAlerts: ${alerts.length}, Signals: ${signals.length}`);
-    for (const a of alerts) {
-      console.log(`  [${a.level}] ${a.message}`);
-    }
-
-    if (signals.length === 0) {
-      console.log("\nNothing to ingest — skipping gateway call.");
-      return;
-    }
-
-    const response = await pushScannerSignals({
-      address: STRATEGY_ADDRESS,
-      scanner: SCANNER_NAME,
-      signals,
-      openclawBin: OPENCLAW_BIN,
-    });
-    console.log("\nIngest response:", JSON.stringify(response));
-  } finally {
-    await transport.close();
-  }
-}
-
-main().catch((error) => {
-  console.error("\nProducer failed:", error.message ?? error);
-  process.exit(1);
-});