@senpi/runtime 3.0.0-dev.runtime-phase-2.20260623210537 → 3.0.0-dev.runtime-phase-2.20260625112547

package/examples/strategies/turbine/recipe-runners.yaml

@@ -0,0 +1,123 @@
+# ── TURBINE · RUNNERS leg (v2 supervised) ───────────────────────────
+# SAME funding-fade rotation as VOLUME, but a patient DSL that lets winners run.
+#
+# Ported from senpi-skills/turbine (producer v3.2.2, config v3.3) to the v2
+# supervised external-scanner contract. The producer daemon is gone: the runtime
+# supervises ../scanners/scan.py (SHARED with the volume leg) and calls
+# scan(inputs, ctx) every `interval_seconds`. Both turbine legs run the SAME
+# rotation alpha — only the sizing (inputs) and DSL exit differ. See scan.py.
+#
+# RUNNERS is OPTIONAL: leave TURBINE_RUNNERS_WALLET unset to run pure volume
+# (don't launch this recipe). The two legs are independent runtimes — no coupling.
+name: turbine-runners
+version: 2.0.0
+group: turbine                      # agent-facing handle (BOTH legs share it)
+description: >
+  TURBINE RUNNERS — Identical funding-fade rotation to the VOLUME leg (same
+  universe, same direction logic), but a patient DSL exit: most positions still
+  exit early via Phase 1 / weak_peak, while the ~5% that catch a real directional
+  move ratchet through a 5-tier Phase 2 (T0..T4) up to +50% margin ROE before
+  retrace. 2 slots @ $1300 margin, 5x, 4h hard timeout. Paired with the VOLUME
+  leg on a separate wallet.
+
+strategy:
+  wallet: "${TURBINE_RUNNERS_WALLET}"
+  slots: 2                          # source slots.runners 2
+  margin_per_slot: 100              # FALLBACK sizing — used only if a signal omits marginUsd. scan.py emits per-signal marginUsd (from inputs below), which WINS. TEST 100; prod source margin.runners 1300 (config v3.3)
+  default_leverage: 5               # source leverage.runners 5 (clamped per-asset in scan.py)
+  trading_risk: moderate            # source trading_risk balanced → nearest v2 tier moderate
+  enabled: true
+
+scanners:
+  - name: position_tracker          # built-in: feeds DSL exit engine
+    type: position_tracker
+    interval_seconds: 10            # source interval 10s
+
+  - name: turbine_runners_signals   # supervised external scanner (SHARED scan.py)
+    type: external_scanner
+    path: ./scanners                # shared rotation scanner (one dir, two recipes)
+    entrypoint: scan.py
+    interval_seconds: 60            # source daemon interval_seconds 60
+    timeout_seconds: 45             # source tick_timeout 45
+    default_signal_validity_seconds: 120   # 2x tick; pass-through gate re-scores next tick
+    state_history_max_count: 200    # holds rotation index + held/last-closed/dedup records
+    inputs:
+      # ── rotation knobs (config v3.3; identical to volume) ──
+      xyzWeight: 0.80               # source xyzWeight 0.80
+      spreadMainBps: 3             # source spread.mainBps 3
+      spreadXyzBps: 10             # source spread.xyzBps 10
+      # ── per-leg sizing (runners) ──
+      leverage: 5                  # source leverage.runners 5
+      marginUsd: 100               # per-signal USD margin; scan.py emits it TOP-LEVEL → runtime honors it as the EFFECTIVE sizing (overrides margin_per_slot). TEST 100; prod source 1300
+      maxSlots: 2                  # source slots.runners 2 (per-tick emission ceiling)
+    signal_data_schema:
+      thesis: { type: string }
+      fundingRegime: { type: string, required: false }
+      fundingAnnualizedPct: { type: number, required: false }
+      spreadBps: { type: number, required: false }
+      isXyz: { type: boolean, required: false }
+
+actions:
+  - name: position_tracker_action   # rule-based lifecycle → DSL
+    action_type: POSITION_TRACKER
+    decision_mode: rule
+    scanners: [position_tracker]
+
+  - name: turbine_runners_entry     # OPEN_POSITION, rule mode (source LLM gate was pure pass-through)
+    action_type: OPEN_POSITION
+    decision_mode: rule
+    scanners: [turbine_runners_signals]
+    params:
+      order_type: FEE_OPTIMIZED_LIMIT
+      fee_optimized_limit_options:
+        ensure_execution_as_taker: true    # source runners exit taker true (don't let a winner slip)
+        execution_timeout_seconds: 60
+    context:
+      - type: signal
+        scanner: turbine_runners_signals
+
+# ── EXIT (DSL — patient; lets the ~5% real movers ride) ──
+exit:
+  engine: dsl
+  interval_seconds: 30              # source exit interval_seconds 30
+  order_type: FEE_OPTIMIZED_LIMIT
+  fee_optimized_limit_options:
+    ensure_execution_as_taker: true    # source runners exit taker true
+    execution_timeout_seconds: 60
+  dsl_preset:
+    hard_timeout:
+      enabled: true
+      interval_in_minutes: 240      # source hard_timeout 240min (4h absolute cap)
+    weak_peak_cut:
+      enabled: true
+      interval_in_minutes: 90       # source weak_peak 90min
+      min_value: 3.0                # source weak_peak min 3%
+    dead_weight_cut:
+      enabled: true
+      interval_in_minutes: 120      # source dead_weight 120min (flat 2h → cut)
+    phase1:
+      enabled: true
+      max_loss_pct: 30.0            # source phase1 max_loss 30
+      retrace_threshold: 8          # source phase1 retrace 8
+      consecutive_breaches_required: 1
+    phase2:
+      enabled: true
+      tiers:                        # source T0..T4 — carried verbatim
+        - { trigger_pct: 5,  lock_hw_pct: 0  }
+        - { trigger_pct: 10, lock_hw_pct: 35 }
+        - { trigger_pct: 20, lock_hw_pct: 55 }
+        - { trigger_pct: 35, lock_hw_pct: 75 }
+        - { trigger_pct: 50, lock_hw_pct: 85 }
+
+# ── RISK guard rails (from runtime-runners.yaml; minutes → seconds) ──
+risk:
+  data_retention_seconds: 259200    # 72h (was data_retention_hours 72)
+  guard_rails:
+    daily_loss_limit_pct: 25
+    max_entries_per_day: 50
+    bypass_max_entries_per_day_on_profit: true
+    max_consecutive_losses: 6
+    cooldown_seconds: 300           # was cooldown_minutes 5
+    drawdown_halt_pct: 25
+    drawdown_reset_on_day_rollover: false
+    per_asset_cooldown_seconds: 600 # was per_asset_cooldown_minutes 10

