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

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

@@ -0,0 +1,410 @@
+"""_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
+
+import difflib
+from dataclasses import dataclass
+from typing import Optional
+
+from ..answers import Answers
+from ..builder import BuiltNode, GraphBuilder
+
+
+class GenerationError(ValueError):
+    """A teaching-shaped error raised when the ANSWERS reference something an archetype cannot
+    bind — an ``indicators`` entry naming a node the registry lacks (or a port it does not
+    declare), or a ``scoring`` name that matches no feature node wired into the scorer.
+
+    Surfaced like the builder's ``archetype template error:`` ValueErrors (a located,
+    fix-pointing message), but attributed to the answers rather than template drift: it is how
+    the F1 expressiveness surface refuses an impossible request LOUDLY, so a requested gate or
+    indicator is NEVER silently dropped from the emitted graph."""
+
+
+# --------------------------------------------------------------------------- F1 (scoring + indicators)
+
+@dataclass(frozen=True)
+class ResolvedIndicator:
+    """One resolved ``answers.indicators`` entry, with its input-wiring decision (C1b).
+
+    ``in_port`` is the node's data input port (``candles`` for the candle-fed indicators,
+    ``values`` for ``threshold_gate``). When ``source_id`` is set the input is CHAINED off
+    that node's ``source_port`` output instead of the graph's candles; ``out_port`` is the
+    feature output merged into the scorer."""
+
+    id: str
+    out_port: str
+    in_port: Optional[str]
+    source_id: Optional[str] = None
+    source_port: Optional[str] = None
+
+
+def _node_outputs(bn: BuiltNode) -> list[tuple[str, str]]:
+    """[(port_name, port_type_str)] for a BuiltNode's outputs (primitive or pure_fn)."""
+    from composer.registry import NODES_BY_NAME
+
+    if bn.kind == "pure_fn":
+        return [(p["name"], p["type"]) for p in bn.outputs]
+    return [(p.name, p.type.value) for p in NODES_BY_NAME[bn.node].outputs]
+
+
+def _resolve_source_output(
+    b: GraphBuilder, source_id: str, resolved_by_id: dict, i: int, ind_id: str
+) -> tuple[str, str]:
+    """The (port_name, port_type) a ``source`` reference reads. Prefers an earlier
+    ``indicators`` entry's resolved feature port; else a single-output built-in node.
+    Teaches loudly when the source is unknown or ambiguous (never a silent drop)."""
+    bn = next((n for n in b.nodes if n.id == source_id), None)
+    if bn is None:
+        raise GenerationError(
+            f"indicators[{i}] (id {ind_id!r}) sets source {source_id!r}, which is not a node in "
+            f"this graph. `source` must name an EARLIER indicators entry, or a built-in feature "
+            f"node of the archetype."
+        )
+    outs = _node_outputs(bn)
+    if source_id in resolved_by_id:
+        want = resolved_by_id[source_id].out_port
+        typ = next((t for name, t in outs if name == want), None)
+        return want, typ
+    if len(outs) == 1:
+        return outs[0]
+    raise GenerationError(
+        f"indicators[{i}] (id {ind_id!r}) sets source {source_id!r}, which has "
+        f"{len(outs)} output ports {sorted(name for name, _ in outs)}; source chaining needs a "
+        f"single-output feature node (or reference an earlier indicators entry)."
+    )
+
+
+def add_indicator_nodes(b: GraphBuilder, indicators) -> list[ResolvedIndicator]:
+    """Add each ``answers.indicators`` entry as an ADDITIONAL registry node (F1/C1b).
+
+    Returns a :class:`ResolvedIndicator` per entry for the caller to wire (input in, feature
+    out). Validates the node exists, its chosen output port is real, and — when ``source`` is
+    set — that the source exists and its output port type matches this node's input port type;
+    a :class:`GenerationError` otherwise (never a silent drop). Empty ``indicators`` is a no-op,
+    so an archetype threaded through this stays byte-identical to its pre-F1 output."""
+    from composer.registry import NODES_BY_NAME
+
+    resolved: list[ResolvedIndicator] = []
+    resolved_by_id: dict[str, ResolvedIndicator] = {}
+    for i, ind in enumerate(indicators):
+        nd = NODES_BY_NAME.get(ind.node)
+        if nd is None:
+            near = difflib.get_close_matches(ind.node, sorted(NODES_BY_NAME), n=3, cutoff=0.3)
+            hint = f" Did you mean: {', '.join(near)}?" if near else ""
+            raise GenerationError(
+                f"indicators[{i}] (id {ind.id!r}) requests node {ind.node!r}, which is not in "
+                f"the registry.{hint} Run `composer catalog` to see the available nodes."
+            )
+        out_ports = [p.name for p in nd.outputs]
+        port = ind.port or (out_ports[0] if out_ports else "")
+        if port not in out_ports:
+            raise GenerationError(
+                f"indicators[{i}] (id {ind.id!r}, node {ind.node!r}) names output port "
+                f"{ind.port!r}, which it does not have (has: {sorted(out_ports)})."
+            )
+        # the node's data input port (the single non-nothing input every feature node declares).
+        in_ports = list(nd.inputs)
+        in_port = in_ports[0].name if in_ports else None
+        in_port_type = in_ports[0].type.value if in_ports else None
+
+        source_id = source_port = None
+        if ind.source is not None:
+            if in_port is None:
+                raise GenerationError(
+                    f"indicators[{i}] (id {ind.id!r}, node {ind.node!r}) sets a source but "
+                    f"declares no input port to receive it."
+                )
+            src_port, src_type = _resolve_source_output(b, ind.source, resolved_by_id, i, ind.id)
+            if src_type != in_port_type:
+                raise GenerationError(
+                    f"indicators[{i}] (id {ind.id!r}) sets source {ind.source!r} whose output "
+                    f"{src_port!r} is type {src_type!r}, but {ind.node!r}'s input {in_port!r} is "
+                    f"type {in_port_type!r} — a chained source must feed a port of the same type."
+                )
+            source_id, source_port = ind.source, src_port
+        elif in_port != "candles":
+            raise GenerationError(
+                f"indicators[{i}] (id {ind.id!r}, node {ind.node!r}) is not candle-fed (its input "
+                f"is {in_port!r}); it needs a `source:` naming the feature node whose output feeds "
+                f"it (e.g. a threshold_gate reading a recent_high_bars_ago output)."
+            )
+
+        header = ("additional indicators requested via answers.indicators.",) if i == 0 else ()
+        b.add(ind.id, ind.node, dict(ind.with_), header=header)
+        r = ResolvedIndicator(id=ind.id, out_port=port, in_port=in_port,
+                              source_id=source_id, source_port=source_port)
+        resolved.append(r)
+        resolved_by_id[ind.id] = r
+    return resolved
+
+
+def wire_indicator_inputs(b: GraphBuilder, resolved: list[ResolvedIndicator], *, candles_id: str) -> None:
+    """Wire every extra indicator's data input: the graph's candles by default, or a CHAINED
+    feature node's output when the entry set ``source`` (F1/C1b)."""
+    for j, r in enumerate(resolved):
+        if r.source_id is not None:
+            b.connect(r.source_id, r.source_port, r.id, r.in_port,
+                      section="a chained indicator reads another node's feature" if j == 0 else None)
+        else:
+            b.connect(candles_id, "candles", r.id, r.in_port,
+                      section="extra indicators read the same candles" if j == 0 else None)
+
+
+def wire_indicator_features(b: GraphBuilder, resolved: list[ResolvedIndicator], *, scorer_id: str) -> None:
+    """Merge every extra indicator's feature output into the scorer, keyed by its node id (F1)."""
+    for j, r in enumerate(resolved):
+        b.connect(r.id, r.out_port, scorer_id, "features",
+                  section="extra indicator features merge into the scorer" if j == 0 else None)
+
+
+def resolve_scoring(
+    answers: Answers,
+    *,
+    default_required,
+    default_weights: dict,
+    default_min,
+    feature_ids,
+) -> tuple[list[str], dict, object]:
+    """Resolve ``hard_gates_all`` params from the archetype default + optional answers.scoring.
+
+    "Answers override else current defaults" (D7): each ``scoring`` field left ``None`` keeps
+    the default; a set field replaces it. Every referenced name (``required_gates`` entries +
+    ``weights`` keys) MUST be a feature node id wired into the scorer, else a
+    :class:`GenerationError` names the unknown reference and the real feature ids — never a
+    silent drop. With no ``scoring`` the returned values are the defaults unchanged, so the
+    emitted graph is byte-identical to the pre-F1 output."""
+    req = list(default_required)
+    weights = dict(default_weights)
+    min_score = default_min
+    sc = answers.scoring
+    if sc is not None:
+        if sc.required_gates is not None:
+            req = list(sc.required_gates)
+        if sc.weights is not None:
+            weights = dict(sc.weights)
+        if sc.min_score is not None:
+            min_score = sc.min_score
+    valid = set(feature_ids)
+    unknown = [g for g in req if g not in valid]
+    unknown += [w for w in weights if w not in valid]
+    if unknown:
+        raise GenerationError(
+            f"scoring references {sorted(set(unknown))}, which are not feature nodes in this "
+            f"graph. The scorable features are {sorted(valid)} (SOURCE NODE IDS wired into the "
+            f"scorer). Add the missing feature via `indicators:`, or fix the name."
+        )
+    return req, weights, min_score
+
+
+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/breakout.py

