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

package/dist/composer/authoring/archetypes/_common.py

@@ -0,0 +1,218 @@
+"""_common — shared archetype pieces (rankers, the reusable pure_fn bodies + test-gen).
+
+Two concerns live here so the three archetype templates stay small and consistent:
+
+  * cardinality -> ranker: max_positions == 1 emits the single-best ranker; >1 emits the
+    rank-pool-cap-to-open-slots ranker (thesis-fund's shape) wired to the held set. This is
+    the mechanical binding of the "cardinality" answer (D7 step 3).
+  * bespoke scoring bodies WITH WORKING DEFAULTS: the classifier and thesis archetypes need
+    a cross-feature scorer no registry scorer expresses (the slice-3/4 vocabulary limit), so
+    they ship a pure_fn (D2 kind 2) pre-filled with a proven default body — magpie's
+    classifier predicate / thesis-fund's confirmation scorer. The body is the TODO slot the
+    model edits toward its edge; it is emitted verbatim AND executed here to synthesize
+    inline fixture tests that pass BY CONSTRUCTION, so the generated graph validates (the
+    pure_fn test stage runs) with zero edits regardless of the bound universe.
+"""
+
+from __future__ import annotations
+
+from ..builder import GraphBuilder
+
+
+def add_ranker(
+    b: GraphBuilder,
+    *,
+    ranker_id: str,
+    scorer_id: str,
+    scorer_port: str,
+    account_id: str | None,
+    max_positions: int,
+) -> None:
+    """Add the ranker dictated by cardinality and wire the scorer into it.
+
+    Returns nothing; the caller wires ``ranker_id.selected`` onward to the emitter.
+    """
+    if max_positions <= 1:
+        b.add(
+            ranker_id,
+            "emit_single_best",
+            {"min_score": 0},
+            header=("ranker: single best candidate (cardinality = 1).",),
+        )
+        b.connect(scorer_id, scorer_port, ranker_id, "scores", section="score -> rank -> emit")
+    else:
+        b.add(
+            ranker_id,
+            "rank_pool_cap_to_open_slots",
+            {"max_slots": max_positions, "min_score": 0},
+            header=(
+                f"ranker: rank the pool, fill up to {max_positions} open slots "
+                f"(cardinality = {max_positions}).",
+            ),
+        )
+        b.connect(scorer_id, scorer_port, ranker_id, "scores", section="score -> rank -> emit")
+        if account_id is not None:
+            b.connect(account_id, "held", ranker_id, "held")
+
+
+# --------------------------------------------------------------------------- pure_fn bodies
+
+# magpie/pre_listing build_thesis_pre_listing (corpus), the classifier default body.
+CLASSIFIER_FN = '''\
+def classify_candidate(trend4h, trend1h, sm, min_score):
+    # TODO(edit): this is a WORKING DEFAULT classifier (magpie pre-listing shape). The 4h
+    # structure classifies the side (NEUTRAL -> not tradeable); 1h + smart money confirm;
+    # sparse SM falls back to trend-only. Encode YOUR edge by editing this body — it is
+    # purity-checked (no ctx/MCP/I/O) and its inline tests run at validate time.
+    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
+'''
+
+# thesis-fund score_thesis (corpus), the fixed-per-leg confirmation default body.
+THESIS_FN = '''\
+def score_thesis(trend4h, trend1h, rsi, own24h, long_basket, short_basket, min_score):
+    # TODO(edit): this is a WORKING DEFAULT confirmation scorer (thesis-fund shape). A name's
+    # direction is FIXED by its leg (long_basket -> LONG, short_basket -> SHORT), NOT derived;
+    # a name whose 4h structure OPPOSES its leg is dropped ("don't fight the tape"), else a
+    # weighted CONFIRMATION score. Encode YOUR edge by editing this body — it is purity-checked.
+    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
+'''
+
+
+def _exec_fn(fn_src: str):
+    ns: dict = {}
+    exec(fn_src, ns)  # noqa: S102 - trusted, in-repo reference body used only for test-gen
+    for name, obj in ns.items():
+        if callable(obj) and name != "__builtins__":
+            return obj
+    raise RuntimeError("no function found in reference body")
+
+
+def classifier_tests(min_score: float) -> tuple[dict, ...]:
+    """Two inline tests whose expected values are computed from the default body itself, so
+    they pass by construction (the emitted body == the executed body)."""
+    fn = _exec_fn(CLASSIFIER_FN)
+    confirmed_in = {"trend4h": {"ACME": "BULLISH"}, "trend1h": {"ACME": "BULLISH"}, "sm": {"ACME": 60.0}}
+    neutral_in = {"trend4h": {"ACME": "NEUTRAL"}, "trend1h": {"ACME": "BULLISH"}, "sm": {"ACME": 60.0}}
+    confirmed = fn(confirmed_in["trend4h"], confirmed_in["trend1h"], confirmed_in["sm"], min_score)
+    neutral = fn(neutral_in["trend4h"], neutral_in["trend1h"], neutral_in["sm"], min_score)
+    return (
+        {"name": "confirmed_side_scored", "inputs": confirmed_in, "expect": {"scores": confirmed}},
+        {"name": "neutral_4h_dropped", "inputs": neutral_in, "expect": {"scores": neutral}},
+    )
+
+
+def thesis_tests(
+    long_basket: list[str], short_basket: list[str], min_score: float
+) -> tuple[dict, ...]:
+    """Two inline tests (one per leg) computed from the default body with the BOUND baskets,
+    so they pass whatever universe was chosen."""
+    fn = _exec_fn(THESIS_FN)
+    longs = list(long_basket) or ["BTC"]
+    shorts = list(short_basket) or ["ETH"]
+    la, sa = str(longs[0]).upper(), str(shorts[0]).upper()
+    long_in = {"trend4h": {la: "BULLISH"}, "trend1h": {la: "BULLISH"}, "rsi": {la: 50.0}, "own24h": {la: 10.0}}
+    short_in = {"trend4h": {sa: "BEARISH"}, "trend1h": {sa: "BEARISH"}, "rsi": {sa: 50.0}, "own24h": {sa: -10.0}}
+    lo = fn(long_in["trend4h"], long_in["trend1h"], long_in["rsi"], long_in["own24h"], longs, shorts, min_score)
+    so = fn(short_in["trend4h"], short_in["trend1h"], short_in["rsi"], short_in["own24h"], longs, shorts, min_score)
+    return (
+        {"name": "long_leg_confirmed", "inputs": long_in, "expect": {"scores": lo}},
+        {"name": "short_leg_confirmed", "inputs": short_in, "expect": {"scores": so}},
+    )

