@senpi/runtime 3.0.0-dev.runtime-phase-2.20260623210537 → 3.0.1-dev.openclaw-upgrade-mai.20260625140818

package/examples/strategies/spider/scalp/scanners/scan.py

@@ -0,0 +1,219 @@
+"""SPIDER SCALP — supervised external scanner entrypoint.
+
+Port of senpi-skills/spider (producer v5.1.1, SPIDER_LEG=scalp) to the v2
+`scan(inputs, ctx)` contract. The daemon loop is gone — the runtime supervisor
+calls scan() every interval_seconds.
+
+What stayed faithful to the source:
+  - score_scalp scoring + all thresholds (see scoring.py — ported verbatim).
+  - Static universe (allowedAssets): majors + energy.
+  - The recent-signal dedup (RECENT_SIGNAL_TTL): a coin signaled in the last
+    `recentSignalTtlSeconds` is skipped. Source kept this in a JSON file; here it
+    lives in ctx.state.
+  - Leverage clamp to the per-asset HL venue max (clamp_leverage).
+  - The dual-DEX equity collapse via max() (NOT sum()) when reading account value.
+
+What was simplified vs the source (FLAGGED, same as the swing leg):
+  - The producer's `affordable` per-tick emission cap moves to the v2 runtime
+    (strategy.slots + risk gates). scan() emits ALL qualifying candidates above
+    minScore (held + recently-signaled filtered). The signal-GATING thresholds
+    (minScore, held-set, recent-dedup, venue min notional) are preserved exactly.
+"""
+
+import sys
+import time
+
+import scoring
+
+
+_DEFAULT_RECENT_TTL = 180
+
+
+def _dex_for(asset):
+    return "xyz" if asset.lower().startswith("xyz:") else ""
+
+
+def _get_universe_meta(ctx):
+    """{name: {"max_leverage": int|None, "ctx": {...}}} for every live
+    instrument on both dexes (one market_list_instruments call)."""
+    try:
+        data = ctx.senpi_mcp.call_tool("market_list_instruments", {})
+    except Exception:
+        return {}
+    out = {}
+    if not data:
+        return out
+    insts = data.get("data", data) if isinstance(data, dict) else data
+    if isinstance(insts, dict):
+        insts = insts.get("instruments", [])
+    for inst in insts or []:
+        if not isinstance(inst, dict):
+            continue
+        if inst.get("is_delisted"):
+            continue
+        name = inst.get("name") or inst.get("context", {}).get("coin")
+        if not name:
+            continue
+        entry = {
+            "max_leverage": inst.get("max_leverage", inst.get("maxLeverage")),
+            "ctx": inst.get("context", {}) if isinstance(inst.get("context"), dict) else {},
+        }
+        out[name] = entry
+        out[name.upper()] = entry
+    return out
+
+
+def _fetch_candles(ctx, asset, intervals):
+    try:
+        data = ctx.senpi_mcp.call_tool("market_get_asset_data", {
+            "asset": asset,
+            "candle_intervals": intervals,
+            "dex": _dex_for(asset),
+            "include_funding": False,
+            "include_order_book": False,
+        })
+    except Exception:
+        return None
+    if not data or (isinstance(data, dict) and not data.get("success", True)):
+        return None
+    d = data.get("data", data) if isinstance(data, dict) else data
+    if not isinstance(d, dict):
+        return None
+    return {"candles": d.get("candles", {}) or {}, "ctx": d.get("asset_context", {}) or {}}
+
+
+def _get_account(ctx):
+    """(account_value, [position_dicts]) — dual-DEX equity collapse via max()."""
+    try:
+        ch = ctx.senpi_mcp.call_tool("strategy_get_clearinghouse_state",
+                                     {"strategy_wallet": ctx.wallet})
+    except Exception:
+        return 0.0, []
+    if not ch:
+        return 0.0, []
+    data = ch.get("data", ch) if isinstance(ch, dict) else ch
+    if not isinstance(data, dict):
+        return 0.0, []
+    positions, account_value = [], 0.0
+    for section in ("main", "xyz"):
+        s = data.get(section, {})
+        if not isinstance(s, dict):
+            continue
+        ms = s.get("marginSummary", {})
+        account_value = max(account_value, float(ms.get("accountValue", 0) or 0))
+        for ap in s.get("assetPositions", []):
+            pos = ap.get("position", ap)
+            szi = float(pos.get("szi", 0) or 0)
+            if szi == 0:
+                continue
+            positions.append({"coin": pos.get("coin", ""),
+                              "margin": float(pos.get("marginUsed", 0) or 0)})
+    return account_value, positions
+
+
+# ── ctx.state recent-signal dedup ──
+
+def _load_signaled(ctx):
+    if ctx.state is None or len(ctx.state) == 0:
+        return {}
+    last = ctx.state.last() or {}
+    sig = last.get("signaled", {})
+    return dict(sig) if isinstance(sig, dict) else {}
+
+
+def _was_recently_signaled(signaled, coin, ttl, now):
+    last = signaled.get(coin.upper())
+    if last is None:
+        return False
+    return (now - last) < ttl
+
+
+def _prune_signaled(signaled, ttl, now):
+    cutoff = now - (ttl * 4)
+    return {k: v for k, v in signaled.items() if v >= cutoff}
+
+
+def scan(inputs, ctx):
+    now = time.time()
+    min_score = inputs.get("minScore", 4)
+    margin_pct = float(inputs.get("marginPct", 0.15))
+    leg_max_lev = inputs.get("maxLeverage", 5)
+    ttl = float(inputs.get("recentSignalTtlSeconds", _DEFAULT_RECENT_TTL))
+    venue_min_notional = float(inputs.get("venueMinNotionalUsd", 10))
+    min_notional_pct = float(inputs.get("minNotionalPctOfEquity", 0.01))
+
+    account_value, positions = _get_account(ctx)
+    held_assets = [p["coin"] for p in positions if p.get("coin")]
+    held_set = {h.upper() for h in held_assets}
+    if account_value <= 0:
+        return []
+
+    min_notional = max(account_value * min_notional_pct, venue_min_notional)
+    margin_usd = round(account_value * margin_pct, 2)
+
+    signaled = _prune_signaled(_load_signaled(ctx), ttl, now)
+
+    meta_map = _get_universe_meta(ctx)
+    allowed = list(inputs.get("allowedAssets", []))
+
+    candidates = []
+    for asset in allowed:
+        au = asset.upper()
+        if au in held_set:
+            continue
+        if _was_recently_signaled(signaled, asset, ttl, now):
+            continue
+        meta = meta_map.get(asset) or meta_map.get(au)
+        if not meta:
+            continue
+        md = _fetch_candles(ctx, asset, ["5m", "15m", "1h"])
+        if not md:
+            continue
+        c15 = md["candles"].get("15m", [])
+        c1 = md["candles"].get("1h", [])
+        thesis = scoring.score_scalp(asset, c15, c1, meta.get("ctx", {}), inputs)
+        if thesis and thesis["score"] >= min_score:
+            thesis["_meta"] = meta
+            candidates.append(thesis)
+
+    candidates.sort(key=lambda x: x["score"], reverse=True)
+
+    out = []
+    for th in candidates:
+        leverage = scoring.clamp_leverage(leg_max_lev, th["_meta"].get("max_leverage"))
+        notional = margin_usd * leverage
+        if leverage <= 0 or notional < min_notional:
+            continue
+        out.append({
+            "asset": th["coin"],
+            "direction": th["direction"],
+            "marginUsd": margin_usd,
+            "leverage": leverage,
+            "data": {
+                "score": th["score"],
+                "direction": th["direction"],
+                "reasons": th["reasons"],
+                "heldAssets": held_assets,
+                "trend1h": th.get("trend1h"),
+                "rsi": round(th.get("rsi", 0), 1),
+                "stretchPct": round(th.get("stretchPct", 0), 3),
+            },
+        })
+        signaled[th["coin"].upper()] = now
+
+    # If this append fails (e.g. state_history_max_count is 0/unset so append
+    # raises, or a transient persist error), the next tick reloads stale dedup
+    # state and may re-emit already-suppressed signals. Log-and-continue: don't
+    # crash the tick, but make the failure visible on stderr (the runtime
+    # supervisor captures the scaffold child's stderr) instead of swallowing it.
+    if ctx.state is not None:
+        try:
+            ctx.state.append({"signaled": signaled})
+        except Exception as exc:
+            print(
+                f"[spider.scalp.scan] WARNING: dedup-state append failed; next "
+                f"tick may re-emit suppressed signals: {exc!r}",
+                file=sys.stderr,
+            )
+
+    return out