package/examples/strategies/turbine/recipe-volume.yaml

@@ -0,0 +1,129 @@
+# ── TURBINE · VOLUME leg (v2 supervised) ────────────────────────────
+# Funding-fade volume rotation, fast force-close. 7 slots, 10-min hard timeout.
+#
+# Ported from senpi-skills/turbine (producer v3.2.2, config v3.3) to the v2
+# supervised external-scanner contract. The producer daemon is gone: the runtime
+# supervises ../scanners/scan.py (SHARED with the runners leg) and calls
+# scan(inputs, ctx) every `interval_seconds`. Both turbine legs run the SAME
+# rotation alpha — only the sizing (inputs) and DSL exit differ. See scan.py.
+name: turbine-volume
+version: 2.0.0
+group: turbine                      # agent-facing handle (BOTH legs share it)
+description: >
+  TURBINE VOLUME — Funding-fade rotation across BTC/ETH/SOL/HYPE + xyz
+  (BRENTOIL/GOLD/SPX), probabilistic xyz-weighted pool pick. Pure high-notional
+  volume printing: 7 slots @ $700 margin, 5x, force-closed by a 10-min DSL hard
+  timeout with no Phase 2. Shares the rotation scanner with the RUNNERS leg on a
+  separate wallet; the wallet boundary selects the DSL exit.
+
+strategy:
+  wallet: "${TURBINE_VOLUME_WALLET}"
+  slots: 7                          # source slots.volume 7
+  margin_per_slot: 100              # FALLBACK sizing — used only if a signal omits marginUsd. scan.py emits per-signal marginUsd (from inputs below), which WINS. TEST 100; prod source margin.volume 700 (config v3.3)
+  default_leverage: 5               # source leverage.volume 5 (clamped per-asset in scan.py)
+  trading_risk: aggressive          # source trading_risk aggressive
+  enabled: true
+
+scanners:
+  - name: position_tracker          # built-in: feeds DSL exit engine
+    type: position_tracker
+    interval_seconds: 10            # source interval 10s
+
+  - name: turbine_volume_signals    # supervised external scanner (SHARED scan.py)
+    type: external_scanner
+    path: ./scanners                # shared rotation scanner (one dir, two recipes)
+    entrypoint: scan.py
+    interval_seconds: 60            # source daemon interval_seconds 60
+    timeout_seconds: 45             # source tick_timeout 45
+    default_signal_validity_seconds: 120   # 2x tick; pass-through gate re-scores next tick
+    state_history_max_count: 200    # holds rotation index + held/last-closed/dedup records
+    inputs:
+      # ── rotation knobs (config v3.3) ──
+      xyzWeight: 0.80               # source xyzWeight 0.80
+      spreadMainBps: 3             # source spread.mainBps 3
+      spreadXyzBps: 10             # source spread.xyzBps 10
+      # ── per-leg sizing (volume) ──
+      leverage: 5                  # source leverage.volume 5
+      marginUsd: 100               # per-signal USD margin; scan.py emits it TOP-LEVEL → runtime honors it as the EFFECTIVE sizing (overrides margin_per_slot). TEST 100; prod source 700
+      maxSlots: 7                  # source slots.volume 7 (per-tick emission ceiling)
+    signal_data_schema:
+      thesis: { type: string }
+      fundingRegime: { type: string, required: false }
+      fundingAnnualizedPct: { type: number, required: false }
+      spreadBps: { type: number, required: false }
+      isXyz: { type: boolean, required: false }
+
+actions:
+  - name: position_tracker_action   # rule-based lifecycle → DSL
+    action_type: POSITION_TRACKER
+    decision_mode: rule
+    scanners: [position_tracker]
+
+  - name: turbine_volume_entry      # OPEN_POSITION, rule mode (source LLM gate was pure pass-through)
+    action_type: OPEN_POSITION
+    decision_mode: rule
+    scanners: [turbine_volume_signals]
+    params:
+      order_type: FEE_OPTIMIZED_LIMIT
+      fee_optimized_limit_options:
+        ensure_execution_as_taker: false   # source volume: maker-only (free volume)
+        execution_timeout_seconds: 60      # source exit timeout 60 (entry was 180; v2 owns order lifecycle)
+    context:
+      - type: signal
+        scanner: turbine_volume_signals
+
+# ── EXIT (DSL — pure rotation, force-close on the clock; NO Phase 2) ──
+exit:
+  engine: dsl
+  interval_seconds: 30              # source exit interval_seconds 30
+  order_type: FEE_OPTIMIZED_LIMIT
+  fee_optimized_limit_options:
+    ensure_execution_as_taker: false   # source volume exit taker false (free volume)
+    execution_timeout_seconds: 60
+  dsl_preset:
+    hard_timeout:
+      enabled: true
+      interval_in_minutes: 10       # source hard_timeout 10min — force every position off the clock
+    weak_peak_cut:
+      enabled: false                # source disabled on volume
+      interval_in_minutes: 60
+      min_value: 1.0
+    dead_weight_cut:
+      enabled: false                # source disabled on volume
+      interval_in_minutes: 60
+    phase1:
+      enabled: true
+      max_loss_pct: 50.0            # source phase1 max_loss 50
+      retrace_threshold: 30         # source phase1 retrace 30
+      consecutive_breaches_required: 1
+    phase2:
+      enabled: false                # source: NO phase2 on volume — disabled, never advances
+      # The v2 DSL parser requires a non-empty tiers array even when phase2 is
+      # disabled (parsePreset: "must have tiers or phase2.tiers"). The source used
+      # `tiers: []`, which v2 rejects. One inert placeholder tier satisfies the
+      # parser; `enabled: false` keeps phase2 off (config.test.ts confirms a
+      # disabled phase2 with tiers present yields phase2Enabled=false). This is the
+      # only threshold that does not map 1:1 to the v2 schema for the volume leg.
+      tiers:
+        - { trigger_pct: 100, lock_hw_pct: 0 }
+
+# ── RISK guard rails (from runtime-volume.yaml; minutes → seconds) ──
+risk:
+  data_retention_seconds: 259200    # 72h (was data_retention_hours 72)
+  guard_rails:
+    daily_loss_limit_pct: 50
+    max_entries_per_day: 1500
+    bypass_max_entries_per_day_on_profit: true
+    max_consecutive_losses: 30
+    cooldown_seconds: 60            # was cooldown_minutes 1 (schema min 60s)
+    drawdown_halt_pct: 50
+    drawdown_reset_on_day_rollover: true
+    # per_asset_cooldown OMITTED — source set per_asset_cooldown_minutes: 0 (disabled).
+    # v2 per_asset_cooldown_seconds has a min of 300; 0 is not expressible, and omitting
+    # the key == disabled, which is the faithful representation of the source's intent.
+
+notifications:
+  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
+  dsl_lifecycle: false
+  dsl_notify_sl_updates: false
+  action_lifecycle: false