package/dist/composer/authoring/archetypes/classifier.py

@@ -0,0 +1,109 @@
+"""classifier — the magpie shape (D7 step 2): a per-graph pure_fn CLASSIFIER predicate over
+trend structure + smart money, on either a discovered or a fixed universe.
+
+The direction classifier is cross-feature logic no registry scorer expresses (the slice-4
+finding), so it is a pure_fn (D2 kind 2) carrying a WORKING DEFAULT body (magpie's
+pre-listing predicate) as the TODO slot the model edits. Mechanically bound: discovery
+params (dex / prefix / leverage cap / volume floor) -> the instrument_list + classifier_
+predicate + universe_discover trio, or a fixed whitelist -> candles; intervals, ttl, risk,
+cardinality bind as usual.
+"""
+
+from __future__ import annotations
+
+from ..answers import Answers
+from ..builder import GraphBuilder
+from . import _common
+
+BANNER = [
+    "classifier strategy — machine-generated anchor (composer new).",
+    "",
+    "Trend structure at 4h + 1h feeds a per-graph pure_fn CLASSIFIER that fixes the side and",
+    "confirms with smart money (magpie pre-listing shape). Universe is either discovered each",
+    "tick from the live instrument board (funding/leverage/volume signature) or a fixed",
+    "whitelist. Edit ONLY the pure_fn body (the EDGE slot) to encode your classification edge.",
+]
+
+_MIN_SCORE = 3.0
+
+
+def build(answers: Answers) -> GraphBuilder:
+    b = GraphBuilder()
+    u = answers.universe
+
+    b.add("account", "clearinghouse_state", header=("sources.",))
+    b.add("dedup_state", "ttl_dedup_state", {"ttl_seconds": answers.ttl_seconds})
+
+    if u.discover:
+        b.add("board", "instrument_list", {"dex": u.dex},
+              header=("dynamic universe discovery: live board -> funding signature -> prefix/leverage/volume.",))
+        b.add("ipop_funding", "classifier_predicate",
+              {"max_funding_abs": 0.0000001, "max_leverage": u.max_leverage_cap, "exclude_delisted": True})
+        b.add("ipop_universe", "universe_discover",
+              {"name_prefix": u.name_prefix, "max_leverage_cap": u.max_leverage_cap, "min_day_volume": u.min_day_volume})
+        b.add("exclude_held", "held_asset_exclusion",
+              header=("universe narrowing over the discovered set.",))
+    else:
+        b.add("exclude_held", "held_asset_exclusion",
+              header=("universe narrowing over the fixed whitelist (candles supplies it).",))
+    b.add("exclude_recent", "recent_signal_ttl_dedup")
+
+    candles_params = {"intervals": list(answers.intervals)}
+    if not u.discover:
+        candles_params = {"whitelist": list(u.whitelist), "intervals": list(answers.intervals)}
+    b.add("candles", "candles_fetch", candles_params,
+          header=("candle + leaderboard reads over the narrowed universe.",))
+    b.add("lean", "sm_lean", {"agree_threshold": 0.55},
+          param_comments={"agree_threshold": "TODO(edit): smart-money agreement band."},
+          slots=("agree_threshold",))
+
+    b.add("trend4h", "trend_structure", {"lookback": 6, "interval": "4h"},
+          header=("trend structure at both intervals (the classifier's inputs).",))
+    b.add("trend1h", "trend_structure", {"lookback": 6, "interval": "1h"})
+
+    b.add_pure_fn(
+        "classify",
+        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[]}."},),
+        params=({"name": "min_score", "type": "float", "default": _MIN_SCORE, "doc": "Minimum score to emit."},),
+        fn=_common.CLASSIFIER_FN,
+        tests=_common.classifier_tests(_MIN_SCORE),
+        header=("pure_fn classifier — THE EDGE SLOT (edit the body; see the EDGE block above).",),
+    )
+    b.set_edge_anchor("classify")
+
+    _common.add_ranker(
+        b, ranker_id="best", scorer_id="classify", scorer_port="scores",
+        account_id="account", max_positions=answers.max_positions,
+    )
+    b.add("emit", "signal_envelope",
+          {"margin_pct": answers.risk.margin_pct, "leverage": answers.risk.leverage},
+          header=("emitter.",))
+
+    # universe wiring
+    if u.discover:
+        b.connect("board", "instruments", "ipop_funding", "candidates", section="dynamic universe discovery")
+        b.connect("ipop_funding", "kept", "ipop_universe", "instruments")
+        b.connect("ipop_universe", "universe", "exclude_held", "candidates", section="universe narrowing chain")
+    b.connect("account", "held", "exclude_held", "held",
+              section=None if u.discover else "universe narrowing chain")
+    b.connect("exclude_held", "kept", "exclude_recent", "candidates")
+    b.connect("dedup_state", "recent", "exclude_recent", "recent")
+    b.connect("exclude_recent", "kept", "candles", "assets")
+    b.connect("exclude_recent", "kept", "lean", "assets")
+    # candles -> trend structure
+    b.connect("candles", "candles", "trend4h", "candles", section="candles fan out to trend structure")
+    b.connect("candles", "candles", "trend1h", "candles")
+    # features into the pure_fn (single writer per declared port)
+    b.connect("trend4h", "direction", "classify", "trend4h", section="features into the classifier pure_fn")
+    b.connect("trend1h", "direction", "classify", "trend1h")
+    b.connect("lean", "lean", "classify", "sm")
+    # classify -> rank -> emit
+    b.connect("best", "selected", "emit", "selected")
+    b.connect("account", "equity", "emit", "equity")
+    b.connect("emit", "signals", "dedup_state", "emitted", section="close the dedup loop")
+    return b

