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

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

@@ -0,0 +1,452 @@
+"""RAPTOR — pure whale copy-follow functions (port of raptor-producer.py v4.0.1).
+
+Ported VERBATIM from senpi-skills/raptor/scripts/raptor-producer.py (the
+parsing + gating + additive scoring helpers) and raptor_config.py. No I/O, no
+MCP, no daemon — pure and unit-testable. `scan.py` fetches trader/market data
+via ctx.senpi_mcp and hands it to these helpers.
+
+DOC-vs-CODE: the SKILL/README docs are STALE (they say trader gate $2M /
+concentration 0.40). The CODE (config v3.1 + producer constants) is the source
+of truth and is what is ported here:
+  - trader delta gate (minDeltaPnl)        = $500,000
+  - position delta gate (minPositionPnl)   = $100,000
+  - concentration gate (minConcentration)  = 0.35
+  - SM gate                                = minSmPct 2.0 / minSmTraders 10
+  - whale entry-discipline                 = skip if price ran > 5% from entry
+  - score floor (minScore)                 = 6
+  - leverage tiers                         = >=10 -> 10x, >=8 -> 8x, >=6 -> 7x
+  - tier2 / tier3 trader thresholds        = $1.5M / $3.0M
+  - margin pct                             = 0.25 base, 0.35 if score >= 10
+
+Source thresholds preserved exactly — see the scoring tier table in
+score_position() (all additive, max ~16).
+"""
+
+# ── Constants (verbatim from producer + config v3.1) ──
+
+XYZ_BANNED = True
+MAX_PRICE_RUN_PCT_FROM_WHALE_ENTRY = 5.0   # v3.3 tightened from 20% -> 5%
+
+# Trader-pool / position gates (config.hotStreak)
+MIN_TRADER_DELTA_PNL = 500_000
+MIN_POSITION_PNL = 100_000
+MIN_CONCENTRATION = 0.35
+TIER2_TRADER_THRESHOLD = 1_500_000
+TIER3_TRADER_THRESHOLD = 3_000_000
+
+# Smart-money alignment (config.smAlignment)
+MIN_SM_PCT = 2.0
+MIN_SM_TRADERS = 10
+REQUIRE_DIRECTION_MATCH = True
+
+# Entry (config.entry)
+MIN_SCORE = 6
+MARGIN_PCT_BASE = 0.25
+MARGIN_PCT_HIGH_CONV = 0.35
+
+# Leverage (config.leverage)
+DEFAULT_LEVERAGE = 7
+LEVERAGE_TIERS = [
+    {"minScore": 10, "leverage": 10},
+    {"minScore": 8, "leverage": 8},
+    {"minScore": 6, "leverage": 7},
+]
+
+# Dedup (config.dedupe)
+EVENT_DEDUPE_HOURS = 4
+
+# Score normalization divisor used when posting the [0,1] score on the wire.
+SCORE_NORMALIZATION_DIVISOR = 16.0
+
+
+def safe_float(val, default=0.0):
+    try:
+        return float(val)
+    except (TypeError, ValueError):
+        return default
+
+
+def _extract_list(raw, *candidate_paths):
+    """Walk candidate dotted paths and return the first list found.
+
+    Verbatim from producer._extract_list — the prod responses nest the actual
+    list under varying keys across tools, so we try each path in order.
+    """
+    if raw is None:
+        return []
+    for path in candidate_paths:
+        cur = raw
+        for k in path:
+            if isinstance(cur, dict) and k in cur:
+                cur = cur[k]
+            else:
+                cur = None
+                break
+        if isinstance(cur, list):
+            return cur
+    if isinstance(raw, list):
+        return raw
+    if isinstance(raw, dict) and isinstance(raw.get("data"), list):
+        return raw["data"]
+    return []
+
+
+# ── Trader-pool quality filter (verbatim from fetch_quality_hot_traders) ──
+
+def parse_quality_traders(raw, min_delta_usd=MIN_TRADER_DELTA_PNL):
+    """Filter a discovery_get_top_traders response to currently-winning quality
+    traders: ELITE/RELIABLE consistency, unrealized delta-pnl >= min_delta_usd.
+
+    Returns a list of trader dicts sorted by unrealized_pnl desc.
+    """
+    raw_list = _extract_list(raw, ("data", "traders"), ("traders",))
+    quality = []
+    for t in raw_list:
+        if not isinstance(t, dict):
+            continue
+        addr = str(t.get("address", "")).lower()
+        if not addr:
+            continue
+        unrealized = safe_float(t.get("unRealizedProfitAndLoss", 0))
+        realized = safe_float(t.get("realizedProfitAndLoss", 0))
+        total_pnl = safe_float(t.get("profitAndLoss", unrealized + realized))
+        tcs_label = str(t.get("tcsLabel", "")).upper()
+        if tcs_label not in ("ELITE", "RELIABLE"):
+            continue
+        if unrealized < min_delta_usd:
+            continue
+        quality.append({
+            "address": addr,
+            "unrealized_pnl": unrealized,
+            "realized_pnl": realized,
+            "total_pnl": total_pnl,
+            "tcs_label": tcs_label,
+            "tcs_value": safe_float(t.get("tcsValue", 0)),
+            "roi": safe_float(t.get("returnOnInvestment", 0)),
+        })
+    quality.sort(key=lambda x: x["unrealized_pnl"], reverse=True)
+    return quality
+
+
+def parse_trader_positions(raw):
+    """v3.4 nested-dict parser fix preserved — try each known position path."""
+    return _extract_list(
+        raw,
+        ("data", "positions", "positions"),   # nested-dict (actual prod shape)
+        ("data", "top_positions", "positions"),
+        ("data", "positions"),
+        ("data", "top_positions"),
+        ("positions",),
+        ("top_positions",),
+    )
+
+
+def parse_sm_map(raw):
+    """Build {TOKEN: {direction, pct, traders, price_chg_4h, price_chg_1h,
+    contrib_15m, contrib_1h}} from a leaderboard_get_markets response.
+
+    xyz-dex markets are dropped (XYZ_BANNED). Verbatim from fetch_sm_map.
+    """
+    markets = []
+    if isinstance(raw, dict):
+        data = raw.get("data", raw)
+        if isinstance(data, dict):
+            markets = data.get("markets", [])
+            if isinstance(markets, dict):
+                markets = markets.get("markets", [])
+        elif isinstance(data, list):
+            markets = data
+    elif isinstance(raw, list):
+        markets = raw
+    sm_map = {}
+    for m in markets:
+        if not isinstance(m, dict):
+            continue
+        token = str(m.get("token", "")).upper()
+        dex = str(m.get("dex", "")).lower()
+        if XYZ_BANNED and dex == "xyz":
+            continue
+        if not token:
+            continue
+        sm_map[token] = {
+            "direction": str(m.get("direction", "")).upper(),
+            "pct": safe_float(m.get("pct_of_top_traders_gain", 0)),
+            "traders": int(m.get("trader_count", 0)),
+            "price_chg_4h": safe_float(m.get("token_price_change_pct_4h", 0)),
+            "price_chg_1h": safe_float(m.get("token_price_change_pct_1h",
+                                             m.get("price_change_1h", 0))),
+            "contrib_15m": safe_float(m.get("contribution_pct_change_15m", 0)),
+            "contrib_1h": safe_float(m.get("contribution_pct_change_1h", 0)),
+        }
+    return sm_map
+
+
+# ── Strongest-position selection + concentration (verbatim from build_signal) ──
+
+def pick_strongest_position(positions):
+    """Pick the position with the largest |delta_pnl|, and compute concentration.
+
+    Returns (best_pos|None, best_abs_pnl, total_abs_pnl, concentration). xyz
+    positions are skipped (XYZ_BANNED). best_pos carries asset/direction/
+    delta_pnl/whale_entry_px. Verbatim from the build_signal position loop.
+    """
+    best_pos = None
+    best_abs_pnl = 0.0
+    total_abs_pnl = 0.0
+    for pos in positions:
+        if not isinstance(pos, dict):
+            continue
+        asset = str(
+            pos.get("coin", pos.get("market", pos.get("asset", pos.get("symbol", ""))))
+        ).upper()
+        if not asset:
+            continue
+        if XYZ_BANNED and asset.lower().startswith("xyz:"):
+            continue
+        delta_pnl = safe_float(
+            pos.get("delta_pnl",
+                    pos.get("deltaPnl",
+                            pos.get("unrealizedPnl",
+                                    pos.get("unrealized_pnl",
+                                            pos.get("pnl", 0)))))
+        )
+        direction = str(
+            pos.get("direction",
+                    pos.get("side",
+                            "LONG" if delta_pnl >= 0 else "SHORT"))
+        ).upper()
+        if direction not in ("LONG", "SHORT"):
+            continue
+        whale_entry_px = safe_float(
+            pos.get("entryPx",
+                    pos.get("entry_px",
+                            pos.get("entryPrice",
+                                    pos.get("entry_price",
+                                            pos.get("avgEntryPx",
+                                                    pos.get("avg_entry_px", 0))))))
+        )
+        abs_pnl = abs(delta_pnl)
+        total_abs_pnl += abs_pnl
+        if abs_pnl > best_abs_pnl:
+            best_abs_pnl = abs_pnl
+            best_pos = {
+                "asset": asset,
+                "direction": direction,
+                "delta_pnl": delta_pnl,
+                "whale_entry_px": whale_entry_px,
+            }
+    concentration = (best_abs_pnl / total_abs_pnl) if total_abs_pnl > 0 else 0
+    return best_pos, best_abs_pnl, total_abs_pnl, concentration
+
+
+def sm_alignment_ok(sm, direction,
+                    min_sm_pct=MIN_SM_PCT, min_sm_traders=MIN_SM_TRADERS,
+                    require_direction_match=REQUIRE_DIRECTION_MATCH):
+    """Smart-money alignment gate (verbatim from build_signal's SM checks).
+
+    `sm` is the per-asset SM record (or None). Returns True only if SM data
+    exists, direction matches (when required), pct >= min_sm_pct, and
+    traders >= min_sm_traders.
+    """
+    if not sm:
+        return False
+    if require_direction_match and sm.get("direction") != direction:
+        return False
+    if safe_float(sm.get("pct", 0)) < min_sm_pct:
+        return False
+    if int(sm.get("traders", 0)) < min_sm_traders:
+        return False
+    return True
+
+
+def entry_discipline_ok(direction, whale_entry_px, current_px,
+                        max_run_pct=MAX_PRICE_RUN_PCT_FROM_WHALE_ENTRY):
+    """v3.3 whale entry-discipline gate: don't buy the whale's top.
+
+    Returns False (skip) when the price has already run more than `max_run_pct`
+    in the whale's favored direction beyond the whale's entry. Only enforced
+    when both prices are positive (matches the source: no price -> don't gate).
+    Verbatim from build_signal's run_pct check.
+    """
+    if whale_entry_px <= 0 or current_px <= 0:
+        return True
+    if direction == "LONG":
+        run_pct = ((current_px - whale_entry_px) / whale_entry_px) * 100
+    else:
+        run_pct = ((whale_entry_px - current_px) / whale_entry_px) * 100
+    return run_pct <= max_run_pct
+
+
+def get_leverage_for_score(score, tiers=LEVERAGE_TIERS, default_leverage=DEFAULT_LEVERAGE):
+    """Conviction-tier leverage: highest matching minScore tier wins.
+
+    Verbatim from producer.get_leverage_for_score.
+    """
+    for tier in sorted(tiers, key=lambda t: t.get("minScore", 0), reverse=True):
+        if score >= tier.get("minScore", 0):
+            return tier.get("leverage", default_leverage)
+    return default_leverage
+
+
+def margin_pct_for_score(score, base=MARGIN_PCT_BASE, high_conv=MARGIN_PCT_HIGH_CONV):
+    """Conviction-tier sizing: high-conviction (score >= 10) sizes up.
+
+    Verbatim from producer.main's margin_pct selection.
+    """
+    return high_conv if score >= 10 else base
+
+
+def clamp_leverage(desired, venue_max):
+    """Clamp desired leverage to the asset's Hyperliquid venue max.
+
+    Port of producer.get_safe_leverage's min(requested, venue_max) with a
+    safe-default fallback (the source defaulted the venue cap to 20 when the
+    limits payload lacked a usable value; here a missing/<=0 venue_max means we
+    keep the desired leverage and let the runtime clamp further if needed).
+    """
+    try:
+        venue = int(float(venue_max))
+    except (TypeError, ValueError):
+        venue = desired
+    if venue <= 0:
+        venue = desired
+    return max(1, min(int(desired), venue))
+
+
+# ── Additive scoring (verbatim tier-for-tier from build_signal) ──
+
+def score_position(trader, best_pos, concentration, sm, current_px):
+    """Compute the additive copy-follow score (max ~16) for a candidate.
+
+    ALL tiers ported VERBATIM from build_signal's scoring block:
+      - TCS:        ELITE +3, RELIABLE +2, else -> None (reject)
+      - trader $:   >= $3M +3, >= $1.5M +2, else +1
+      - ROI:        >= 50% +1
+      - conc:       >= 0.70 +2, >= 0.55 +1
+      - SM pct:     >= 8 +2, >= 4 +1
+      - 4h/1h:      directional confirm +2 / +1, opposing -1
+      - 15m:        contrib > 0.5 +1, <= 0 -1
+      - edge bonus: better-than-whale +2 (>=5%) / +1 (>=2%)
+
+    Returns (score, reasons) or None when TCS is neither ELITE nor RELIABLE.
+    `current_px` may be 0 (entry-discipline bonus only fires with a real price).
+    """
+    direction = best_pos["direction"]
+    whale_entry_px = safe_float(best_pos.get("whale_entry_px", 0))
+    score = 0
+    reasons = []
+
+    tcs = trader["tcs_label"]
+    if tcs == "ELITE":
+        score += 3
+        reasons.append(f"ELITE_tcs{trader['tcs_value']:.0f}")
+    elif tcs == "RELIABLE":
+        score += 2
+        reasons.append(f"RELIABLE_tcs{trader['tcs_value']:.0f}")
+    else:
+        return None
+
+    trader_delta = trader["unrealized_pnl"]
+    if trader_delta >= TIER3_TRADER_THRESHOLD:
+        score += 3
+        reasons.append(f"TIER3_${trader_delta/1e6:.1f}M")
+    elif trader_delta >= TIER2_TRADER_THRESHOLD:
+        score += 2
+        reasons.append(f"TIER2_${trader_delta/1e6:.1f}M")
+    else:
+        score += 1
+        reasons.append(f"TIER1_${trader_delta/1e6:.1f}M")
+
+    if trader["roi"] >= 50:
+        score += 1
+        reasons.append(f"ROI_{trader['roi']:.0f}%")
+
+    if concentration >= 0.70:
+        score += 2
+        reasons.append(f"HIGH_CONV_{concentration:.0%}")
+    elif concentration >= 0.55:
+        score += 1
+        reasons.append(f"CONC_{concentration:.0%}")
+
+    if sm["pct"] >= 8:
+        score += 2
+        reasons.append(f"SM_STRONG_{sm['pct']:.1f}%")
+    elif sm["pct"] >= 4:
+        score += 1
+        reasons.append(f"SM_ALIGNED_{sm['pct']:.1f}%")
+
+    p4h = sm["price_chg_4h"]
+    p1h = sm["price_chg_1h"]
+    if direction == "LONG":
+        if p4h > 0.5 and p1h > 0.2:
+            score += 2
+            reasons.append(f"4H+1H_CONFIRMS_+{p4h:.1f}/+{p1h:.1f}%")
+        elif p4h > 0.5:
+            score += 1
+            reasons.append(f"4H_CONFIRMS_+{p4h:.1f}%")
+        elif p4h < -2:
+            score -= 1
+            reasons.append(f"4H_OPPOSING_{p4h:.1f}%")
+    else:
+        if p4h < -0.5 and p1h < -0.2:
+            score += 2
+            reasons.append(f"4H+1H_CONFIRMS_{p4h:.1f}/{p1h:.1f}%")
+        elif p4h < -0.5:
+            score += 1
+            reasons.append(f"4H_CONFIRMS_{p4h:.1f}%")
+        elif p4h > 2:
+            score -= 1
+            reasons.append(f"4H_OPPOSING_+{p4h:.1f}%")
+
+    c15m = sm.get("contrib_15m", 0)
+    if c15m > 0.5:
+        score += 1
+        reasons.append(f"15M_SPIKE_+{c15m:.2f}")
+    elif c15m <= 0:
+        score -= 1
+        reasons.append(f"15M_STALE_{c15m:.2f}")
+
+    # v3.2 entry-discipline BONUS (better-than-whale entry)
+    if whale_entry_px > 0 and current_px > 0:
+        if direction == "LONG":
+            edge_pct = ((whale_entry_px - current_px) / whale_entry_px) * 100
+        else:
+            edge_pct = ((current_px - whale_entry_px) / whale_entry_px) * 100
+        if edge_pct >= 5:
+            score += 2
+            reasons.append(f"BETTER_THAN_WHALE_+{edge_pct:.1f}%")
+        elif edge_pct >= 2:
+            score += 1
+            reasons.append(f"EDGE_VS_WHALE_+{edge_pct:.1f}%")
+
+    return score, reasons
+
+
+# ── Per-(trader, asset) event dedup (verbatim from producer dedup helpers) ──
+
+def dedup_key(trader_id, asset):
+    """Stable per-(trader, asset) dedup key. Verbatim from the producer:
+    first 10 chars of the trader address (lowercased) + the asset symbol."""
+    return f"{trader_id[:10].lower()}:{asset}"
+
+
+def is_event_seen(seen, trader_id, asset, dedupe_hours=EVENT_DEDUPE_HOURS, now=None):
+    """True if (trader, asset) was signaled within `dedupe_hours`. `seen` is a
+    {key: epoch_seconds} map. Verbatim from producer.is_event_seen."""
+    import time as _time
+    if now is None:
+        now = _time.time()
+    ts = seen.get(dedup_key(trader_id, asset), 0)
+    if ts <= 0:
+        return False
+    return (now - ts) < (dedupe_hours * 3600)
+
+
+def prune_seen_events(seen, dedupe_hours=EVENT_DEDUPE_HOURS, now=None):
+    """Drop dedup entries older than the window (bounds the map). Verbatim from
+    producer.save_seen_events's cutoff filter."""
+    import time as _time
+    if now is None:
+        now = _time.time()
+    cutoff = now - (dedupe_hours * 3600)
+    return {k: v for k, v in seen.items() if v > cutoff}

