@senpi/runtime 3.0.9-dev.20260710204324 → 3.0.9-dev.feat-strategy-compos.20260716013009

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

@@ -0,0 +1,216 @@
+# conviction_scorer — trend/conviction strategy (tier 2) over a BTC/ETH/SOL whitelist, as a
+# typed dataflow DAG whose conviction SCORER is a per-graph pure_fn node (D2 kind 2).
+#
+# Why a pure_fn here (the slice-4 point): this strategy's scoring is not a registry scorer
+# pattern. Its direction is chosen by a WATERFALL (4h trend -> SM lean -> 1h momentum) and
+# then EVERY other signal is a weighted SCORE CONTRIBUTOR, not a hard gate — a CROSS-FEATURE
+# computation the generic weighted-sum scorer cannot express (this is exactly the
+# vocabulary-limit the slice-3 outcome flagged; pure_fn is the pressure valve, D2). The fn
+# body re-expresses the corpus package bison's `build_thesis` conviction math
+# (corpus: /Users/duncan/Senpi/skills/strategies/bison/main/scanners/scoring.py) — cited in
+# the body — and is statically purity-checked (no ctx/MCP/I/O) with inline fixture tests.
+#
+# Correctness = the slice-4 composed goldens (python-tests/composer), not the original's bit
+# output. Feature keys flowing into the pure_fn are its DECLARED input ports (each a single
+# writer), not a merge record — a pure_fn declares its typed inputs explicitly.
+
+version: 1
+
+metadata:
+  archetype: trend_conviction
+  strategy: conviction_scorer
+  corpus_origin: bison                # provenance only, for fidelity replay — not user-facing
+  exit_preset: protected_wide         # slice 9: emitted as runtime.yaml exit: (bison = conviction hold)
+  # EDGE (verbatim, machine never interprets): "stack conviction when the 4h structure,
+  # smart money, 1h momentum and volume all line up behind one direction; size up on the
+  # strongest read and ride it."
+
+nodes:
+  # --- sources ---
+  - id: account
+    node: clearinghouse_state          # held-asset set + dual-DEX max() equity
+
+  - id: dedup_state
+    node: ttl_dedup_state              # ctx.state TTL dedup; `recent` = assets within TTL
+    with:
+      ttl_seconds: 180                 # conviction_scorer's 180s dedup window
+
+  # --- universe narrowing (held-exclusion then recent-signal dedup) ---
+  - id: exclude_held
+    node: held_asset_exclusion         # candidates default to the whitelist universe
+
+  - id: exclude_recent
+    node: recent_signal_ttl_dedup
+
+  # --- candle + leaderboard reads over the narrowed universe ---
+  - id: candles
+    node: candles_fetch
+    with:
+      whitelist: ["BTC", "ETH", "SOL"]
+      intervals: ["1h", "4h"]
+
+  - id: lean
+    node: sm_lean
+    with:
+      agree_threshold: 0.58            # conviction_scorer's own 58/42 band
+
+  # --- indicators feeding the conviction scorer (cross-feature) ---
+  - id: trend4h
+    node: trend_structure              # 4h higher-lows/lower-highs -> BULLISH/BEARISH/NEUTRAL
+    with:
+      lookback: 6
+      interval: "4h"
+
+  - id: mom1h
+    node: pct_change                   # bison price_momentum: 1h percent change
+    with:
+      lookback: 1
+      interval: "1h"
+
+  - id: vol
+    node: volume_surge_ratio           # bison volume_trend, re-expressed as recent/baseline
+    with:
+      recent_window: 1
+      baseline_window: 3
+      interval: "1h"
+
+  - id: rsi1h
+    node: rsi                          # bison calc_rsi (trailing-window RSI over 1h closes)
+    with:
+      period: 4                        # short period so the conviction rsi-room test is cheap
+      interval: "1h"
+
+  # --- pure_fn conviction scorer (the bespoke, cross-feature edge; D2 kind 2) ---
+  - id: score
+    kind: pure_fn
+    inputs:
+      - { name: trend4h, type: feature_map, doc: "4h trend structure (BULLISH/BEARISH/NEUTRAL)." }
+      - { name: momentum, type: feature_map, doc: "1h percent momentum." }
+      - { name: sm, type: feature_map, doc: "Smart-money long lean percent [0,100]." }
+      - { name: vol, type: feature_map, doc: "Recent/baseline volume ratio." }
+      - { name: rsi, type: feature_map, doc: "Trailing-window RSI [0,100] over 1h closes." }
+    outputs:
+      - { name: scores, type: score_map, doc: "Per-asset {score, direction, reasons[]}." }
+    params:
+      - { name: min_score, type: float, default: 5, doc: "Minimum conviction to keep a candidate." }
+    fn: |
+      def score_conviction(trend4h, momentum, sm, vol, rsi, min_score):
+          # Bison (tier 2): direction is the ONLY gate — a 4h-trend -> SM-lean -> 1h-momentum
+          # WATERFALL — after which every signal is a weighted SCORE CONTRIBUTOR, not a hard
+          # gate. Ported from bison/main/scanners/scoring.py build_thesis (9-component
+          # conviction); if no direction resolves the asset is skipped (v2 returns None). The
+          # RSI component reproduces build_thesis's rsi rule verbatim: overbought/oversold
+          # penalises, room rewards (>72/<55 for LONG; <28/>45 for SHORT).
+          scores = {}
+          assets = sorted(set(trend4h) | set(momentum) | set(sm) | set(vol) | set(rsi))
+          for asset in assets:
+              t4 = trend4h.get(asset, "NEUTRAL")
+              lean = sm.get(asset)
+              mom = momentum.get(asset, 0.0)
+              if t4 == "BULLISH":
+                  direction = "LONG"
+              elif t4 == "BEARISH":
+                  direction = "SHORT"
+              elif lean is not None and lean >= 55.0:
+                  direction = "LONG"
+              elif lean is not None and lean <= 45.0:
+                  direction = "SHORT"
+              elif mom > 0.0:
+                  direction = "LONG"
+              elif mom < 0.0:
+                  direction = "SHORT"
+              else:
+                  continue
+              score = 0.0
+              reasons = []
+              if (direction == "LONG" and t4 == "BULLISH") or (direction == "SHORT" and t4 == "BEARISH"):
+                  score = score + 4.0
+                  reasons.append("trend4h_aligned")
+              if (direction == "LONG" and mom > 0.0) or (direction == "SHORT" and mom < 0.0):
+                  score = score + 3.0
+                  reasons.append("momentum_aligned")
+              if lean is not None:
+                  aligned = lean >= 55.0 if direction == "LONG" else (100.0 - lean) >= 55.0
+                  if aligned:
+                      score = score + 2.0
+                      reasons.append("sm_aligned")
+              if vol.get(asset, 0.0) >= 1.0:
+                  score = score + 1.0
+                  reasons.append("volume_ok")
+              r = rsi.get(asset)
+              if r is not None:
+                  if direction == "LONG":
+                      if r > 72.0:
+                          score = score - 1.0
+                          reasons.append("rsi_overbought")
+                      elif r < 55.0:
+                          score = score + 1.0
+                          reasons.append("rsi_room")
+                  else:
+                      if r < 28.0:
+                          score = score - 1.0
+                          reasons.append("rsi_oversold")
+                      elif r > 45.0:
+                          score = score + 1.0
+                          reasons.append("rsi_room")
+              if score < min_score:
+                  continue
+              scores[asset] = {"score": round(score, 4), "direction": direction, "reasons": reasons}
+          return scores
+    tests:
+      - name: full_conviction_long
+        inputs:
+          trend4h: { BTC: BULLISH }
+          momentum: { BTC: 10.0 }
+          sm: { BTC: 60.0 }
+          vol: { BTC: 1.0 }
+          rsi: { BTC: 50.0 }
+        expect:
+          scores:
+            BTC: { score: 11.0, direction: LONG, reasons: [trend4h_aligned, momentum_aligned, sm_aligned, volume_ok, rsi_room] }
+      - name: no_direction_skips
+        inputs:
+          trend4h: { BTC: NEUTRAL }
+          momentum: { BTC: 0.0 }
+          sm: { BTC: 50.0 }
+          vol: { BTC: 1.0 }
+          rsi: { BTC: 50.0 }
+        expect:
+          scores: {}
+
+  # --- ranker + emitter ---
+  - id: best
+    node: emit_single_best
+    with:
+      min_score: 0                     # the pure_fn already applies conviction_scorer's conviction floor
+
+  - id: emit
+    node: signal_envelope
+    with:
+      margin_pct: 5                    # PERCENT of withdrawable (conviction_scorer base margin)
+      leverage: 7                      # conviction_scorer conviction leverage clamp floor [7,10]
+
+edges:
+  # universe narrowing chain
+  - { from: account.held, to: exclude_held.held }
+  - { from: exclude_held.kept, to: exclude_recent.candidates }
+  - { from: dedup_state.recent, to: exclude_recent.recent }
+  - { from: exclude_recent.kept, to: candles.assets }
+  - { from: exclude_recent.kept, to: lean.assets }
+  # candles fan out to the indicators
+  - { from: candles.candles, to: trend4h.candles }
+  - { from: candles.candles, to: mom1h.candles }
+  - { from: candles.candles, to: vol.candles }
+  - { from: candles.candles, to: rsi1h.candles }
+  # each indicator wires into ONE declared pure_fn input port (single writer, no merge)
+  - { from: trend4h.direction, to: score.trend4h }
+  - { from: mom1h.pct, to: score.momentum }
+  - { from: lean.lean, to: score.sm }
+  - { from: vol.ratio, to: score.vol }
+  - { from: rsi1h.rsi, to: score.rsi }
+  # score -> rank -> emit
+  - { from: score.scores, to: best.scores }
+  - { from: best.selected, to: emit.selected }
+  - { from: account.equity, to: emit.equity }
+  # close the dedup loop: this tick's signals are recorded in ctx.state
+  - { from: emit.signals, to: dedup_state.emitted }

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