package/dist/composer/authoring/archetypes/skeleton.py

@@ -0,0 +1,54 @@
+"""skeleton — the off-map fallback (D7 step 5): no matching archetype -> a MINIMAL valid
+graph (universe -> fetch -> score slot -> emit) so the anchor property holds even for a
+strategy shape the ~10 archetypes do not cover.
+
+It is deliberately the smallest graph that validates and compiles: one candle fetch over
+the universe, one trend indicator, a hard-gates scorer as the single TODO edge slot, and
+single-best emission. The model grows it from here (full edit rights, D7) — the skeleton
+only guarantees a valid starting point exists.
+"""
+
+from __future__ import annotations
+
+from ..answers import Answers
+from ..builder import GraphBuilder
+
+BANNER = [
+    "minimal skeleton — machine-generated anchor (composer new).",
+    "",
+    "No archetype matched, so this is the smallest VALID graph: universe -> fetch -> score",
+    "slot -> emit. It validates and compiles as-is; grow it toward your strategy by editing",
+    "the scorer slot and adding nodes (`composer catalog` / `composer describe <node>`).",
+]
+
+
+def build(answers: Answers) -> GraphBuilder:
+    b = GraphBuilder()
+    iv = answers.intervals[0] if answers.intervals else "4h"
+    whitelist = list(answers.universe.whitelist) or ["BTC"]
+
+    b.add("candles", "candles_fetch", {"whitelist": whitelist, "intervals": list(answers.intervals)},
+          header=("universe -> fetch.",))
+    b.add("trend", "trend_structure", {"lookback": 6, "interval": iv},
+          header=("one feature to score on.",))
+    b.add(
+        "score", "hard_gates_all",
+        {"weights": {"trend": 1.0}, "min_score": 0},
+        header=("scorer — THE EDGE SLOT (see the EDGE block above); edit the weights/gates.",),
+        param_comments={
+            "weights": "TODO(edit): source-node-id -> weight; add features and weight them here.",
+            "min_score": "TODO(edit): minimum score to emit.",
+        },
+        slots=("weights", "min_score"),
+    )
+    b.set_edge_anchor("score")
+    b.add("best", "emit_single_best", {"min_score": 0}, header=("ranker.",))
+    b.add("emit", "signal_envelope",
+          {"margin_pct": answers.risk.margin_pct, "leverage": answers.risk.leverage},
+          header=("emitter.",))
+
+    b.connect("candles", "candles", "trend", "candles", section="fetch -> feature")
+    b.connect("trend", "direction", "score", "features", section="feature -> score -> rank -> emit")
+    b.connect("score", "scores", "best", "scores")
+    b.connect("best", "selected", "emit", "selected")
+    return b

