@senpi/runtime 3.0.9-dev.feat-strategy-compos.20260721003344 → 3.0.9-dev.feat-strategy-compos.20260722213012

package/dist/composer/examples/contrarian_fade_crowd.graph.yaml

@@ -0,0 +1,356 @@
+# contrarian_fade strategy — machine-generated anchor (composer new).
+#
+# Fade an overextended move: detect an RSI extreme confirmed by a recent price run and enter the
+# OPPOSITE direction (SHORT an overbought rip, LONG an oversold flush), betting on mean reversion.
+# fade_crowd additionally requires the crowd (smart-money lean) to be piling in AND the market-wide
+# funding regime to permit the fade; fade_price fades pure price. A hysteresis-free reversion exit
+# closes when RSI crosses back through the midline or the move invalidates the fade, with
+# held-exclusion built in. Edit ONLY the pure_fn body (the EDGE slot) to move it toward your edge;
+# every intermediate state stays valid (`composer check`).
+
+version: 1
+
+metadata:
+  archetype: contrarian_fade
+  strategy: fade_crowded_majors
+  generated:
+    by: "composer new"
+    content_hash: "ecafe30f1dfa5bbe64cb08ac68e0a6c75993ea4bc2a7a9d3e73fb749c16fdb72"
+    structure_hash: "841ef7ce490e1e6e733135f0b01af847315948f80e7a88272bf58356277c9fc5"
+  spec:
+    version: 2
+    archetype: contrarian_fade
+    strategy: fade_crowded_majors
+    thesis: "fade the crowd: when a liquid major rips 3%+ in ~4h and smart money is piled in on that side, the late entrants are maximally exposed — short the overbought rip / buy the oversold flush and ride th..."
+    universe:
+      whitelist: ["BTC", "ETH", "SOL", "HYPE"]
+      long_basket: []
+      short_basket: []
+      discover: false
+      dex: ""
+      name_prefix: ""
+      max_leverage_cap: 5.0
+      min_day_volume: 0.0
+    intervals: ["4h"]
+    max_positions: 1
+    dedup_seconds: 240
+    exit_preset: protected_wide
+    unmanaged: false
+    protection:
+      seeded_from: protected_wide
+      interval_seconds: 60
+      dsl_preset:
+        hard_timeout:
+          enabled: true
+          interval_in_minutes: 20160
+        weak_peak_cut:
+          enabled: false
+          interval_in_minutes: 240
+        dead_weight_cut:
+          enabled: false
+          interval_in_minutes: 480
+        phase1:
+          enabled: true
+          max_loss_pct: 25.0
+          retrace_threshold: 15
+          consecutive_breaches_required: 2
+        phase2:
+          enabled: true
+          tiers:
+            - trigger_pct: 15
+              lock_hw_pct: 0
+            - trigger_pct: 30
+              lock_hw_pct: 30
+            - trigger_pct: 60
+              lock_hw_pct: 55
+            - trigger_pct: 120
+              lock_hw_pct: 72
+            - trigger_pct: 250
+              lock_hw_pct: 85
+      guard_rails:
+        daily_loss_limit_pct: 15
+        max_consecutive_losses: 4
+        cooldown_seconds: 3600
+        drawdown_halt_pct: 25
+        drawdown_reset_on_day_rollover: false
+        per_asset_cooldown_seconds: 1800
+    risk:
+      margin_pct: 5.0
+      leverage: 3.0
+      drawdown_halt_pct: null
+      max_consecutive_losses: null
+      cooldown_seconds: null
+      max_entries_per_day: null
+    edge: "fade the crowd: when a liquid major rips 3%+ in ~4h and smart money is piled in on that side, the late entrants are maximally exposed — short the overbought rip / buy the oversold flush and ride the mean reversion; step aside when RSI reverts through the midline."
+    requires: []
+    exit_signals:
+      interval_seconds: 300
+      enter_threshold: 3.0
+      exit_threshold: 2.0
+      reentry_cooldown_seconds: 1800
+    contrarian_fade:
+      use_crowd: true
+      overbought_rsi: 70.0
+      oversold_rsi: 30.0
+      min_extension_pct: 3.0
+      crowd_threshold: 0.15
+  # EDGE (verbatim, machine never interprets): "fade the crowd: when a liquid major rips 3%+ in ~4h and smart money is piled in on that side, the late entrants are maximally exposed — short the overbought rip / buy the oversold flush and ride the mean reversion; step aside when RSI reverts through the midline."
+
+nodes:
+  # sources: account equity for sizing. NO held-exclusion at the universe level —
+  # it lives in the pure_fn (fade only when flat, exit only when held).
+  - id: account
+    node: clearinghouse_state
+  # open positions (held + direction): in-fn held-exclusion + the exit tail's REAL
+  # held-direction stamp. Kept even in the entry-only variant (no-pyramiding).
+  - id: positions
+    node: open_positions
+  # candle reads over the fixed fade basket.
+  - id: candles
+    node: candles_fetch
+    with:
+      whitelist: ["BTC", "ETH", "SOL", "HYPE"]
+      intervals: ["4h"]
+  # overextension read: RSI extreme + a recent price run.
+  - id: rsi
+    node: rsi
+    with:
+      period: 14
+      interval: "4h"
+  - id: move
+    node: pct_change
+    with:
+      lookback: 6
+      interval: "4h"
+  # crowd read: smart-money lean (fade only WITH the crowd) + the funding regime gate.
+  - id: lean
+    node: sm_lean
+    with:
+      agree_threshold: 0.6   # TODO(edit): smart-money agreement band (fade corpus 0.55-0.60).
+  - id: regime
+    node: funding_regime_fetch
+  # ---------------------------------------------------------------
+  # EDGE (verbatim — the machine did NOT interpret this; encode it
+  # by editing the TODO slots on this scoring node):
+  #   fade the crowd: when a liquid major rips 3%+ in ~4h and smart money is piled in on that side, the late entrants are maximally exposed — short the overbought rip / buy the oversold flush and ride the mean reversion; step aside when RSI reverts through the midline.
+  # ---------------------------------------------------------------
+  # pure_fn signed-fade scorer (crowd) — THE EDGE SLOT (edit the body; see the EDGE
+  # block above). TWO outputs: entry_scores (entry tail) + exit_scores (exit tail).
+  - id: score
+    kind: pure_fn
+    title: "crowd fade: RSI/price overextension the smart-money crowd is piling into"
+    inputs:
+      - { name: rsi, type: feature_map, doc: "Per-asset RSI in [0,100]." }
+      - { name: move, type: feature_map, doc: "Per-asset recent percent return (extension)." }
+      - { name: sm, type: feature_map, doc: "Per-asset smart-money tilt in [0,1] (0.5 neutral)." }
+      - { name: regime, type: label, doc: "Market-wide funding regime (LONG_CROWDED|SHORT_CROWDED|NEUTRAL): the fade master gate." }
+      - { name: positions, type: record_list, doc: "Open positions (from open_positions) — held-exclusion + exit direction." }
+    outputs:
+      - { name: entry_scores, type: score_map, doc: "ENTER the FADE (opposite the exhausted move) when overextended and FLAT." }
+      - { name: exit_scores, type: score_map, doc: "CLOSE a held fade when RSI crosses back through the 50 midline OR the move invalidates it." }
+    params:
+      - { name: overbought_rsi, type: float, default: 70.0, doc: "RSI at/above which an up-move is exhausted (fade SHORT)." }
+      - { name: oversold_rsi, type: float, default: 30.0, doc: "RSI at/below which a down-move is exhausted (fade LONG)." }
+      - { name: min_extension_pct, type: float, default: 3.0, doc: "|recent return %| that qualifies a move as overextended (dog 3%+/~4h)." }
+      - { name: crowd_threshold, type: float, default: 0.15, doc: "Smart-money lean deviation from 0.5 that counts as crowded (dog ~15%+)." }
+      - { name: invalidation_factor, type: float, default: 2.0, doc: "A held fade is INVALIDATED when the move extends past this multiple of min_extension_pct while the RSI extreme is unresolved (the crowd kept pushing)." }
+      - { name: signal_strength, type: float, default: 1.0, doc: "Per-signal score unit multiplier." }
+    fn: |
+      def score_fade_crowd(rsi, move, sm, regime, positions, overbought_rsi, oversold_rsi, min_extension_pct, crowd_threshold, invalidation_factor, signal_strength):
+          # TODO(edit): the CROWD-FADE edge (a WORKING DEFAULT; dog/lemon/egret/owl + hyena regime gate).
+          # For each asset, an OVEREXTENSION is an RSI extreme confirmed by a recent price run: overbought =
+          # rsi >= overbought_rsi AND move (recent % return) >= min_extension_pct; oversold is the mirror.
+          # Fade it ONLY when the CROWD is aligned WITH the exhausted move (smart-money tilt in [0,1], 0.5
+          # neutral: crowded-long = tilt >= 0.5+crowd_threshold) AND the market-wide funding regime PERMITS
+          # the fade (LONG_CROWDED -> only SHORT fades; SHORT_CROWDED -> only LONG fades; NEUTRAL/"" -> both).
+          # ENTER the OPPOSITE direction when FLAT. EXIT a held fade when MEAN REVERSION IS COMPLETE (RSI
+          # crossed back through the 50 midline) OR the THESIS IS INVALIDATED (the move extended further
+          # against the fade). Held-exclusion + the real held direction live here (via positions) so entry
+          # and exit can never both fire. A missing leg simply abstains (no vote), never raises. Encode YOUR
+          # edge by editing this body — it is purity-checked (no ctx/MCP/I/O, math only) and its inline tests
+          # run at validate time.
+          reg = (regime or "").upper()
+          allow_short = reg != "SHORT_CROWDED"
+          allow_long = reg != "LONG_CROWDED"
+          held = {}
+          for record in positions or []:
+              coin = str(record.get("coin", "")).upper()
+              if coin:
+                  held[coin] = record.get("direction") or "LONG"
+          entry_scores = {}
+          exit_scores = {}
+          for asset in sorted(set(rsi) | set(move)):
+              r = rsi.get(asset)
+              mv = move.get(asset)
+              if r is None or mv is None:
+                  continue
+              raw = sm.get(asset, 0.5)
+              tilt = raw.get("tilt", raw.get("lean", 0.5)) if isinstance(raw, dict) else raw
+              crowd_long = tilt >= 0.5 + crowd_threshold
+              crowd_short = tilt <= 0.5 - crowd_threshold
+              overbought = r >= overbought_rsi and mv >= min_extension_pct
+              oversold = r <= oversold_rsi and mv <= -min_extension_pct
+              held_direction = held.get(str(asset).upper())
+              if held_direction is None:
+                  if overbought and crowd_long and allow_short:
+                      score = signal_strength * (abs(r - overbought_rsi) + abs(mv))
+                      entry_scores[asset] = {"score": round(score, 4), "direction": "SHORT",
+                                             "reasons": ["overbought_rip", "crowd_long"]}
+                  elif oversold and crowd_short and allow_long:
+                      score = signal_strength * (abs(oversold_rsi - r) + abs(mv))
+                      entry_scores[asset] = {"score": round(score, 4), "direction": "LONG",
+                                             "reasons": ["oversold_flush", "crowd_short"]}
+              else:
+                  if held_direction == "SHORT":
+                      reverted = r <= 50.0
+                      invalidated = r >= overbought_rsi and mv >= min_extension_pct * invalidation_factor
+                  else:
+                      reverted = r >= 50.0
+                      invalidated = r <= oversold_rsi and mv <= -min_extension_pct * invalidation_factor
+                  if reverted or invalidated:
+                      exit_scores[asset] = {"score": round(abs(mv), 4), "direction": held_direction,
+                                            "reasons": ["reversion_complete" if reverted else "thesis_invalidated"]}
+          return entry_scores, exit_scores
+    tests:
+      - name: crowd_long_overbought_fade_short
+        inputs:
+          rsi:
+            BTC: 75.0
+          move:
+            BTC: 5.0
+          sm:
+            BTC: 0.75
+          regime: NEUTRAL
+          positions: []
+        expect:
+          entry_scores:
+            BTC:
+              score: 10.0
+              direction: SHORT
+              reasons: ["overbought_rip", "crowd_long"]
+          exit_scores: {}
+      - name: crowd_short_oversold_fade_long
+        inputs:
+          rsi:
+            ETH: 25.0
+          move:
+            ETH: -5.0
+          sm:
+            ETH: 0.24999999999999997
+          regime: NEUTRAL
+          positions: []
+        expect:
+          entry_scores:
+            ETH:
+              score: 10.0
+              direction: LONG
+              reasons: ["oversold_flush", "crowd_short"]
+          exit_scores: {}
+      - name: regime_vetoes_long_fade
+        inputs:
+          rsi:
+            ETH: 25.0
+          move:
+            ETH: -5.0
+          sm:
+            ETH: 0.24999999999999997
+          regime: LONG_CROWDED
+          positions: []
+        expect:
+          entry_scores: {}
+          exit_scores: {}
+      - name: crowd_not_aligned_no_entry
+        inputs:
+          rsi:
+            BTC: 75.0
+          move:
+            BTC: 5.0
+          sm:
+            BTC: 0.5
+          regime: NEUTRAL
+          positions: []
+        expect:
+          entry_scores: {}
+          exit_scores: {}
+      - name: reversion_complete_exit_when_held
+        inputs:
+          rsi:
+            BTC: 45.0
+          move:
+            BTC: 0.0
+          sm:
+            BTC: 0.5
+          regime: NEUTRAL
+          positions:
+            - coin: BTC
+              direction: SHORT
+              szi: -1.0
+              entry_px: 100.0
+              unrealized_pnl_pct: 1.0
+              margin_used: 10.0
+        expect:
+          entry_scores: {}
+          exit_scores:
+            BTC:
+              score: 0.0
+              direction: SHORT
+              reasons: ["reversion_complete"]
+      - name: thesis_invalidated_exit_when_held
+        inputs:
+          rsi:
+            BTC: 75.0
+          move:
+            BTC: 7.0
+          sm:
+            BTC: 0.75
+          regime: NEUTRAL
+          positions:
+            - coin: BTC
+              direction: SHORT
+              szi: -1.0
+              entry_px: 100.0
+              unrealized_pnl_pct: 1.0
+              margin_used: 10.0
+        expect:
+          entry_scores: {}
+          exit_scores:
+            BTC:
+              score: 7.0
+              direction: SHORT
+              reasons: ["thesis_invalidated"]
+  # ranker: single best candidate (cardinality = 1).
+  - id: best
+    node: emit_single_best
+    with:
+      min_score: 0
+  # entry emitter: build the scan() OPEN signal list.
+  - id: emit
+    node: signal_envelope
+    with:
+      margin_pct: 5.0
+      leverage: 3.0
+  # exit emitter: reduce-only CLOSE list (no sizing/equity). The compiler splits
+  # this into a second, exit-only scanner; the DSL preset stays as the safety net.
+  - id: close_emit
+    node: close_signal_envelope
+    with:
+      signal_type: "thesis_exit"
+
+edges:
+  # score -> rank -> emit
+  - { from: score.entry_scores, to: best.scores }
+  # candles fan out to the overextension read
+  - { from: candles.candles, to: rsi.candles }
+  - { from: candles.candles, to: move.candles }
+  # overextension + positions -> the fade pure_fn
+  - { from: rsi.rsi, to: score.rsi }
+  - { from: move.pct, to: score.move }
+  - { from: lean.lean, to: score.sm }
+  - { from: regime.regime, to: score.regime }
+  - { from: positions.positions, to: score.positions }
+  # entry tail: entry_scores -> rank -> emit
+  - { from: best.selected, to: emit.selected }
+  - { from: account.equity, to: emit.equity }
+  # exit tail: exit_scores -> close emitter (+ positions for direction)
+  - { from: score.exit_scores, to: close_emit.selected }
+  - { from: positions.positions, to: close_emit.positions }