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

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

@@ -0,0 +1,121 @@
+# breakout_swing — breakout swing-trading strategy (tier 1) over a 3-asset basket, as a
+# typed dataflow DAG.
+#
+# Hand-authored from the corpus-recon inventory (hawk section): a BTC/ETH/SOL basket
+# scanned on 1h + 4h candles. Two HARD gates in the corpus (a directional breakout of the
+# prior-7d closes, and smart-money agreement); the 4h trend-structure and volume ratio are
+# score contributors. Single-best emission, universal TTL signal-dedup on ctx.state.
+# Re-expression of corpus package hawk; semantics cited to skills/strategies/hawk/...
+#
+# Re-expression notes (correctness = the slice-3 goldens, not the original's bit output):
+#  - breakout_detect.direction is the sole hard gate (required_gates: [brk]); it is also
+#    the emitted trade direction (the scorer's direction detector reads the LONG/SHORT
+#    feature). Smart-money is a weighted contributor here rather than a second hard,
+#    direction-matched gate — the generic scorer gates on truthiness, not cross-feature
+#    agreement (documented deviation; corpus fidelity is the slice-8 oracle).
+#  - trend_structure emits BULLISH/BEARISH/NEUTRAL, so it can be wired into the same scorer
+#    as breakout_detect (both would otherwise be a "direction" port) without colliding.
+#  - feature/gate/weight keys are SOURCE NODE IDS (the compiler merges keyed by node id).
+
+version: 1
+
+metadata:
+  archetype: breakout
+  strategy: breakout_swing
+  corpus_origin: hawk                # provenance only, for fidelity replay — not user-facing
+  exit_preset: protected_tight       # slice 9: emitted as runtime.yaml exit: (hawk = cut failed breakouts fast)
+  # EDGE (verbatim, machine never interprets): "buy the liquid majors the moment price
+  # breaks a week of range with smart money leaning the same way; ride it with the DSL."
+
+nodes:
+  # --- sources ---
+  - id: account
+    node: clearinghouse_state          # dual-DEX max() equity + held-position set
+
+  - id: dedup_state
+    node: ttl_dedup_state              # ctx.state TTL dedup; `recent` = assets within TTL
+    with:
+      ttl_seconds: 240
+
+  # --- universe narrowing (held-exclusion then recent-signal dedup) ---
+  - id: exclude_held
+    node: held_asset_exclusion         # candidates default to the basket (candles whitelist)
+
+  - id: exclude_recent
+    node: recent_signal_ttl_dedup
+
+  # --- candle + leaderboard reads over the narrowed basket ---
+  - id: candles
+    node: candles_fetch
+    with:
+      whitelist: ["BTC", "ETH", "SOL"]
+      intervals: ["1h", "4h"]
+
+  - id: lean
+    node: sm_lean
+    with:
+      agree_threshold: 0.55            # breakout_swing's own 55% band (not conviction_scorer's 58/42)
+
+  # --- indicators ---
+  - id: brk
+    node: breakout_detect              # HARD gate: prior-168h close high/low break
+    with:
+      window: 168
+      interval: "1h"
+
+  - id: trend4h
+    node: trend_structure              # 4h higher-lows/lower-highs (score contributor)
+    with:
+      lookback: 6
+      interval: "4h"
+
+  - id: vol
+    node: volume_surge_ratio           # 1h recent/baseline volume (score contributor)
+    with:
+      recent_window: 1
+      baseline_window: 10
+      interval: "1h"
+
+  # --- scorer: breakout is the only hard gate; trend/vol/SM contribute ---
+  - id: gates
+    node: hard_gates_all
+    with:
+      required_gates: ["brk"]          # a decisive breakout (LONG/SHORT, not NEUTRAL)
+      # TODO(edge): tune these weights — the strategy's real edge lives here.
+      weights: { brk: 2.0, trend4h: 2.0, vol: 1.0, lean: 0.05 }
+      min_score: 5
+
+  # --- ranker + emitter ---
+  - id: best
+    node: emit_single_best
+    with:
+      min_score: 5
+
+  - id: emit
+    node: signal_envelope
+    with:
+      margin_pct: 20                   # PERCENT of withdrawable (breakout_swing's flat 20%)
+      leverage: 5
+
+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 indicators
+  - { from: candles.candles, to: brk.candles }
+  - { from: candles.candles, to: trend4h.candles }
+  - { from: candles.candles, to: vol.candles }
+  # per-asset features MERGE into the scorer (keyed by source node id)
+  - { from: brk.direction, to: gates.features }
+  - { from: trend4h.direction, to: gates.features }
+  - { from: vol.ratio, to: gates.features }
+  - { from: lean.lean, to: gates.features }
+  # score -> rank -> emit
+  - { from: gates.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/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 }