package/dist/composer/authoring/archetypes/thesis_fund.py

@@ -0,0 +1,103 @@
+"""thesis_fund — the thesis-fund shape (D7 step 2): a fixed long/short basket whose direction
+is FIXED per leg, scored for CONFIRMATION by a pure_fn, ranked, and capped to open slots.
+
+This is the archetype that ranks a pool against open slots rather than emitting a single
+best (recon). Direction is not derived — long_basket names are LONG, short_basket names are
+SHORT — so the scorer is a pure_fn (D2 kind 2) with a WORKING DEFAULT body (thesis-fund's
+score_thesis) as the TODO slot. Mechanically bound: baskets -> candles whitelist + the
+pure_fn's basket params, max_positions -> the rank-pool-cap ranker, intervals/ttl/risk as
+usual. The lay-thesis -> basket mapping happens in elicitation (the answer), not here.
+"""
+
+from __future__ import annotations
+
+from ..answers import Answers
+from ..builder import GraphBuilder
+from . import _common
+
+BANNER = [
+    "thesis_fund strategy — machine-generated anchor (composer new).",
+    "",
+    "A fixed long/short basket: each name's direction is FIXED by its leg (long -> LONG,",
+    "short -> SHORT), and a pure_fn scores how strongly the tape CONFIRMS that side (drops a",
+    "name whose 4h structure opposes its leg). Confirming names are ranked and the top",
+    "(max_positions - held) fill the open slots. Edit ONLY the pure_fn body (the EDGE slot).",
+]
+
+_MIN_SCORE = 4.0
+
+
+def build(answers: Answers) -> GraphBuilder:
+    b = GraphBuilder()
+    u = answers.universe
+    basket = list(u.long_basket) + list(u.short_basket)
+
+    b.add("account", "clearinghouse_state", header=("sources.",))
+    b.add("dedup_state", "ttl_dedup_state", {"ttl_seconds": answers.ttl_seconds})
+    b.add("board", "instrument_list", header=("live venue board for live-instrument validation.",))
+
+    b.add("exclude_held", "held_asset_exclusion",
+          header=("universe narrowing: held-exclusion, recent dedup, live-board validation.",))
+    b.add("exclude_recent", "recent_signal_ttl_dedup")
+    b.add("validate_live", "live_instrument_validation")
+
+    b.add("candles", "candles_fetch",
+          {"whitelist": basket, "intervals": list(answers.intervals), "include_asset_context": True},
+          header=("candle reads over the validated basket (asset_context for the 24h return).",))
+
+    b.add("ret24", "own_return_24h", header=("features feeding the confirmation scorer.",))
+    b.add("trend4h", "trend_structure", {"lookback": 6, "interval": "4h"})
+    b.add("trend1h", "trend_structure", {"lookback": 6, "interval": "1h"})
+    b.add("rsi1h", "rsi", {"period": 4, "interval": "1h"})
+
+    b.add_pure_fn(
+        "score",
+        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]."},
+            {"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": list(u.long_basket) or ["BTC"], "doc": "Names whose fixed thesis direction is LONG."},
+            {"name": "short_basket", "type": "list[str]", "default": list(u.short_basket) or ["ETH"], "doc": "Names whose fixed thesis direction is SHORT."},
+            {"name": "min_score", "type": "float", "default": _MIN_SCORE, "doc": "Minimum confirmation score to keep a name."},
+        ),
+        fn=_common.THESIS_FN,
+        tests=_common.thesis_tests(list(u.long_basket), list(u.short_basket), _MIN_SCORE),
+        header=("pure_fn confirmation scorer — THE EDGE SLOT (edit the body; see the EDGE block above).",),
+    )
+    b.set_edge_anchor("score")
+
+    b.add("rank", "rank_pool_cap_to_open_slots",
+          {"max_slots": answers.max_positions, "min_score": 0},
+          header=(f"ranker: rank the confirming pool, fill up to {answers.max_positions} open slots.",))
+    b.add("emit", "signal_envelope",
+          {"margin_pct": answers.risk.margin_pct, "leverage": answers.risk.leverage},
+          header=("emitter.",))
+
+    # universe narrowing chain
+    b.connect("account", "held", "exclude_held", "held", section="universe narrowing chain")
+    b.connect("exclude_held", "kept", "exclude_recent", "candidates")
+    b.connect("dedup_state", "recent", "exclude_recent", "recent")
+    b.connect("exclude_recent", "kept", "validate_live", "candidates")
+    b.connect("board", "instruments", "validate_live", "instruments")
+    b.connect("validate_live", "kept", "candles", "assets")
+    # candles fan out to the confirmation features
+    b.connect("candles", "candles", "ret24", "candles", section="candles fan out to the confirmation features")
+    b.connect("candles", "candles", "trend4h", "candles")
+    b.connect("candles", "candles", "trend1h", "candles")
+    b.connect("candles", "candles", "rsi1h", "candles")
+    # each feature wires into one declared pure_fn input port
+    b.connect("trend4h", "direction", "score", "trend4h", section="features into the confirmation pure_fn")
+    b.connect("trend1h", "direction", "score", "trend1h")
+    b.connect("rsi1h", "rsi", "score", "rsi")
+    b.connect("ret24", "return_24h", "score", "own24h")
+    # score -> rank-pool-cap -> emit
+    b.connect("score", "scores", "rank", "scores", section="score -> rank-pool-cap-to-slots -> emit")
+    b.connect("account", "held", "rank", "held")
+    b.connect("rank", "selected", "emit", "selected")
+    b.connect("account", "equity", "emit", "equity")
+    b.connect("emit", "signals", "dedup_state", "emitted", section="close the dedup loop")
+    return b