package/examples/strategies/spider/scalp/scanners/scoring.py

@@ -0,0 +1,179 @@
+"""SPIDER SCALP — pure scoring functions (port of spider-producer.py v5.1.1).
+
+Ported VERBATIM from senpi-skills/spider/scripts/spider-producer.py (the
+technical helpers + score_scalp). No I/O, no MCP, no daemon — pure and
+unit-testable. `scan.py` fetches candle/market data via ctx.senpi_mcp and
+hands it to score_scalp here.
+
+Source thresholds preserved exactly:
+  - candle minimums: 15m >= 20 bars, 1h >= 6 bars
+  - MA: simple 20-bar on 15m closes; stretch = (price - ma)/ma * 100
+  - side select: fade the larger of oversold_mag / overbought_mag
+  - LONG: rsi<=20 +3 / <=25 +2 / <=rsiOversold +1; -stretch>=2*thr +2 / >=thr +1;
+          1h BULLISH +1 / BEARISH -2; funding<0 +1
+  - SHORT: rsi>=80 +3 / >=75 +2 / >=rsiOverbought +1; stretch>=2*thr +2 / >=thr +1;
+          1h BEARISH +1 / BULLISH -2; funding>0 +1
+"""
+
+
+# ── Technical helpers (close=c, high=h, low=l on HL candles) ──
+
+def _close(c):
+    return float(c.get("close", c.get("c", 0)) or 0)
+
+
+def _high(c):
+    return float(c.get("high", c.get("h", 0)) or 0)
+
+
+def _low(c):
+    return float(c.get("low", c.get("l", 0)) or 0)
+
+
+def trend_structure(candles, lookback=6):
+    """Higher lows = BULLISH, lower highs = BEARISH."""
+    if len(candles) < lookback:
+        return "NEUTRAL", 0
+    lows = [_low(c) for c in candles[-lookback:]]
+    highs = [_high(c) for c in candles[-lookback:]]
+    higher_lows = sum(1 for i in range(1, len(lows)) if lows[i] > lows[i - 1])
+    lower_highs = sum(1 for i in range(1, len(highs)) if highs[i] < highs[i - 1])
+    total = lookback - 1
+    if higher_lows >= total * 0.6:
+        return "BULLISH", higher_lows / total
+    elif lower_highs >= total * 0.6:
+        return "BEARISH", lower_highs / total
+    return "NEUTRAL", 0
+
+
+def calc_rsi(closes, period=14):
+    if len(closes) < period + 1:
+        return 50.0
+    gains, losses = [], []
+    for i in range(1, len(closes)):
+        d = closes[i] - closes[i - 1]
+        gains.append(max(0, d))
+        losses.append(max(0, -d))
+    g, l = gains[-period:], losses[-period:]
+    avg_g, avg_l = sum(g) / period, sum(l) / period
+    if avg_l == 0:
+        return 100.0
+    return 100.0 - (100.0 / (1.0 + avg_g / avg_l))
+
+
+def simple_ma(closes, period):
+    if not closes:
+        return 0
+    window = closes[-period:] if len(closes) >= period else closes
+    return sum(window) / len(window)
+
+
+# ── SCALP scoring — Macro & majors fast mean-reversion, BOTH directions ──
+
+def score_scalp(asset, candles_15m, candles_1h, ctx_meta, config):
+    """Score one asset for the SCALP leg.
+
+    Args:
+      asset:        symbol (e.g. "BTC" or "xyz:BRENTOIL")
+      candles_15m:  list of 15m candle dicts (oldest -> newest)
+      candles_1h:   list of 1h candle dicts
+      ctx_meta:     the instrument's "ctx" dict (funding)
+      config:       inputs dict (reads rsiOversold/rsiOverbought/stretchThresholdPct)
+
+    Returns a thesis dict, or None if data is insufficient OR neither side is
+    stretched. The score gate (>= minScore) is applied by the caller.
+    """
+    if len(candles_15m) < 20 or len(candles_1h) < 6:
+        return None
+    closes15 = [_close(c) for c in candles_15m]
+    price = closes15[-1]
+
+    ma = simple_ma(closes15, 20)
+    stretch = ((price - ma) / ma * 100) if ma > 0 else 0
+    rsi = calc_rsi(closes15)
+    trend1, _ = trend_structure(candles_1h)
+
+    ctx = ctx_meta or {}
+    funding = float(ctx.get("funding", 0) or 0)
+
+    rsi_os = config.get("rsiOversold", 30)
+    rsi_ob = config.get("rsiOverbought", 70)
+    stretch_thresh = config.get("stretchThresholdPct", 0.8)
+
+    # Which side is more extreme? Fade it.
+    oversold_mag = max(rsi_os - rsi, 0) / max(rsi_os, 1) + max(-stretch, 0) / stretch_thresh
+    overbought_mag = max(rsi - rsi_ob, 0) / max(100 - rsi_ob, 1) + max(stretch, 0) / stretch_thresh
+    if oversold_mag <= 0 and overbought_mag <= 0:
+        return None
+    direction = "LONG" if oversold_mag >= overbought_mag else "SHORT"
+
+    score = 0
+    reasons = []
+
+    if direction == "LONG":
+        if rsi <= 20:
+            score += 3
+            reasons.append(f"rsi_{rsi:.0f}_deep_oversold")
+        elif rsi <= 25:
+            score += 2
+            reasons.append(f"rsi_{rsi:.0f}_oversold")
+        elif rsi <= rsi_os:
+            score += 1
+            reasons.append(f"rsi_{rsi:.0f}_oversold")
+        if -stretch >= 2 * stretch_thresh:
+            score += 2
+            reasons.append(f"stretch_{stretch:+.2f}%")
+        elif -stretch >= stretch_thresh:
+            score += 1
+            reasons.append(f"stretch_{stretch:+.2f}%")
+        if trend1 == "BULLISH":
+            score += 1
+            reasons.append("1h_uptrend_dip")
+        elif trend1 == "BEARISH":
+            score -= 2
+            reasons.append("1h_downtrend_knife")
+        if funding < 0:
+            score += 1
+            reasons.append(f"funding_neg_{funding:+.4f}")
+    else:  # SHORT
+        if rsi >= 80:
+            score += 3
+            reasons.append(f"rsi_{rsi:.0f}_deep_overbought")
+        elif rsi >= 75:
+            score += 2
+            reasons.append(f"rsi_{rsi:.0f}_overbought")
+        elif rsi >= rsi_ob:
+            score += 1
+            reasons.append(f"rsi_{rsi:.0f}_overbought")
+        if stretch >= 2 * stretch_thresh:
+            score += 2
+            reasons.append(f"stretch_{stretch:+.2f}%")
+        elif stretch >= stretch_thresh:
+            score += 1
+            reasons.append(f"stretch_{stretch:+.2f}%")
+        if trend1 == "BEARISH":
+            score += 1
+            reasons.append("1h_downtrend_rip")
+        elif trend1 == "BULLISH":
+            score -= 2
+            reasons.append("1h_uptrend_knife")
+        if funding > 0:
+            score += 1
+            reasons.append(f"funding_pos_{funding:+.4f}")
+
+    return {
+        "coin": asset, "direction": direction, "score": score,
+        "reasons": reasons, "price": price, "rsi": rsi,
+        "trend1h": trend1, "stretchPct": stretch, "funding": funding,
+    }
+
+
+def clamp_leverage(desired, venue_max):
+    """Clamp desired leverage to the asset's Hyperliquid venue max."""
+    try:
+        venue = int(venue_max)
+    except (TypeError, ValueError):
+        venue = desired
+    if venue <= 0:
+        venue = desired
+    return max(1, min(int(desired), venue))