package/examples/strategies/spider/README.md

@@ -0,0 +1,89 @@
+# SPIDER (v2 supervised demo)
+
+Spider is a **two-leg** strategy. The two legs are genuinely different theses on
+separate wallets — not mirror images — so each is its own v2 recipe + supervised
+`scan(inputs, ctx)`.
+
+Ported from `senpi-skills/spider` (producer v5.1.1) to the runtime v2 supervised
+external-scanner contract. The standalone producer daemon is gone; the runtime
+supervises each leg's `scanners/scan.py` and calls `scan()` on the recipe's
+`interval_seconds`.
+
+## The two legs
+
+| Leg     | Thesis                                      | Direction | Universe | Tick | minScore | Slots | DSL |
+|---------|---------------------------------------------|-----------|----------|------|----------|-------|-----|
+| `swing` | Tech & AI multi-day momentum                | LONG only | dynamic XYZ tech/AI pool + crypto alts | 300s | 5 | 3 @ marginPct 0.28 | wide, all time-cuts off, 7d hard timeout |
+| `scalp` | Macro & majors fast mean-reversion          | LONG + SHORT | majors (BTC/ETH/SOL/HYPE) + energy (xyz:BRENTOIL/xyz:CL) | 60s | 4 | 4 @ marginPct 0.15 | tight, weak_peak + dead_weight on, 2h hard timeout |
+
+- **swing** scores 4h/1h trend structure + 24h relative strength + RSI room +
+  funding + smart-money consensus. Its universe is rebuilt each tick from the
+  live instrument board (curated tech/AI/space include-set + auto-caught
+  freshly-listed names, minus a commodity/FX/index exclude-set).
+- **scalp** fades short-timeframe stretch (15m RSI extreme + stretch from a
+  20-bar MA) with a 1h trend filter so it doesn't catch a falling knife.
+
+Both recipes set `group: spider` — the agent-facing handle that ties the legs
+together.
+
+## Layout
+
+```
+spider/
+├── README.md
+├── swing/
+│   ├── recipe.yaml
+│   └── scanners/
+│       ├── scan.py        # scan(inputs, ctx) entrypoint
+│       └── scoring.py     # pure scoring functions (unit-tested)
+└── scalp/
+    ├── recipe.yaml
+    └── scanners/
+        ├── scan.py
+        └── scoring.py
+```
+
+## Environment variables
+
+| Variable               | Required | Purpose |
+|------------------------|----------|---------|
+| `SPIDER_SWING_WALLET`  | swing    | Swing-leg strategy wallet |
+| `SPIDER_SCALP_WALLET`  | scalp    | Scalp-leg strategy wallet |
+| `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 |
+
+The two legs run as two separate strategies on two separate wallets. Fund both
+wallets before enabling; the source's suggested split is swing 60% / scalp 40%
+of the combined pool.
+
+## Install / run
+
+Run each leg as its own runtime instance, pointing at its recipe:
+
+```bash
+SPIDER_SWING_WALLET=0x... \
+SENPI_API_KEY=... SENPI_MCP_URL=https://mcp.prod.senpi.ai/mcp \
+  openclaw senpi run examples/strategies/spider/swing/recipe.yaml
+
+SPIDER_SCALP_WALLET=0x... \
+SENPI_API_KEY=... SENPI_MCP_URL=https://mcp.prod.senpi.ai/mcp \
+  openclaw senpi run examples/strategies/spider/scalp/recipe.yaml
+```
+
+## Sizing note
+
+The source producer computed `margin_usd = account_value * marginPct` and then
+emitted at most `min(open_slots, affordable)` signals per tick, where
+`affordable` was derived from free margin. In v2 the runtime owns slot count and
+affordability (`strategy.slots` + the `risk.guard_rails`), so `scan()` emits
+**every** candidate that clears `minScore` (after filtering held + recently
+signaled assets) and carries the computed `marginUsd` + venue-clamped `leverage`
+on each signal's `data{}`. The signal-gating thresholds are unchanged; only the
+per-tick emission cap moved to the runtime.
+
+## Action gate
+
+The source's `OPEN_POSITION` action used `decision_mode: llm` with a
+copy-verbatim pass-through prompt and a pinned confidence — i.e. a rule wearing
+an LLM costume. The v2 recipes use `decision_mode: rule` directly.

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

@@ -0,0 +1,129 @@
+# ── SPIDER · SCALP leg (v2 supervised) ──────────────────────────────
+# Macro & majors fast mean-reversion, BOTH directions.
+#
+# Ported from senpi-skills/spider (producer v5.1.1, SPIDER_LEG=scalp) 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-scalp
+version: 2.0.0
+group: spider                       # agent-facing handle (BOTH legs share it)
+description: >
+  SPIDER SCALP — Macro & majors fast mean-reversion, BOTH directions. Scores a
+  fixed universe (BTC/ETH/SOL/HYPE + energy xyz:BRENTOIL/xyz:CL) on 15m RSI
+  extreme + stretch from a 20-bar MA, with a 1h trend filter to avoid fading a
+  strong trend. minScore 4; strict 5x; tight fast-capture DSL with dead_weight
+  + weak_peak cuts on, 2h staleness cap. Paired with the SWING leg on a
+  separate wallet.
+
+strategy:
+  wallet: "${SPIDER_SCALP_WALLET}"
+  slots: 4                          # source maxSlots 4
+  margin_pct: 15                    # source marginPct 0.15 → margin_usd = account_value * 0.15
+  default_leverage: 5               # source scalpMaxLeverage 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_scalp_signals      # supervised external scanner
+    type: external_scanner
+    path: ./scanners
+    entrypoint: scan.py
+    interval_seconds: 60            # source tickSeconds 60
+    timeout_seconds: 50             # source tick_timeout = min(180, max(30, tick-10)) = 50
+    default_signal_validity_seconds: 120   # 2x tick; pass-through gate re-scores next tick
+    state_history_max_count: 200    # holds recent-signal dedup records
+    inputs:
+      allowedAssets: ["BTC", "ETH", "SOL", "HYPE", "xyz:BRENTOIL", "xyz:CL"]
+      minScore: 4
+      marginPct: 0.15
+      maxLeverage: 5
+      maxSlots: 4
+      rsiOversold: 30
+      rsiOverbought: 70
+      stretchThresholdPct: 0.8
+      venueMinNotionalUsd: 10
+      minNotionalPctOfEquity: 0.01
+      recentSignalTtlSeconds: 180
+    signal_data_schema:
+      score: { type: number }
+      direction: { type: string }
+      reasons: { type: array, required: false }
+      trend1h: { type: string, required: false }
+      rsi: { type: number, required: false }
+      stretchPct: { 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_scalp_entry        # OPEN_POSITION, rule mode (source LLM gate was pure pass-through)
+    action_type: OPEN_POSITION
+    decision_mode: rule
+    scanners: [spider_scalp_signals]
+    params:
+      order_type: FEE_OPTIMIZED_LIMIT
+      fee_optimized_limit_options:
+        ensure_execution_as_taker: true
+        execution_timeout_seconds: 20
+    context:
+      - type: signal
+        scanner: spider_scalp_signals
+
+# ── EXIT (DSL — tight fast-capture; the source flips in minutes) ──
+exit:
+  engine: dsl
+  interval_seconds: 30
+  order_type: FEE_OPTIMIZED_LIMIT
+  fee_optimized_limit_options:
+    ensure_execution_as_taker: true
+    execution_timeout_seconds: 20
+  dsl_preset:
+    hard_timeout:
+      enabled: true
+      interval_in_minutes: 120      # 2h — a scalp that lingers is dead
+    weak_peak_cut:
+      enabled: true
+      interval_in_minutes: 30       # if it hasn't moved in 30m, cut
+      min_value: 1.5
+    dead_weight_cut:
+      enabled: true
+      interval_in_minutes: 25       # at/below break-even after 25m → cut
+    phase1:
+      enabled: true
+      max_loss_pct: 5.0
+      retrace_threshold: 3
+      consecutive_breaches_required: 1
+    phase2:
+      enabled: true
+      tiers:
+        - { trigger_pct: 3, lock_hw_pct: 35 }
+        - { trigger_pct: 6, lock_hw_pct: 55 }
+        - { trigger_pct: 12, lock_hw_pct: 70 }
+        - { trigger_pct: 25, lock_hw_pct: 85 }
+
+# ── RISK guard rails (from runtime-scalp.yaml; minutes → seconds) ──
+risk:
+  data_retention_seconds: 259200    # 72h (was data_retention_hours 72)
+  guard_rails:
+    daily_loss_limit_pct: 10
+    max_entries_per_day: 18
+    bypass_max_entries_per_day_on_profit: false
+    max_consecutive_losses: 5
+    cooldown_seconds: 1800          # was cooldown_minutes 30
+    drawdown_halt_pct: 20
+    drawdown_reset_on_day_rollover: false
+    per_asset_cooldown_seconds: 600     # was per_asset_cooldown_minutes 10
+
+notifications:
+  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
+  dsl_lifecycle: true
+  dsl_notify_sl_updates: false
+  action_lifecycle: true