@@ -0,0 +1,247 @@
+# macro_thesis_basket — macro long/short basket strategy (tier 1), as a typed dataflow DAG.
+# This is the one corpus strategy that RANKS A POOL against OPEN SLOTS rather than emitting
+# a single best (recon §2/§3): it scores every basket name's CONFIRMATION of a preset-fixed
+# direction and emits the top (maxSlots - held) confirming names. Re-expression of corpus
+# package thesis-fund; semantics cited to skills/strategies/thesis-fund/...
+#
+# Slice-5 deliverables exercised here:
+#  - the discovery/validation source `instrument_list` + filter `live_instrument_validation`
+#    (macro_thesis_basket only scores names live on the venue board; corpus scan.py _get_universe_meta
+#    + the "not on live instrument board, skipping" guard).
+#  - the source `own_return_24h` (24h markPx/prevDayPx return, corpus ret_24h), consumed as
+#    a distinct momentum feature.
+#  - the indicator `rsi` (corpus scoring.calc_rsi, the RSI-room confirmation component).
+#  - the ranker `rank_pool_cap_to_open_slots` (corpus rank-then-cap-to-open-slots) — the
+#    NEW second ranker the recon named.
+#  - the universal `ttl_dedup_state` on ctx.state (corpus 180s recent-signal dedup).
+#
+# Why a pure_fn scorer (D2 kind 2): macro_thesis_basket's direction is FIXED PER LEG (a long-basket
+# name is LONG, a short-basket name is SHORT — NOT derived), and a name whose 4h structure
+# OPPOSES its leg is dropped ("don't fight the tape"). This per-leg, per-asset confirmation is
+# bespoke scoring, which by the settled stance (2026-07-15) is ALWAYS a pure_fn node, never a
+# scorer primitive — so the cross-feature score_thesis math is a purity-checked pure_fn
+# (mirrors the original's scoring.score_thesis; cited in the body), exactly as the plan permits.
+
+version: 1
+
+metadata:
+  archetype: thesis_fund
+  strategy: macro_thesis_basket
+  corpus_origin: thesis-fund          # provenance only, for fidelity replay — not user-facing
+  exit_preset: protected_standard     # slice 9: emitted as runtime.yaml exit: (thesis-fund = balanced let-it-work)
+  # EDGE (verbatim, machine never interprets): "express a macro view as a fixed long/short
+  # basket; only add a name when the tape is confirming its side, and never hold more than
+  # my slot budget — rank the confirming names and fill the open slots with the strongest."
+
+nodes:
+  # --- sources ---
+  - id: account
+    node: clearinghouse_state          # held-asset set (open slots) + dual-DEX max() equity
+
+  - id: dedup_state
+    node: ttl_dedup_state              # ctx.state TTL dedup; `recent` = assets within TTL
+    with:
+      ttl_seconds: 180                 # macro_thesis_basket's 180s recent-signal window
+
+  - id: board
+    node: instrument_list              # live venue board for live-instrument validation
+
+  # --- universe narrowing (held-exclusion, recent dedup, live-board validation) ---
+  - id: exclude_held
+    node: held_asset_exclusion         # candidates default to the basket (candles whitelist)
+
+  - id: exclude_recent
+    node: recent_signal_ttl_dedup
+
+  - id: validate_live
+    node: live_instrument_validation   # only score names still live on the venue board
+
+  # --- candle reads over the validated basket (asset_context for the 24h return) ---
+  - id: candles
+    node: candles_fetch
+    with:
+      whitelist: ["BTC", "ETH"]        # the basket universe (long BTC / short ETH below)
+      intervals: ["1h", "4h"]
+      include_asset_context: true      # markPx/prevDayPx for own_return_24h
+
+  # --- features feeding the confirmation scorer ---
+  - id: ret24
+    node: own_return_24h               # 24h markPx/prevDayPx return (corpus ret_24h)
+
+  - id: trend4h
+    node: trend_structure
+    with:
+      lookback: 6
+      interval: "4h"
+
+  - id: trend1h
+    node: trend_structure
+    with:
+      lookback: 6
+      interval: "1h"
+
+  - id: rsi1h
+    node: rsi                          # corpus calc_rsi over 1h closes (RSI-room component)
+    with:
+      period: 4
+      interval: "1h"
+
+  # --- pure_fn confirmation scorer (fixed per-leg direction; D2 kind 2) ---
+  - id: score
+    kind: pure_fn
+    inputs:
+      - { name: trend4h, type: feature_map, doc: "4h trend structure (BULLISH/BEARISH/NEUTRAL)." }
+      - { name: trend1h, type: feature_map, doc: "1h trend structure (BULLISH/BEARISH/NEUTRAL)." }
+      - { name: rsi, type: feature_map, doc: "Trailing-window RSI [0,100] over 1h closes." }
+      - { name: own24h, type: feature_map, doc: "24h percent return (markPx vs prevDayPx)." }
+    outputs:
+      - { name: scores, type: score_map, doc: "Per-asset {score, direction, reasons[]} for confirming names." }
+    params:
+      - { name: long_basket, type: "list[str]", default: ["BTC"], doc: "Names whose fixed thesis direction is LONG." }
+      - { name: short_basket, type: "list[str]", default: ["ETH"], doc: "Names whose fixed thesis direction is SHORT." }
+      - { name: min_score, type: float, default: 4, doc: "Minimum confirmation score to keep a name." }
+    fn: |
+      def score_thesis_fund(trend4h, trend1h, rsi, own24h, long_basket, short_basket, min_score):
+          # MACRO THESIS BASKET (tier 1): direction is FIXED by the preset leg (long_basket -> LONG,
+          # short_basket -> SHORT), NOT derived. Ported from thesis-fund/main/scanners/
+          # scoring.py score_thesis: a name whose 4h structure OPPOSES its thesis leg is
+          # dropped ("don't fight the tape"); otherwise a weighted CONFIRMATION score
+          # (4h alignment, 1h alignment, 24h momentum, RSI room). The score only measures how
+          # strongly the market confirms the fixed direction.
+          scores = {}
+          longs = {str(a).upper() for a in long_basket}
+          shorts = {str(a).upper() for a in short_basket}
+          assets = sorted(set(trend4h) | set(trend1h) | set(rsi) | set(own24h))
+          for asset in assets:
+              au = str(asset).upper()
+              if au in longs:
+                  direction = "LONG"
+              elif au in shorts:
+                  direction = "SHORT"
+              else:
+                  continue
+              t4 = trend4h.get(asset, "NEUTRAL")
+              t1 = trend1h.get(asset, "NEUTRAL")
+              r = rsi.get(asset, 50.0)
+              own = own24h.get(asset, 0.0)
+              score = 0.0
+              reasons = []
+              if direction == "LONG":
+                  if t4 == "BEARISH":
+                      continue
+                  if t4 == "BULLISH":
+                      score = score + 3.0
+                      reasons.append("4h_bullish")
+                  else:
+                      score = score + 1.0
+                      reasons.append("4h_neutral")
+                  if t1 == "BULLISH":
+                      score = score + 1.0
+                      reasons.append("1h_bullish")
+                  elif t1 == "BEARISH":
+                      score = score - 1.0
+                      reasons.append("1h_bearish")
+                  if own >= 1.0:
+                      score = score + 2.0
+                      reasons.append("mom_strong")
+                  elif own >= 0.0:
+                      score = score + 1.0
+                      reasons.append("mom")
+                  if r < 78.0:
+                      score = score + 1.0
+                      reasons.append("rsi_room")
+              else:
+                  if t4 == "BULLISH":
+                      continue
+                  if t4 == "BEARISH":
+                      score = score + 3.0
+                      reasons.append("4h_bearish")
+                  else:
+                      score = score + 1.0
+                      reasons.append("4h_neutral")
+                  if t1 == "BEARISH":
+                      score = score + 1.0
+                      reasons.append("1h_bearish")
+                  elif t1 == "BULLISH":
+                      score = score - 1.0
+                      reasons.append("1h_bullish")
+                  if own <= -1.0:
+                      score = score + 2.0
+                      reasons.append("mom_strong")
+                  elif own <= 0.0:
+                      score = score + 1.0
+                      reasons.append("mom")
+                  if r > 22.0:
+                      score = score + 1.0
+                      reasons.append("rsi_room")
+              if score < min_score:
+                  continue
+              scores[asset] = {"score": round(score, 4), "direction": direction, "reasons": reasons}
+          return scores
+    tests:
+      - name: long_leg_confirmed
+        inputs:
+          trend4h: { BTC: BULLISH }
+          trend1h: { BTC: BULLISH }
+          rsi: { BTC: 50.0 }
+          own24h: { BTC: 10.0 }
+        expect:
+          scores:
+            BTC: { score: 7.0, direction: LONG, reasons: [4h_bullish, 1h_bullish, mom_strong, rsi_room] }
+      - name: dont_fight_the_tape
+        inputs:
+          trend4h: { BTC: BEARISH }
+          trend1h: { BTC: BULLISH }
+          rsi: { BTC: 50.0 }
+          own24h: { BTC: 10.0 }
+        expect:
+          scores: {}
+      - name: short_leg_confirmed
+        inputs:
+          trend4h: { ETH: BEARISH }
+          trend1h: { ETH: BEARISH }
+          rsi: { ETH: 50.0 }
+          own24h: { ETH: -10.0 }
+        expect:
+          scores:
+            ETH: { score: 7.0, direction: SHORT, reasons: [4h_bearish, 1h_bearish, mom_strong, rsi_room] }
+
+  # --- ranker: rank the confirming pool, cap to open slots (maxSlots - held) ---
+  - id: rank
+    node: rank_pool_cap_to_open_slots
+    with:
+      max_slots: 2                     # emit the top (2 - held) confirming names
+      min_score: 0                     # the pure_fn already applies macro_thesis_basket's floor
+
+  # --- emitter ---
+  - id: emit
+    node: signal_envelope
+    with:
+      margin_pct: 12                   # PERCENT of withdrawable (macro_thesis_basket flat 12%)
+      leverage: 5                      # flat 5x (venue clamp is a no-op without a venue feature)
+
+edges:
+  # universe narrowing chain (basket -> held-excl -> recent-dedup -> live-validate)
+  - { from: account.held, to: exclude_held.held }
+  - { from: exclude_held.kept, to: exclude_recent.candidates }
+  - { from: dedup_state.recent, to: exclude_recent.recent }
+  - { from: exclude_recent.kept, to: validate_live.candidates }
+  - { from: board.instruments, to: validate_live.instruments }
+  - { from: validate_live.kept, to: candles.assets }
+  # candles fan out to the confirmation features
+  - { from: candles.candles, to: ret24.candles }
+  - { from: candles.candles, to: trend4h.candles }
+  - { from: candles.candles, to: trend1h.candles }
+  - { from: candles.candles, to: rsi1h.candles }
+  # each feature wires into ONE declared pure_fn input port (single writer, no merge)
+  - { from: trend4h.direction, to: score.trend4h }
+  - { from: trend1h.direction, to: score.trend1h }
+  - { from: rsi1h.rsi, to: score.rsi }
+  - { from: ret24.return_24h, to: score.own24h }
+  # score -> rank-pool-cap-to-slots -> emit
+  - { from: score.scores, to: rank.scores }
+  - { from: account.held, to: rank.held }
+  - { from: rank.selected, to: emit.selected }
+  - { from: account.equity, to: emit.equity }
+  # close the dedup loop: this tick's signals are recorded in ctx.state
+  - { from: emit.signals, to: dedup_state.emitted }

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