package/examples/strategies/spider/swing/recipe.yaml

@@ -0,0 +1,137 @@
+# ── SPIDER · SWING leg (v2 supervised) ──────────────────────────────
+# Tech & AI multi-day momentum, LONG only.
+#
+# Ported from senpi-skills/spider (producer v5.1.1, SPIDER_LEG=swing) to the
+# v2 supervised external-scanner contract. The producer daemon is gone: the
+# runtime supervises ./scanners/scan.py and calls scan(inputs, ctx) every
+# `interval_seconds`. All scoring thresholds preserved exactly; see scan.py.
+name: spider-swing
+version: 2.0.0
+group: spider                       # agent-facing handle (BOTH legs share it)
+description: >
+  SPIDER SWING — Tech & AI multi-day momentum, LONG only. Scores a dynamic
+  universe (curated tech/AI/space XYZ equities auto-rebuilt from the live
+  instrument board + a static crypto-alt pool) on 4h/1h trend structure, 24h
+  relative strength, RSI room, funding crowding, and smart-money consensus.
+  minScore 5; wide let-winners-run DSL, all time-cuts off, 7d staleness cap.
+  Paired with the SCALP leg on a separate wallet.
+
+strategy:
+  wallet: "${SPIDER_SWING_WALLET}"
+  slots: 3                          # source maxSlots 3
+  margin_pct: 28                    # source marginPct 0.28 → margin_usd = account_value * 0.28
+  default_leverage: 10              # source swingMaxLeverage cap (clamped per-asset to HL venue max in scan.py)
+  trading_risk: moderate
+  enabled: true
+
+scanners:
+  - name: position_tracker          # built-in: feeds DSL exit engine
+    type: position_tracker
+    interval_seconds: 10
+
+  - name: spider_swing_signals      # supervised external scanner
+    type: external_scanner
+    path: ./scanners
+    entrypoint: scan.py
+    interval_seconds: 300           # source tickSeconds 300
+    timeout_seconds: 180            # source tick_timeout = min(180, max(30, tick-10))
+    default_signal_validity_seconds: 600   # 2x tick; LLM gate is pass-through so a fresh re-score arrives next tick
+    state_history_max_count: 200    # holds recent-signal dedup + xyz first-seen ledger records
+    inputs:
+      # ── universe knobs (from spider-swing-config.json) ──
+      cryptoAlts: ["SUI", "ONDO", "HYPE", "NIL", "GRASS", "ZEC"]
+      xyzIncludeSet: ["NVDA", "AMD", "INTC", "MRVL", "MU", "TSM", "ASML", "ARM", "SMSN", "SKHX", "DRAM", "SNDK", "DELL", "LITE", "CRWV", "PLTR", "ORCL", "GOOGL", "META", "MSFT", "AMZN", "AAPL", "NFLX", "IBM", "COIN", "MSTR", "CRCL", "HOOD", "SPCX", "RKLB", "CBRS"]
+      xyzExcludeSet: ["GOLD", "SILVER", "PLATINUM", "PALLADIUM", "COPPER", "CL", "BRENTOIL", "NATGAS", "URANIUM", "URNM", "EUR", "JPY", "GBP", "KRW", "DXY", "SP500", "JP225", "KR200", "NIFTY", "IBOV", "XYZ100", "EWY", "EWJ", "EWT", "EWZ", "XLE", "VIX", "PURRDAT", "BIRD"]
+      xyzVolFloorUsd: 5000000
+      xyzFreshDays: 21
+      xyzMaxNames: 20
+      allowedAssets: ["xyz:NVDA", "xyz:AMD", "xyz:INTC", "xyz:MRVL", "xyz:MU", "xyz:TSM", "SUI", "ONDO", "HYPE", "NIL", "GRASS", "ZEC"]
+      # ── scoring knobs ──
+      minScore: 5
+      marginPct: 0.28
+      maxLeverage: 10
+      maxSlots: 3
+      rsiMaxLong: 78
+      useSmBonus: true
+      venueMinNotionalUsd: 10
+      minNotionalPctOfEquity: 0.01
+      recentSignalTtlSeconds: 180
+    signal_data_schema:
+      score: { type: number }
+      direction: { type: string }
+      reasons: { type: array, required: false }
+      trend4h: { type: string, required: false }
+      rs: { type: number, required: false }
+      smPct: { type: number, required: false }
+      heldAssets: { type: array, required: false }
+
+actions:
+  - name: position_tracker_action   # rule-based lifecycle → DSL
+    action_type: POSITION_TRACKER
+    decision_mode: rule
+    scanners: [position_tracker]
+
+  - name: spider_swing_entry        # OPEN_POSITION, rule mode (source LLM gate was pure pass-through)
+    action_type: OPEN_POSITION
+    decision_mode: rule
+    scanners: [spider_swing_signals]
+    params:
+      order_type: FEE_OPTIMIZED_LIMIT
+      fee_optimized_limit_options:
+        ensure_execution_as_taker: true
+        execution_timeout_seconds: 60
+    context:
+      - type: signal
+        scanner: spider_swing_signals
+
+# ── EXIT (DSL — wide let-winners-run; the style rides multi-day) ──
+exit:
+  engine: dsl
+  interval_seconds: 60
+  order_type: FEE_OPTIMIZED_LIMIT
+  fee_optimized_limit_options:
+    ensure_execution_as_taker: true
+    execution_timeout_seconds: 60
+  dsl_preset:
+    hard_timeout:
+      enabled: true
+      interval_in_minutes: 10080    # 7d — matches source max hold
+    weak_peak_cut:
+      enabled: false                # patience leg
+      interval_in_minutes: 720
+      min_value: 3.0
+    dead_weight_cut:
+      enabled: false                # patience leg
+      interval_in_minutes: 1440
+    phase1:
+      enabled: true
+      max_loss_pct: 22.0            # source tolerates deep drawdowns
+      retrace_threshold: 12
+      consecutive_breaches_required: 1
+    phase2:
+      enabled: true
+      tiers:
+        - { trigger_pct: 15,  lock_hw_pct: 0 }
+        - { trigger_pct: 30,  lock_hw_pct: 45 }
+        - { trigger_pct: 60,  lock_hw_pct: 68 }
+        - { trigger_pct: 100, lock_hw_pct: 80 }
+        - { trigger_pct: 150, lock_hw_pct: 90 }
+
+# ── RISK guard rails (from runtime-swing.yaml; minutes → seconds) ──
+risk:
+  data_retention_seconds: 604800    # 7d (was data_retention_hours 168)
+  guard_rails:
+    daily_loss_limit_pct: 15
+    max_entries_per_day: 12
+    bypass_max_entries_per_day_on_profit: true
+    max_consecutive_losses: 4
+    cooldown_seconds: 5400          # was cooldown_minutes 90
+    drawdown_halt_pct: 25
+    drawdown_reset_on_day_rollover: true
+    per_asset_cooldown_seconds: 14400   # was per_asset_cooldown_minutes 240 (4h)
+
+notifications:
+  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
+  dsl_lifecycle: true
+  dsl_notify_sl_updates: false
+  action_lifecycle: true