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

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

@@ -1,334 +0,0 @@
-"""SPIDER SWING — supervised external scanner entrypoint.
-
-Port of senpi-skills/spider (producer v5.1.1, SPIDER_LEG=swing) 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_swing scoring + all thresholds (see scoring.py — ported verbatim).
-  - The dynamic universe (build_universe): static crypto alts + a live XYZ pool
-    rebuilt from market_list_instruments, with the include-set / fresh-listing /
-    exclude-set logic and the xyzMaxNames volume cap.
-  - 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.
-  - The XYZ first-seen ledger (new-listing auto-catch): source kept it in a JSON
-    file; here it lives in ctx.state alongside the dedup map.
-  - 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):
-  - The producer also computed an `affordable` slot count from free margin and
-    emitted at most min(open_slots, affordable) signals. The v2 runtime owns
-    slots/affordability (strategy.slots + risk gates), so 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; only the per-tick emission CAP moves to the
-    runtime. marginUsd is still computed (account_value * marginPct) and carried
-    on data{} so the action sizes identically to the source.
-"""
-
-import sys
-import time
-
-import scoring
-
-
-# How long after emitting a signal we treat the asset as "in-flight" and refuse
-# to re-emit (source RECENT_SIGNAL_TTL_SEC = 180). Overridable via inputs.
-_DEFAULT_RECENT_TTL = 180
-
-
-# ── MCP data fetchers (route the producer's calls through ctx.senpi_mcp) ──
-
-def _dex_for(asset):
-    """XYZ (HIP-3) assets must pass dex='xyz'; main-DEX assets pass ''."""
-    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 _get_sm_map(ctx):
-    """{COIN: long_ratio_pct} from smart-money leaderboard markets."""
-    try:
-        data = ctx.senpi_mcp.call_tool("leaderboard_get_markets", {})
-    except Exception:
-        return {}
-    out = {}
-    if not data:
-        return out
-    markets = data.get("data", data) if isinstance(data, dict) else data
-    if isinstance(markets, dict):
-        markets = markets.get("markets", markets.get("leaderboard", []))
-    agg = {}
-    for m in markets or []:
-        if not isinstance(m, dict):
-            continue
-        token = m.get("token", m.get("coin", m.get("asset", "")))
-        if not token:
-            continue
-        direction = m.get("direction", "").lower()
-        pct = float(m.get("pct_of_top_traders_gain", m.get("longPct", 0)) or 0)
-        a = agg.setdefault(token.upper(), {"long": 0.0, "short": 0.0})
-        if direction == "long":
-            a["long"] = pct
-        elif direction == "short":
-            a["short"] = pct
-    for tok, a in agg.items():
-        total = a["long"] + a["short"]
-        if total > 0:
-            out[tok] = a["long"] / total * 100
-    return out
-
-
-def _fetch_candles(ctx, asset, intervals):
-    """{"candles": {iv: [...]}, "ctx": {...}} or None on failure."""
-    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]) from strategy_get_clearinghouse_state.
-
-    Dual-DEX equity collapse: account_value is taken via max() across the
-    main/xyz sections — they are TWO VIEWS of ONE cross-margined wallet, never
-    summed (summing would double every position size). assetPositions ARE
-    per-sub-DEX, so those are enumerated across both sections.
-    """
-    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 + xyz first-seen ledger ──
-#
-# The bounded ctx.state series stores one snapshot record per tick:
-#   {"signaled": {COIN: epoch_seconds}, "first_seen": {name: epoch_seconds}}
-# We read the latest record to recover both maps, prune the dedup map by TTL,
-# and append the updated snapshot at the end of the tick.
-
-def _load_state_maps(ctx):
-    if ctx.state is None or len(ctx.state) == 0:
-        return {}, {}
-    last = ctx.state.last() or {}
-    signaled = dict(last.get("signaled", {})) if isinstance(last.get("signaled"), dict) else {}
-    first_seen = dict(last.get("first_seen", {})) if isinstance(last.get("first_seen"), dict) else {}
-    return signaled, first_seen
-
-
-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}
-
-
-# ── Universe resolution (static crypto alts + dynamic XYZ pool) ──
-
-def _build_universe(inputs, meta_map, first_seen, now):
-    """Resolve the asset list to score this tick (port of build_universe).
-
-    Returns (universe, updated_first_seen). The first-seen ledger is updated
-    in-place semantics: pre-existing names on the first run are backdated as
-    already-old so the fresh-listing auto-catch only fires for names that appear
-    AFTER deploy.
-    """
-    crypto = list(inputs.get("cryptoAlts", []))
-    include = {t.upper() for t in inputs.get("xyzIncludeSet", [])}
-    exclude = {t.upper() for t in inputs.get("xyzExcludeSet", [])}
-    vol_floor = float(inputs.get("xyzVolFloorUsd", 5000000))
-    fresh_days = float(inputs.get("xyzFreshDays", 21))
-    max_names = int(inputs.get("xyzMaxNames", 20))
-
-    # Fallback if the instrument board is unavailable: static include-set.
-    if not meta_map:
-        return crypto + [f"xyz:{t}" for t in sorted(include)], first_seen
-
-    xyz_names = sorted(n for n in meta_map if isinstance(n, str) and n.startswith("xyz:"))
-
-    fresh_window = fresh_days * 86400
-    first_run = not first_seen
-    backdate = now - fresh_window - 1  # mark pre-existing names as already-old
-    first_seen = dict(first_seen)
-    for n in xyz_names:
-        if n not in first_seen:
-            first_seen[n] = backdate if first_run else now
-
-    qualifiers = []
-    for n in xyz_names:
-        ctx_meta = (meta_map.get(n) or {}).get("ctx", {})
-        try:
-            vol = float(ctx_meta.get("dayNtlVlm", 0) or 0)
-        except (TypeError, ValueError):
-            vol = 0.0
-        if vol < vol_floor:
-            continue
-        bare = n.split(":", 1)[1].upper()
-        is_fresh = (now - first_seen.get(n, backdate)) < fresh_window
-        if bare in include or (is_fresh and bare not in exclude):
-            qualifiers.append((n, vol))
-
-    qualifiers.sort(key=lambda x: x[1], reverse=True)
-    return crypto + [n for n, _ in qualifiers[:max_names]], first_seen
-
-
-# ── Entry point ──
-
-def scan(inputs, ctx):
-    now = time.time()
-    min_score = inputs.get("minScore", 5)
-    margin_pct = float(inputs.get("marginPct", 0.28))
-    leg_max_lev = inputs.get("maxLeverage", 10)
-    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, first_seen = _load_state_maps(ctx)
-    signaled = _prune_signaled(signaled, ttl, now)
-
-    meta_map = _get_universe_meta(ctx)
-    sm_map = _get_sm_map(ctx) if inputs.get("useSmBonus", True) else {}
-    allowed, first_seen = _build_universe(inputs, meta_map, first_seen, now)
-
-    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, ["1h", "4h"])
-        if not md:
-            continue
-        c1 = md["candles"].get("1h", [])
-        c4 = md["candles"].get("4h", [])
-        thesis = scoring.score_swing(
-            asset, c1, c4, meta.get("ctx", {}), sm_map.get(au), 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,
-                "trend4h": th.get("trend4h"),
-                "rs": round(th.get("rs", 0), 2),
-                "smPct": round(th.get("smPct", 0), 1),
-            },
-        })
-        signaled[th["coin"].upper()] = now
-
-    # Persist the updated dedup + first-seen snapshot for next tick.
-    # 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, "first_seen": first_seen})
-        except Exception as exc:
-            print(
-                f"[spider.swing.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/swing/scanners/scoring.py

@@ -1,184 +0,0 @@
-"""SPIDER SWING — 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_swing). 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_swing here.
-
-Source thresholds preserved exactly:
-  - candle minimums: 1h >= 8 bars, 4h >= 6 bars
-  - 4h trend: BULLISH +3 / BEARISH -4
-  - 1h trend: BULLISH +2 / BEARISH -1
-  - 24h relative strength: >=8 +3, >=4 +2, >=1 +1, <0 -1
-  - RSI: > rsiMaxLong (78) -2, < 50 +1
-  - funding: < 0 +1, > 0.0002 -1
-  - smart-money: ratio > 58 +2, < 42 -2
-"""
-
-
-# ── 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 price_momentum(candles, n_bars=1):
-    if len(candles) < n_bars + 1:
-        return 0
-    old = _close(candles[-(n_bars + 1)])
-    new = _close(candles[-1])
-    if old == 0:
-        return 0
-    return ((new - old) / old) * 100
-
-
-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))
-
-
-# ── SWING scoring — Tech & AI multi-day momentum, LONG only ──
-
-def score_swing(asset, candles_1h, candles_4h, ctx_meta, sm_ratio, config):
-    """Score one asset for the SWING leg.
-
-    Args:
-      asset:        symbol (e.g. "xyz:NVDA" or "SUI")
-      candles_1h:   list of 1h candle dicts (oldest -> newest)
-      candles_4h:   list of 4h candle dicts
-      ctx_meta:     the instrument's "ctx" dict (funding/markPx/prevDayPx)
-      sm_ratio:     smart-money long-ratio pct for this asset, or None
-      config:       inputs dict (reads rsiMaxLong; default 78)
-
-    Returns a thesis dict, or None if data is insufficient. The score gate
-    (>= minScore) is applied by the caller, not here.
-    """
-    if len(candles_1h) < 8 or len(candles_4h) < 6:
-        return None
-    closes1 = [_close(c) for c in candles_1h]
-    price = closes1[-1]
-
-    trend4, s4 = trend_structure(candles_4h)
-    trend1, s1 = trend_structure(candles_1h)
-    rsi = calc_rsi(closes1)
-
-    ctx = ctx_meta or {}
-    funding = float(ctx.get("funding", 0) or 0)
-    markpx = float(ctx.get("markPx", price) or price)
-    prevday = float(ctx.get("prevDayPx", 0) or 0)
-    rs24 = ((markpx - prevday) / prevday * 100) if prevday > 0 else price_momentum(candles_1h, min(24, len(candles_1h) - 1))
-
-    direction = "LONG"
-    score = 0
-    reasons = []
-
-    # 4h trend structure: the multi-day backbone. Bearish kills it.
-    if trend4 == "BULLISH":
-        score += 3
-        reasons.append(f"4h_bullish_{s4:.0%}")
-    elif trend4 == "BEARISH":
-        score -= 4
-        reasons.append("4h_bearish")
-
-    # 1h trend confirmation
-    if trend1 == "BULLISH":
-        score += 2
-        reasons.append(f"1h_bullish_{s1:.0%}")
-    elif trend1 == "BEARISH":
-        score -= 1
-        reasons.append("1h_bearish")
-
-    # 24h relative-strength proxy
-    if rs24 >= 8:
-        score += 3
-        reasons.append(f"rs_{rs24:+.1f}%")
-    elif rs24 >= 4:
-        score += 2
-        reasons.append(f"rs_{rs24:+.1f}%")
-    elif rs24 >= 1:
-        score += 1
-        reasons.append(f"rs_{rs24:+.1f}%")
-    elif rs24 < 0:
-        score -= 1
-        reasons.append(f"rs_neg_{rs24:+.1f}%")
-
-    # RSI room (overbought penalty / room bonus)
-    rsi_max = config.get("rsiMaxLong", 78)
-    if rsi > rsi_max:
-        score -= 2
-        reasons.append(f"rsi_overbought_{rsi:.0f}")
-    elif rsi < 50:
-        score += 1
-        reasons.append(f"rsi_room_{rsi:.0f}")
-
-    # Funding: negative funding (shorts pay) favors a LONG; very crowded
-    # long funding is a small penalty.
-    if funding < 0:
-        score += 1
-        reasons.append(f"funding_neg_{funding:+.4f}")
-    elif funding > 0.0002:
-        score -= 1
-        reasons.append("funding_crowded")
-
-    # Smart-money consensus bonus (crypto alts only; XYZ has none)
-    sm_pct = 0.0
-    if sm_ratio is not None:
-        sm_pct = sm_ratio
-        if sm_ratio > 58:
-            score += 2
-            reasons.append(f"sm_long_{sm_ratio:.0f}%")
-        elif sm_ratio < 42:
-            score -= 2
-            reasons.append(f"sm_short_{sm_ratio:.0f}%")
-
-    return {
-        "coin": asset, "direction": direction, "score": score,
-        "reasons": reasons, "price": price, "rsi": rsi,
-        "trend4h": trend4, "trend1h": trend1, "rs": rs24,
-        "smPct": sm_pct, "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/turbine/README.md

@@ -1,167 +0,0 @@
-# TURBINE (v2 supervised demo)
-
-Turbine is a **two-leg** strategy where both legs run the **same signal** and
-differ **only** in sizing + DSL exit + risk. So unlike spider (two distinct
-theses), turbine is authored as **one shared scanner** and **two recipes**.
-
-Ported from `senpi-skills/turbine` (producer v3.2.2, config v3.3) to the runtime
-v2 supervised external-scanner contract. The standalone producer daemon is gone;
-the runtime supervises the shared `scanners/scan.py` and calls `scan()` on each
-recipe's `interval_seconds`.
-
-## The two legs
-
-| Leg       | Thesis (identical signal) | Slots | Margin/slot | Lev | DSL exit |
-|-----------|---------------------------|-------|-------------|-----|----------|
-| `volume`  | Funding-fade rotation     | 7     | $700        | 5x  | force-close: 10-min hard timeout, phase1 max_loss 50 / retrace 30, **no phase2**, maker exit |
-| `runners` | Funding-fade rotation     | 2     | $1300       | 5x  | patient: 4h hard timeout, weak_peak 90m@3 + dead_weight 120m, phase1 max_loss 30 / retrace 8, 5-tier phase2 (5/0·10/35·20/55·35/75·50/85), taker exit |
-
-Both legs run the **identical** rotation alpha (same universe, same direction
-logic, same gates). The wallet boundary selects DSL behavior: `volume` prints
-high notional and force-closes on the clock; `runners` takes the same entries but
-lets the ~5% that catch a real directional move ride the phase2 ratchet.
-
-Both recipes set `group: turbine` — the agent-facing handle that ties the legs
-together.
-
-## The signal (shared `scanners/scan.py`)
-
-Funding-fade volume rotation:
-
-- **Universe** — `MAIN = {BTC, ETH, SOL, HYPE}`, `XYZ = {xyz:BRENTOIL, xyz:GOLD,
-  xyz:SPX}`.
-- **Pool pick** — probabilistic: `random() < xyzWeight (0.80)` → XYZ pool, else
-  MAIN pool. A **deterministic rotation index** then walks the chosen pool;
-  exhaustion falls through to the other pool.
-- **Direction = funding fade** — `LONG_CROWDED`/`LONG_HEAVY` → SHORT,
-  `SHORT_CROWDED`/`SHORT_HEAVY` → LONG, flat/unknown → a random coin flip.
-- **Spread gate** — `main ≤ 3 bps`, `xyz ≤ 10 bps`, off the top-of-book mid.
-- **Skip held + 90s post-close cooldown** — never re-enter an asset already held
-  or closed in the last 90 seconds.
-- **One signal per free slot** — the rotation index advances once per emitted
-  candidate, so a tick emits at most `maxSlots` distinct assets.
-
-MCP tools used (all read-only): `strategy_get_clearinghouse_state`,
-`strategy_get_open_orders`, `market_list_instruments`, `market_get_asset_data`.
-
-State (rotation index, held set, last-closed map, signal dedup) lives in
-`ctx.state` (the source kept it in per-wallet JSON files).
-
-## Layout
-
-```
-turbine/
-├── README.md
-├── recipe-volume.yaml      # volume leg recipe   (path: ./scanners, entrypoint: scan.py)
-├── recipe-runners.yaml     # runners leg recipe  (path: ./scanners, entrypoint: scan.py)
-└── scanners/               # SHARED by both recipes
-    ├── scan.py             # scan(inputs, ctx) entrypoint (one signal stream)
-    └── scoring.py          # pure rotation/direction/spread functions (unit-tested)
-```
-
-The per-leg sizing (`marginUsd`, `leverage`, `maxSlots`) rides on each recipe's
-`inputs:` block, so the one `scan.py` emits correctly-sized signals for whichever
-leg supervises it.
-
-## Environment variables
-
-| Variable                 | Required | Purpose |
-|--------------------------|----------|---------|
-| `TURBINE_VOLUME_WALLET`  | volume   | Volume-leg strategy wallet |
-| `TURBINE_RUNNERS_WALLET` | runners  | Runners-leg strategy wallet (**optional** — see below) |
-| `SENPI_API_KEY`          | yes      | MCP auth for `ctx.senpi_mcp` (injected into the scaffold child) |
-| `SENPI_MCP_URL`          | yes      | MCP server URL |
-| `TELEGRAM_CHAT_ID`       | optional | Notifications |
-
-### Runners is optional
-
-Leave `TURBINE_RUNNERS_WALLET` unset and simply **don't launch**
-`recipe-runners.yaml` to run a **pure volume engine**. The two legs are
-independent runtimes with no cross-leg coupling, so volume runs standalone with
-no degradation. (The source's per-wallet rotation desync came from each wallet
-owning its own rotation index — here that is just each leg owning its own
-`ctx.state`.)
-
-## Install / run
-
-Run each leg as its own runtime instance, pointing at its recipe:
-
-```bash
-TURBINE_VOLUME_WALLET=0x... \
-SENPI_API_KEY=... SENPI_MCP_URL=https://mcp.prod.senpi.ai/mcp \
-  openclaw senpi run examples/strategies/turbine/recipe-volume.yaml
-
-# optional second leg:
-TURBINE_RUNNERS_WALLET=0x... \
-SENPI_API_KEY=... SENPI_MCP_URL=https://mcp.prod.senpi.ai/mcp \
-  openclaw senpi run examples/strategies/turbine/recipe-runners.yaml
-```
-
-## Fidelity notes
-
-These are the source behaviors that changed (or did not map 1:1) under the v2
-contract. Nothing load-bearing was silently dropped.
-
-### Dropped: the `cancel_order` stale-order sweep
-
-The source producer cancelled orphaned resting maker orders each tick
-(`sweep_stale_resting_orders`). Those orphans were an artifact of the **old
-daemon / helpers-migration era**: a runtime swap left resting ALO orders that the
-*new* runtime instance did not own, so they starved slots indefinitely.
-
-Under v2 the **supervised runtime owns its own order lifecycle** end to end:
-
-- `FEE_OPTIMIZED_LIMIT`'s `execution_timeout_seconds` cancels the entry maker
-  order the runtime itself placed if it doesn't fill in time, and
-- the DSL `hard_timeout` force-closes any position that does fill.
-
-There is no second uncoordinated runtime to leave orphans, so the sweep is
-**redundant** and was not ported — a scanner produces signals, it does not manage
-orders. (If orphaned ALOs ever reappear in operation, the correct fix is a
-runtime-side reconcile, not a scanner side-effect.) `scan.py` therefore makes
-**only read-only MCP calls** — a test asserts `cancel_order` is never called.
-
-### Moved to the runtime: `effective_slots` auto-downsize / per-tick cap
-
-The source computed `effective_slots = min(maxSlots, account_value /
-margin_per_slot)` and emitted at most that many signals per tick. In v2 the
-runtime owns slot count (`strategy.slots`) and affordability (`risk.guard_rails`),
-so `scan()` emits all candidates clearing the gates (held + cooldown + spread),
-carrying `marginUsd` + `leverage` on each signal's `data{}`. It still caps a tick
-at `maxSlots` candidates (the rotation only advances that many times) so the
-scanner doesn't flood the queue; the runtime makes the final open/skip decision.
-
-### Kept: non-deterministic `random` picks
-
-The probabilistic pool pick and the neutral-regime coin flip are the source's
-design (rotation desync + unbiased neutral direction). They are kept verbatim. A
-non-deterministic scan is fine — the tests assert structure (valid, gated
-signals) and seed/inject the rng for the deterministic paths.
-
-### Threshold that did not map: volume `phase2: tiers: []`
-
-The source volume preset disabled phase2 with `tiers: []`. The v2 DSL parser
-requires a **non-empty** `tiers` array even when phase2 is disabled. The volume
-recipe keeps `phase2.enabled: false` (so phase2 never advances) but supplies one
-**inert placeholder tier** to satisfy the parser. Every other threshold in both
-legs is carried verbatim. The runners 5-tier phase2 maps cleanly (all
-`trigger_pct ≤ 100`).
-
-### `trading_risk: balanced` → `moderate`
-
-The runners source used `trading_risk: balanced`, which is not a v2 enum value
-(`conservative | moderate | aggressive`). It is mapped to the nearest tier,
-`moderate`. The volume source's `aggressive` is carried verbatim.
-
-### Action gate
-
-The source `OPEN_POSITION` action used `decision_mode: llm` with a copy-verbatim
-pass-through prompt and a pinned confidence — a rule wearing an LLM costume. Both
-v2 recipes use `decision_mode: rule` directly.
-
-### Sizing source of truth
-
-The source had margin/slot drift across files (700/1300 in config v3.3 vs
-500/950 producer defaults vs YAML). This port uses **config v3.3**: volume 7
-slots @ $700, runners 2 slots @ $1300, both 5x, `xyzWeight 0.80`, spread
-main 3 bps / xyz 10 bps.