@@ -0,0 +1,204 @@
+# pre_listing_classifier — new-listing/IPOP strategy (tier 2) whose direction CLASSIFIER
+# is a per-graph pure_fn node (D2 kind 2).
+#
+# Why a pure_fn here (the slice-4 point): this strategy's pre-listing thesis is a CLASSIFIER
+# PREDICATE — the 4h structure classifies tradeable direction (NEUTRAL is dropped), the 1h
+# structure and smart money CONFIRM, and because SM data is sparse pre-listing its ABSENCE
+# falls back to a trend-only assumed-aligned bonus. That "SM present -> must agree; SM absent
+# -> assume aligned" branch is cross-feature conditional logic no registry scorer expresses.
+# The fn body re-expresses the corpus package magpie's `build_thesis_pre_listing`
+# (corpus: /Users/duncan/Senpi/skills/strategies/magpie/pre_listing/scanners/scoring.py) —
+# cited in the body — statically purity-checked, with inline fixture tests.
+#
+# DYNAMIC UNIVERSE (slice 5, restored): pre_listing_classifier's real universe is discovered each tick off
+# the LIVE market_list_instruments read by its IPOP funding signature (corpus
+# magpie/pre_listing/scanners/scan.py _fetch_ipop_universe + scoring.ipop_passes_universe).
+# The slice-4 whitelist stand-in is replaced by the discovery trio:
+#   instrument_list (live board records) -> classifier_predicate (funding + leverage +
+#   not-delisted, the ipop_passes_universe funding portion) -> universe_discover (xyz: prefix
+#   + leverage cap + min daily volume) -> the tradeable IPOP names.
+# Chaining the two predicates reproduces ipop_passes_universe's full conjunction while using
+# each registry node as declared (no registry change). emit_single_best is used because the
+# discovered pre-listing universe is naturally tiny (recon: "magpie-implicit-via-small-N").
+
+version: 1
+
+metadata:
+  archetype: event_new_listing
+  strategy: pre_listing_classifier
+  corpus_origin: magpie                # provenance only, for fidelity replay — not user-facing
+  exit_preset: protected_standard      # slice 9: emitted as runtime.yaml exit: (magpie = balanced discovery)
+  # EDGE (verbatim, machine never interprets): "catch trade.xyz pre-IPO perps as they start
+  # trending into the listing — 4h sets the side, 1h and smart money confirm, and when the
+  # book is too new for smart-money data, trust the trend."
+
+nodes:
+  # --- sources ---
+  - id: account
+    node: clearinghouse_state
+
+  - id: dedup_state
+    node: ttl_dedup_state
+    with:
+      ttl_seconds: 720                 # pre_listing_classifier's 720s per-coin dedup window
+
+  # --- dynamic universe discovery (the IPOP funding signature; see header) ---
+  - id: board
+    node: instrument_list              # live market_list_instruments records for the xyz venue
+    with:
+      dex: "xyz"
+
+  - id: ipop_funding
+    node: classifier_predicate         # ipop_passes_universe: |funding| tiny, lev<=5, live
+    with:
+      max_funding_abs: 0.0000001       # magpie ipopFundingMaxAbs 1e-7
+      max_leverage: 5                  # magpie ipopMaxLeverageCap
+      exclude_delisted: true
+
+  - id: ipop_universe
+    node: universe_discover            # xyz: prefix + leverage cap + min daily volume floor
+    with:
+      name_prefix: "xyz:"
+      max_leverage_cap: 5
+      min_day_volume: 100000           # magpie ipopMinDailyVolUsd
+
+  # --- universe narrowing over the discovered IPOP set ---
+  - id: exclude_held
+    node: held_asset_exclusion
+
+  - id: exclude_recent
+    node: recent_signal_ttl_dedup
+
+  # --- candle + leaderboard reads over the discovered, narrowed universe ---
+  - id: candles
+    node: candles_fetch
+    with:
+      intervals: ["1h", "4h"]          # universe is wired in (dynamic), not a static whitelist
+
+  - id: lean
+    node: sm_lean
+    with:
+      agree_threshold: 0.55            # magpie smTiltMinPct 55%
+
+  # --- trend structure at both intervals (the classifier's inputs) ---
+  - id: trend4h
+    node: trend_structure
+    with:
+      lookback: 6
+      interval: "4h"
+
+  - id: trend1h
+    node: trend_structure
+    with:
+      lookback: 6
+      interval: "1h"
+
+  # --- pure_fn classifier predicate (the bespoke, cross-feature edge; D2 kind 2) ---
+  - id: classify
+    kind: pure_fn
+    inputs:
+      - { name: trend4h, type: feature_map, doc: "4h trend structure (BULLISH/BEARISH/NEUTRAL)." }
+      - { name: trend1h, type: feature_map, doc: "1h trend structure (BULLISH/BEARISH/NEUTRAL)." }
+      - { name: sm, type: feature_map, doc: "Smart-money long lean percent [0,100]; may be absent." }
+    outputs:
+      - { name: scores, type: score_map, doc: "Per-asset {score, direction, reasons[]} for tradeable IPOPs." }
+    params:
+      - { name: min_score, type: float, default: 3, doc: "Minimum pre-listing score to emit." }
+    fn: |
+      def classify_pre_listing(trend4h, trend1h, sm, min_score):
+          # Magpie PRE-LISTING (tier 2): a CLASSIFIER PREDICATE, not a weighted scorer. The
+          # 4h structure classifies the side (NEUTRAL -> not tradeable, dropped); 1h + SM
+          # confirm; SM is SPARSE pre-listing, so its ABSENCE falls back to trend-only
+          # (assumed aligned) while a PRESENT-but-opposing SM read drops the candidate.
+          # Ported from magpie/pre_listing/scanners/scoring.py build_thesis_pre_listing.
+          scores = {}
+          assets = sorted(set(trend4h) | set(trend1h) | set(sm))
+          for asset in assets:
+              t4 = trend4h.get(asset, "NEUTRAL")
+              if t4 == "NEUTRAL":
+                  continue
+              direction = "LONG" if t4 == "BULLISH" else "SHORT"
+              score = 3.0
+              reasons = ["4h_" + t4.lower()]
+              t1 = trend1h.get(asset, "NEUTRAL")
+              if (direction == "LONG" and t1 == "BULLISH") or (direction == "SHORT" and t1 == "BEARISH"):
+                  score = score + 2.0
+                  reasons.append("1h_confirms")
+              lean = sm.get(asset)
+              if lean is None:
+                  score = score + 2.0
+                  reasons.append("sm_sparse_assumed_aligned")
+              else:
+                  tilt = lean if direction == "LONG" else 100.0 - lean
+                  if tilt < 55.0:
+                      continue
+                  score = score + 2.0
+                  reasons.append("sm_aligned")
+                  if tilt >= 70.0:
+                      score = score + 1.0
+                      reasons.append("sm_strong")
+              if score < min_score:
+                  continue
+              scores[asset] = {"score": round(score, 4), "direction": direction, "reasons": reasons}
+          return scores
+    tests:
+      - name: bullish_confirmed_long
+        inputs:
+          trend4h: { ACME: BULLISH }
+          trend1h: { ACME: BULLISH }
+          sm: { ACME: 60.0 }
+        expect:
+          scores:
+            ACME: { score: 7.0, direction: LONG, reasons: [4h_bullish, 1h_confirms, sm_aligned] }
+      - name: neutral_4h_not_tradeable
+        inputs:
+          trend4h: { ACME: NEUTRAL }
+          trend1h: { ACME: BULLISH }
+          sm: { ACME: 60.0 }
+        expect:
+          scores: {}
+      - name: sparse_sm_trend_only
+        inputs:
+          trend4h: { ACME: BULLISH }
+          trend1h: { ACME: NEUTRAL }
+          sm: {}
+        expect:
+          scores:
+            ACME: { score: 5.0, direction: LONG, reasons: [4h_bullish, sm_sparse_assumed_aligned] }
+
+  # --- ranker + emitter ---
+  - id: best
+    node: emit_single_best
+    with:
+      min_score: 0                     # the pure_fn already applies pre_listing_classifier's score floor
+
+  - id: emit
+    node: signal_envelope
+    with:
+      margin_pct: 10                   # PERCENT of withdrawable
+      leverage: 5                      # pre_listing_classifier's IPOP venue max is <=5
+
+edges:
+  # dynamic universe discovery: board -> funding signature -> prefix/leverage/volume
+  - { from: board.instruments, to: ipop_funding.candidates }
+  - { from: ipop_funding.kept, to: ipop_universe.instruments }
+  # universe narrowing chain over the discovered IPOP names
+  - { from: ipop_universe.universe, to: exclude_held.candidates }
+  - { from: account.held, to: exclude_held.held }
+  - { from: exclude_held.kept, to: exclude_recent.candidates }
+  - { from: dedup_state.recent, to: exclude_recent.recent }
+  - { from: exclude_recent.kept, to: candles.assets }
+  - { from: exclude_recent.kept, to: lean.assets }
+  # candles fan out to trend structure at both intervals
+  - { from: candles.candles, to: trend4h.candles }
+  - { from: candles.candles, to: trend1h.candles }
+  # each feature wires into ONE declared pure_fn input port (single writer, no merge)
+  - { from: trend4h.direction, to: classify.trend4h }
+  - { from: trend1h.direction, to: classify.trend1h }
+  - { from: lean.lean, to: classify.sm }
+  # classify -> rank -> emit
+  - { from: classify.scores, to: best.scores }
+  - { from: best.selected, to: emit.selected }
+  - { from: account.equity, to: emit.equity }
+  # close the dedup loop
+  - { from: emit.signals, to: dedup_state.emitted }