@@ -0,0 +1,134 @@
+"""breakout — the hawk shape (D7 step 2): a directional range-break as the hard gate, over a
+FIXED basket or a DISCOVERED universe, with trend / volume / smart-money as weighted
+contributors. Ported from the hand-authored ``examples/breakout_swing.graph.yaml`` (the spec)
+and made an archetype so `composer new --archetype breakout` reproduces it — and, composed
+with the F1 ``scoring`` / ``indicators`` surface, the 4-hard-gate discovery variant the first
+real dev test agreed but generation could not produce.
+
+Mechanically bound from the answers (D7 step 3): universe -> candles whitelist OR the live
+instrument board (discover); intervals -> candles + indicators; ttl -> ttl_dedup_state;
+cardinality -> ranker; risk -> emitter. The scorer default hard-gates ONLY the breakout
+(``required_gates: ["brk"]``) with trend/vol/SM as weights — the example's shape. Answers
+that pass ``scoring`` re-select the hard gates (e.g. all four of breakout / freshness /
+volume / smart-money), and ``indicators`` add registry nodes the fixed set does not carry
+(e.g. ``recent_high_bars_ago`` for the "don't-chase" freshness gate) — no hand edit.
+"""
+
+from __future__ import annotations
+
+from ..answers import Answers
+from ..builder import GraphBuilder
+from . import _common
+
+BANNER = [
+    "breakout strategy — machine-generated anchor (composer new).",
+    "",
+    "A directional range-break (breakout_detect) is the hard gate; 4h trend structure, a",
+    "volume surge, and smart-money lean contribute to a weighted score, then single-best (or",
+    "pool-cap) emission with the universal TTL signal-dedup. The universe is a fixed basket or",
+    "discovered each tick from the live instrument board. Edit ONLY the TODO(edit) slots on the",
+    "scorer to move this toward your edge; every intermediate state stays valid (`composer check`).",
+]
+
+
+def build(answers: Answers) -> GraphBuilder:
+    b = GraphBuilder()
+    iv = answers.intervals[0] if answers.intervals else "1h"
+    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 -> leverage/volume/prefix signature.",))
+        b.add("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 basket (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 (hawk 0.55)."},
+          slots=("agree_threshold",))
+
+    b.add("brk", "breakout_detect", {"window": 168, "interval": iv},
+          header=("indicators: candles -> per-asset features.",))
+    b.add("trend4h", "trend_structure", {"lookback": 6, "interval": "4h"})
+    b.add("vol", "volume_surge_ratio", {"recent_window": 1, "baseline_window": 10, "interval": iv})
+
+    # F1 — ADDITIONAL registry indicators requested by the answers (empty => no-op).
+    extra = _common.add_indicator_nodes(b, answers.indicators)
+
+    # F1 — the scorer's hard-vs-weighted split. DEFAULT = the example's shape: breakout is the
+    # sole hard gate, trend/vol/SM are weighted contributors. answers.scoring overrides it (e.g.
+    # the incident's four hard gates: brk + a freshness indicator + vol + lean).
+    feature_ids = ["brk", "trend4h", "vol", "lean"] + [r.id for r in extra]
+    required_gates, weights, min_score = _common.resolve_scoring(
+        answers,
+        default_required=("brk",),
+        default_weights={"brk": 2.0, "trend4h": 2.0, "vol": 1.0, "lean": 0.05},
+        default_min=5,
+        feature_ids=feature_ids,
+    )
+    b.add(
+        "gates", "hard_gates_all",
+        {
+            "required_gates": required_gates,
+            "weights": weights,
+            "min_score": min_score,
+        },
+        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 wiring
+    if u.discover:
+        b.connect("board", "instruments", "universe", "instruments", section="dynamic universe discovery")
+        b.connect("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 fan out to indicators
+    b.connect("candles", "candles", "brk", "candles", section="candles fan out to indicators")
+    b.connect("candles", "candles", "trend4h", "candles")
+    b.connect("candles", "candles", "vol", "candles")
+    _common.wire_indicator_inputs(b, extra, candles_id="candles")
+    # per-asset features MERGE into the scorer (keyed by source node id)
+    b.connect("brk", "direction", "gates", "features", section="per-asset features merge into the scorer (keyed by source node id)")
+    b.connect("trend4h", "direction", "gates", "features")
+    b.connect("vol", "ratio", "gates", "features")
+    b.connect("lean", "lean", "gates", "features")
+    _common.wire_indicator_features(b, extra, scorer_id="gates")
+    # 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

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