package/dist/composer/authoring/archetypes/trend_momentum.py

@@ -0,0 +1,104 @@
+"""trend_momentum — the stag/hawk shape (D7 step 2): fixed universe, fan-out to indicators,
+a hard-gates-plus-weighted-sum scorer, TTL dedup, single-best (or pool-cap) emission.
+
+Mechanically bound from the answers (D7 step 3): universe -> candles whitelist, intervals ->
+candles + indicators, ttl_seconds -> ttl_dedup_state, cardinality -> ranker, risk knobs ->
+emitter. Bespoke slots left TODO-marked WITH WORKING DEFAULTS: the gate list, the weighted-
+sum weights, the score floor, and the smart-money agreement band — the graph validates and
+compiles before any of them is touched.
+"""
+
+from __future__ import annotations
+
+from ..answers import Answers
+from ..builder import GraphBuilder
+from . import _common
+
+BANNER = [
+    "trend_momentum strategy — machine-generated anchor (composer new).",
+    "",
+    "A fixed universe scanned each tick: candles fan out to trend / momentum / volume /",
+    "acceleration indicators whose per-asset features MERGE into a hard-gates + weighted-sum",
+    "scorer, then single-best (or pool-cap) emission with the universal TTL signal-dedup on",
+    "ctx.state. Edit ONLY the TODO(edit) slots on the scorer to move this toward your edge;",
+    "every intermediate state stays valid (run `composer check`).",
+]
+
+
+def build(answers: Answers) -> GraphBuilder:
+    b = GraphBuilder()
+    iv = answers.intervals[0] if answers.intervals else "4h"
+    u = answers.universe
+
+    b.add("account", "clearinghouse_state", header=("sources.",))
+    b.add("dedup_state", "ttl_dedup_state", {"ttl_seconds": answers.ttl_seconds})
+
+    b.add("exclude_held", "held_asset_exclusion",
+          header=("universe narrowing: held-exclusion then recent-signal dedup.",))
+    b.add("exclude_recent", "recent_signal_ttl_dedup")
+
+    b.add("candles", "candles_fetch",
+          {"whitelist": list(u.whitelist), "intervals": list(answers.intervals)},
+          header=("candle + leaderboard reads over the narrowed universe.",))
+    b.add("lean", "sm_lean", {"agree_threshold": 0.6},
+          param_comments={"agree_threshold": "TODO(edit): smart-money agreement band (stag 0.6, hawk 0.55, bison 0.58)."},
+          slots=("agree_threshold",))
+
+    b.add("trend_sma", "sma", {"period": 200, "interval": iv},
+          header=("indicators: candles -> per-asset features.",))
+    b.add("fresh_high", "recent_high_bars_ago", {"window": 60, "interval": iv})
+    b.add("trend_pct", "pct_change", {"lookback": 42, "interval": iv})
+    b.add("vol_surge", "volume_surge_ratio", {"recent_window": 6, "baseline_window": 42, "interval": iv})
+    b.add("accel", "acceleration", {"short_window": 3, "long_window": 6, "interval": iv})
+
+    b.add(
+        "gates", "hard_gates_all",
+        {
+            "required_gates": ["trend_sma", "accel"],
+            "weights": {"trend_pct": 1.0, "vol_surge": 1.0, "lean": 1.0},
+            "min_score": 3,
+        },
+        header=("scorer: hard gates + weighted sum — THE EDGE SLOT (see the EDGE block above).",),
+        param_comments={
+            "required_gates": "TODO(edit): feature keys (SOURCE NODE IDS) that must ALL pass.",
+            "weights": "TODO(edit): source-node-id -> weight; this weighted sum IS your edge.",
+            "min_score": "TODO(edit): minimum score to emit.",
+        },
+        slots=("required_gates", "weights", "min_score"),
+    )
+    b.set_edge_anchor("gates")
+
+    _common.add_ranker(
+        b, ranker_id="best", scorer_id="gates", scorer_port="scores",
+        account_id="account", max_positions=answers.max_positions,
+    )
+
+    b.add("emit", "signal_envelope",
+          {"margin_pct": answers.risk.margin_pct, "leverage": answers.risk.leverage},
+          header=("emitter: build the scan() signal list.",))
+
+    # universe narrowing chain
+    b.connect("account", "held", "exclude_held", "held", section="universe narrowing chain")
+    b.connect("exclude_held", "kept", "exclude_recent", "candidates")
+    b.connect("dedup_state", "recent", "exclude_recent", "recent")
+    b.connect("exclude_recent", "kept", "candles", "assets")
+    b.connect("exclude_recent", "kept", "lean", "assets")
+    # candles fan out to indicators
+    b.connect("candles", "candles", "trend_sma", "candles", section="candles fan out to indicators")
+    b.connect("candles", "candles", "fresh_high", "candles")
+    b.connect("candles", "candles", "trend_pct", "candles")
+    b.connect("candles", "candles", "vol_surge", "candles")
+    b.connect("candles", "candles", "accel", "candles")
+    # per-asset features MERGE into the scorer (keyed by source node id)
+    b.connect("trend_sma", "above", "gates", "features", section="per-asset features merge into the scorer (keyed by source node id)")
+    b.connect("fresh_high", "bars_ago", "gates", "features")
+    b.connect("trend_pct", "pct", "gates", "features")
+    b.connect("vol_surge", "ratio", "gates", "features")
+    b.connect("accel", "accelerating", "gates", "features")
+    b.connect("lean", "lean", "gates", "features")
+    # score -> rank -> emit (rank wiring added by add_ranker)
+    b.connect("best", "selected", "emit", "selected")
+    b.connect("account", "equity", "emit", "equity")
+    # close the dedup loop
+    b.connect("emit", "signals", "dedup_state", "emitted", section="close the dedup loop: this tick's signals are recorded in ctx.state")
+    return b