package/examples/strategies/turbine/scanners/scan.py

@@ -0,0 +1,283 @@
+"""TURBINE — shared supervised external scanner entrypoint (volume + runners).
+
+Port of senpi-skills/turbine (producer v3.2.2) to the v2 `scan(inputs, ctx)` contract. The
+daemon loop is gone — the runtime supervisor calls scan() every interval_seconds.
+
+ONE scanner, TWO recipes. Turbine's two legs (volume + runners) ran the IDENTICAL volume-
+rotation alpha on the source; only the DSL exit preset and the per-slot sizing differed, and
+those live entirely in the recipe YAMLs. So both recipe-volume.yaml and recipe-runners.yaml
+point `path: ./scanners` + `entrypoint: scan.py` at THIS one module. The `inputs` block carries
+the per-leg sizing (marginUsd, leverage, slots) so the same code emits correctly-sized signals
+for whichever leg supervises it.
+
+What stayed faithful to the source (see scoring.py — ported verbatim):
+  - Universe MAIN={BTC,ETH,SOL,HYPE} / XYZ={xyz:BRENTOIL,xyz:GOLD,xyz:SPX}.
+  - Probabilistic pool pick (xyzWeight 0.80) + deterministic rotation index.
+  - Direction = funding fade (crowded-long -> SHORT, crowded-short -> LONG, flat -> random).
+  - Spread gate: main <= 3bps, xyz <= 10bps (from the top-of-book mid).
+  - Skip held assets + 90s post-close cooldown.
+  - Emit one signal per free slot (filled by rotating the index).
+  - Per-wallet rotation index, prev-held set, and last-closed map: source kept these in JSON
+    files; here they live in ctx.state.
+
+FLAGS — behaviors that changed under the v2 contract (do NOT read as silent drops):
+
+  1. cancel_order stale-order sweep — DROPPED (was producer.sweep_stale_resting_orders).
+     The source cancelled orphaned resting maker orders each tick. Those orphans were an
+     artifact of the OLD daemon/helpers-migration era: a runtime swap left resting ALOs that
+     the NEW runtime instance did not own, so they starved slots forever. Under v2 the
+     SUPERVISED runtime owns its own order lifecycle end-to-end:
+       - FEE_OPTIMIZED_LIMIT `execution_timeout_seconds` cancels the entry maker order the
+         runtime itself placed if it doesn't fill in time, and
+       - the DSL `hard_timeout` force-closes any position that does fill.
+     There is no second uncoordinated runtime to leave orphans, so the sweep is redundant.
+     A scanner's job is to PRODUCE SIGNALS, not to manage orders — so the cancel side-effect
+     is intentionally not ported. (If, in operation, orphaned ALOs ever reappear, the right
+     fix is a runtime-side reconcile, not a scanner side-effect.)
+
+  2. effective_slots auto-downsize / per-tick emission cap — MOVED to the runtime. The source
+     computed effective_slots = min(maxSlots, account_value / margin_per_slot) and emitted at
+     most that many signals per tick. In v2 the runtime owns slot count (strategy.slots) and
+     affordability (risk gates), so scan() emits ALL candidates clearing the gates (held +
+     cooldown + spread), carrying marginUsd + leverage at each signal's TOP LEVEL. We still emit
+     at most `maxSlots` candidates per tick (the rotation only advances that many times) so the
+     scanner doesn't flood the queue, but the runtime makes the final open/skip decision.
+
+  3. random pool/direction picks are non-deterministic — kept verbatim (this is the source's
+     design: rotation desync + neutral-regime coin flip). Tests assert STRUCTURE (valid gated
+     signals) and seed/inject rng for the deterministic paths.
+
+  4. runners optional — an empty TURBINE_RUNNERS_WALLET means runners-only is simply not
+     launched; the volume leg runs standalone. There is no cross-leg coupling in this module
+     (the source's per-wallet desync came from independent rotation indices, which here is just
+     each leg owning its own ctx.state).
+
+State (in ctx.state, newest record wins): {"signaled": {coin_key: ts}, "last_closed":
+{coin_key: {"ts": ts}}, "rotation_index": int, "held": [coin_key, ...]}.
+"""
+
+import sys
+import time
+
+import scoring
+
+
+def _dex_for(asset):
+    return "xyz" if asset.lower().startswith("xyz:") else ""
+
+
+def _get_universe_meta(ctx):
+    """{name: {"max_leverage": int|None}} for live instruments (one call). Used only to clamp
+    leverage to the venue max; turbine's source used a fixed 5x and let the runtime clamp."""
+    try:
+        data = ctx.senpi_mcp.call_tool("market_list_instruments", {})
+    except Exception:
+        return {}
+    out = {}
+    if not data:
+        return out
+    insts = data.get("data", data) if isinstance(data, dict) else data
+    if isinstance(insts, dict):
+        insts = insts.get("instruments", [])
+    for inst in insts or []:
+        if not isinstance(inst, dict):
+            continue
+        if inst.get("is_delisted"):
+            continue
+        name = inst.get("name") or (inst.get("context", {}) or {}).get("coin")
+        if not name:
+            continue
+        entry = {"max_leverage": inst.get("max_leverage", inst.get("maxLeverage"))}
+        out[name] = entry
+        out[name.upper()] = entry
+    return out
+
+
+def _fetch_asset_data(ctx, asset):
+    """market_get_asset_data with order book + funding for one asset (spread + regime)."""
+    try:
+        return ctx.senpi_mcp.call_tool("market_get_asset_data", {
+            "asset": asset,
+            "candle_intervals": [],
+            "include_funding": True,
+            "include_order_book": True,
+            "dex": _dex_for(asset),
+        })
+    except Exception:
+        return None
+
+
+def _get_held(ctx):
+    """held_keys set from open positions + non-reduceOnly resting orders, across both dexes.
+
+    Mirrors the source's held accounting (positions via clearinghouse_state, resting maker
+    orders via open_orders), so a slot the runtime is already working is not double-filled.
+    Reduce-only / trigger orders are DSL exit legs — never slot occupiers."""
+    held = set()
+    try:
+        ch = ctx.senpi_mcp.call_tool("strategy_get_clearinghouse_state",
+                                     {"strategy_wallet": ctx.wallet})
+    except Exception:
+        ch = None
+    account_value = 0.0
+    if ch:
+        data = ch.get("data", ch) if isinstance(ch, dict) else ch
+        if isinstance(data, dict):
+            for section in ("main", "xyz"):
+                s = data.get(section, {})
+                if not isinstance(s, dict):
+                    continue
+                ms = s.get("marginSummary", {})
+                account_value += scoring.safe_float(ms.get("accountValue", 0))
+                for ap in s.get("assetPositions", []) or []:
+                    pos = ap.get("position", ap)
+                    if scoring.safe_float(pos.get("szi", 0)) == 0:
+                        continue
+                    coin = pos.get("coin", "")
+                    if coin:
+                        held.add(scoring.normalize_coin_key(coin))
+
+    try:
+        od = ctx.senpi_mcp.call_tool("strategy_get_open_orders",
+                                     {"strategy_wallet": ctx.wallet})
+    except Exception:
+        od = None
+    if od:
+        orders = od.get("data", od) if isinstance(od, dict) else od
+        if isinstance(orders, dict):
+            orders = orders.get("orders", orders.get("openOrders", []))
+        if isinstance(orders, list):
+            for o in orders:
+                if not isinstance(o, dict):
+                    continue
+                if o.get("reduceOnly") or o.get("isTrigger"):
+                    continue
+                coin = o.get("coin") or o.get("asset", "")
+                if coin:
+                    held.add(scoring.normalize_coin_key(coin))
+    return held, account_value
+
+
+# ── ctx.state I/O ──
+
+def _load_state(ctx):
+    if ctx.state is None or len(ctx.state) == 0:
+        return {}, {}, 0
+    last = ctx.state.last() or {}
+    signaled = last.get("signaled", {})
+    last_closed = last.get("last_closed", {})
+    rot_idx = last.get("rotation_index", 0)
+    return (dict(signaled) if isinstance(signaled, dict) else {},
+            dict(last_closed) if isinstance(last_closed, dict) else {},
+            int(rot_idx) if isinstance(rot_idx, int) else 0)
+
+
+def _load_prev_held(ctx):
+    if ctx.state is None or len(ctx.state) == 0:
+        return set()
+    last = ctx.state.last() or {}
+    held = last.get("held", [])
+    return set(held) if isinstance(held, list) else set()
+
+
+def scan(inputs, ctx):
+    now = time.time()
+    xyz_weight = float(inputs.get("xyzWeight", 0.80))
+    spread_main_bps = float(inputs.get("spreadMainBps", 3))
+    spread_xyz_bps = float(inputs.get("spreadXyzBps", 10))
+    leg_leverage = float(inputs.get("leverage", 5))
+    margin_usd = float(inputs.get("marginUsd", 700))
+    max_slots = int(inputs.get("maxSlots", 7))
+
+    held_set, _account_value = _get_held(ctx)
+
+    # Detect closes since last tick -> stamp last_closed (drives the 90s post-close cooldown).
+    prev_signaled, last_closed, rot_idx = _load_state(ctx)
+    prev_held = _load_prev_held(ctx)
+    closed_this_tick = prev_held - held_set
+    for k in closed_this_tick:
+        last_closed[k] = {"ts": now}
+    # Prune cooldown entries well past the window so last_closed doesn't grow unbounded.
+    cutoff = now - (scoring.POST_CLOSE_COOLDOWN_SECONDS * 4)
+    last_closed = {k: v for k, v in last_closed.items()
+                   if scoring.safe_float(v.get("ts", 0)) >= cutoff}
+
+    free_slots = max(0, max_slots - len(held_set))
+    if free_slots <= 0:
+        if ctx.state is not None:
+            try:
+                ctx.state.append({"signaled": prev_signaled, "last_closed": last_closed,
+                                  "rotation_index": rot_idx, "held": sorted(held_set)})
+            except Exception as exc:
+                # See note at the end-of-tick append below: a swallowed failure
+                # here lets the next tick reload stale dedup state and re-emit
+                # suppressed signals. Log-and-continue, don't crash the tick.
+                print(
+                    f"[turbine.scan] WARNING: dedup-state append failed (no-slot "
+                    f"branch); next tick may re-emit suppressed signals: {exc!r}",
+                    file=sys.stderr,
+                )
+        return []
+
+    meta_map = _get_universe_meta(ctx)
+
+    # working_held: assets already held PLUS those we emit this tick, so the rotation index
+    # advances past them (mirrors fill_wallet_slots adding to held_keys after each emit).
+    working_held = set(held_set)
+    out = []
+    for _ in range(free_slots):
+        asset, rot_idx = scoring.pick_rotation_asset(
+            rot_idx, xyz_weight, working_held, last_closed, now=now)
+        if asset is None:
+            break
+        resp = _fetch_asset_data(ctx, asset)
+        ad = scoring.parse_asset_data(resp)
+        if ad is None:
+            continue
+        if not scoring.spread_ok(asset, ad["spread_bps"], spread_main_bps, spread_xyz_bps):
+            continue
+        direction, thesis = scoring.choose_direction(ad["funding_regime"])
+
+        meta = meta_map.get(asset) or meta_map.get(asset.upper()) or {}
+        leverage = scoring.clamp_leverage(leg_leverage, meta.get("max_leverage"))
+        if leverage <= 0:
+            continue
+
+        out.append({
+            "asset": asset,
+            "direction": direction,
+            "marginUsd": float(margin_usd),
+            "leverage": float(leverage),
+            "data": {
+                "thesis": thesis,
+                "fundingRegime": ad["funding_regime"],
+                "fundingAnnualizedPct": float(ad["funding_annualized_pct"]),
+                "spreadBps": float(ad["spread_bps"]),
+                "isXyz": scoring.is_xyz(asset),
+            },
+        })
+        coin_key = scoring.normalize_coin_key(asset)
+        working_held.add(coin_key)
+        prev_signaled[coin_key] = now
+
+    # If this append fails (e.g. state_history_max_count is 0/unset so append
+    # raises, or a transient persist error), the next tick reloads stale dedup
+    # state and may re-emit already-suppressed signals. Log-and-continue: don't
+    # crash the tick, but make the failure visible on stderr (the runtime
+    # supervisor captures the scaffold child's stderr) instead of swallowing it.
+    if ctx.state is not None:
+        try:
+            ctx.state.append({
+                "signaled": prev_signaled,
+                "last_closed": last_closed,
+                "rotation_index": rot_idx,
+                "held": sorted(working_held),
+            })
+        except Exception as exc:
+            print(
+                f"[turbine.scan] WARNING: dedup-state append failed; next tick "
+                f"may re-emit suppressed signals: {exc!r}",
+                file=sys.stderr,
+            )
+
+    return out