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

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

@@ -1,219 +0,0 @@
-"""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

@@ -1,179 +0,0 @@
-"""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

@@ -1,141 +0,0 @@
-# ── 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:
-        # FIDELITY NOTE: the source had a 6th tier { trigger_pct: 150, lock_hw_pct: 90 }.
-        # The v2 DSL caps trigger_pct at <= 100 (src/dsl/config/parse-tiers.ts), so the
-        # +150% tier cannot be expressed. Dropped; the +100% tier (lock 80%) is now the
-        # top of the ladder. All tiers <= 100 are carried verbatim. This is the single
-        # threshold that does not map cleanly to the v2 schema.
-        - { 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 }
-
-# ── 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