@senpi/runtime 3.0.0-dev.openclaw-upgrade-mai.20260623210452 → 3.0.0-dev.runtime-phase-2.20260623210537

package/dist/scanners/external/scaffold/state_manager.py

@@ -1,175 +0,0 @@
-"""Disk-backed, bounded, transactional state series for the scaffold core.
-
-`StateManager` is the `ctx.state` capability the supervised external scanner
-author sees: a list-like series of dict records, persisted between ticks and
-bounded by `state_history_max_count`.
-
-Shape (per scanner-and-ctx-design.md §2.3):
-
-    StateManager(state_path, state_history_max_count)
-
-  Author surface:
-    append(record)   record MUST be a dict; a reserved `recorded_at` (float
-                     SECONDS, time.time() magnitude — never ms) is injected.
-                     scaffold wins on a `recorded_at` collision. returns None.
-                     RAISES when state_history_max_count is 0/unset — history
-                     disabled is a hard error, never a silent no-op.
-    recent(n)        last n entries, chronological (oldest->newest); n<=0 -> [].
-    last()           most recent entry, or None if empty.
-    __len__ / __getitem__ (index + slice) / __iter__ (oldest -> newest).
-
-  Internals: backed by collections.deque(maxlen=state_history_max_count).
-  Loading an on-disk series longer than the bound keeps the NEWEST entries
-  (deque eviction drops the oldest).
-
-  Transactional (one commit per tick):
-    commit()    persists the working buffer via the atomic write_state.
-                JSON-serializability is enforced LOUD here — a failed persist
-                RAISES and does NOT advance the committed snapshot, leaving the
-                prior on-disk state intact.
-    rollback()  discards mid-tick mutations: the working buffer is restored to
-                the last committed snapshot.
-    read-your-writes within a tick: appended records are visible via
-    len/recent/last/iter/getitem BEFORE commit.
-"""
-
-from __future__ import annotations
-
-import copy
-import time
-from collections import deque
-
-from .scaffold_state import read_state, write_state
-
-# Reserved, scaffold-owned key injected into every record. Float seconds.
-RECORDED_AT_KEY = "recorded_at"
-
-
-class StateManager:
-    """A disk-backed, bounded, transactional series of dict records."""
-
-    def __init__(self, state_path: str, state_history_max_count):
-        self._state_path = state_path
-        # 0 / None / falsy => history disabled. Kept as-is so append can raise.
-        self._max_count = state_history_max_count
-
-        # Load any persisted series. read_state never raises: missing/corrupt
-        # -> None. A non-list payload is treated as "no usable history".
-        # state_path None => no disk persistence (commit advances the in-memory
-        # snapshot but never writes). read_state needs a real path.
-        loaded = read_state(state_path) if state_path is not None else None
-        if not isinstance(loaded, list):
-            loaded = []
-
-        # The committed snapshot is the last durably-persisted series; the
-        # working buffer is what the current tick reads/mutates. Both are
-        # bounded the same way (deque(maxlen=...)); loading a longer-than-bound
-        # series keeps the NEWEST entries (deque evicts from the left).
-        self._committed = self._new_deque(loaded)
-        self._working = self._snapshot(self._committed)
-
-    # -- internals ---------------------------------------------------------
-
-    def _new_deque(self, initial=()):
-        """A deque bounded by max_count. When history is disabled (max_count is
-        0/None) the bound is 0 — nothing can ever be buffered."""
-        maxlen = self._max_count if self._max_count else 0
-        return deque(initial, maxlen=maxlen)
-
-    def _snapshot(self, source):
-        """An independent bounded deque whose records share NO mutable state
-        with `source`. Committed and working buffers must never alias the same
-        dict objects — otherwise a mid-tick mutation of a record (an author
-        scribbling on a dict handed back by last()/recent()/getitem) would
-        survive a rollback and corrupt the very snapshot the rollback restores.
-        Deep-copy at every snapshot boundary (load / commit / rollback)."""
-        return self._new_deque(copy.deepcopy(entry) for entry in source)
-
-    # -- author surface ----------------------------------------------------
-
-    def append(self, record) -> None:
-        """Append a dict record to the working buffer.
-
-        Injects the reserved `recorded_at` (float seconds, scaffold wins on
-        collision). Raises TypeError if record is not a dict. Raises if history
-        is disabled (state_history_max_count 0/unset) — never a silent no-op.
-        """
-        if not self._max_count:
-            raise ValueError(
-                "state is disabled: state_history_max_count is 0 or unset "
-                "(set it > 0 to use ctx.state.append)"
-            )
-        # bool is an int subclass but never a dict; explicit dict check rejects
-        # lists/tuples/sets/strings/numbers/None/objects/bool alike.
-        if not isinstance(record, dict):
-            raise TypeError(
-                f"state record must be a dict, got {type(record).__name__}"
-            )
-
-        # Copy so the author's dict is never mutated, then stamp recorded_at.
-        # scaffold wins on collision: assign AFTER copying author keys.
-        entry = dict(record)
-        entry[RECORDED_AT_KEY] = time.time()
-        self._working.append(entry)
-        return None
-
-    def recent(self, n) -> list:
-        """The last n entries, chronological (oldest->newest).
-
-        n <= 0 returns []; n greater than the buffer returns the whole buffer.
-        Negative n is NOT a from-the-end slice — it is meaningless for "last n"
-        and yields [].
-        """
-        if n <= 0:
-            return []
-        items = list(self._working)
-        return items[-n:]
-
-    def last(self):
-        """The most recent entry, or None if empty."""
-        if not self._working:
-            return None
-        return self._working[-1]
-
-    # -- sequence protocol -------------------------------------------------
-
-    def __len__(self) -> int:
-        return len(self._working)
-
-    def __getitem__(self, key):
-        # deque supports integer indexing (raising IndexError out of range) but
-        # not slicing; materialise a list so slices work with Python semantics
-        # (clamping, steps, negative bounds) and index errors still propagate.
-        if isinstance(key, slice):
-            return list(self._working)[key]
-        return self._working[key]
-
-    def __iter__(self):
-        return iter(self._working)
-
-    # -- transaction -------------------------------------------------------
-
-    def commit(self) -> None:
-        """Persist the working buffer atomically via write_state.
-
-        JSON-serializability is enforced LOUD: write_state returns False on a
-        non-serializable value (or IO failure) without touching the existing
-        file. We raise on that False so a failed persist never silently
-        advances the committed snapshot — the prior on-disk state stays intact.
-        """
-        payload = list(self._working)
-        # No disk path => commit advances the in-memory snapshot only.
-        ok = True if self._state_path is None else write_state(self._state_path, payload)
-        if not ok:
-            raise RuntimeError(
-                f"failed to persist state to {self._state_path} "
-                "(non-serializable value or IO error); state not advanced"
-            )
-        # Durable: advance the committed snapshot to match what is on disk.
-        # Deep-copy so the committed snapshot does not alias working records.
-        self._committed = self._snapshot(self._working)
-
-    def rollback(self) -> None:
-        """Discard mid-tick mutations: restore the working buffer to the last
-        committed snapshot. Never touches disk."""
-        self._working = self._snapshot(self._committed)

package/dist/utils/keyed-mutex.d.ts

@@ -1,37 +0,0 @@
-/**
- * KeyedMutex — per-key async serialization primitive.
- *
- * Concurrent calls with DIFFERENT keys run in parallel.
- * Concurrent calls with the SAME key are queued and run strictly FIFO.
- *
- * NON-REENTRANT by design: calling withKeyLock(k, ...) from *inside* a fn
- * that is already holding lock k will deadlock. Callers must not nest
- * same-key locks. If you need reentrance, restructure the call to pass the
- * already-computed value in or extract the critical section into a helper
- * that runs outside the lock.
- *
- * Memory: once a key has no holder and no waiters its internal entry is
- * deleted — the Map does not grow unboundedly.
- */
-export declare class KeyedMutex {
-    private readonly locks;
-    /**
-     * Acquire the lock for `key`, execute `fn`, release the lock, and return
-     * the resolved value of `fn`. If `fn` throws or rejects, the error is
-     * propagated to the caller and the lock is released so the next waiter
-     * can proceed.
-     */
-    withKeyLock<T>(key: string, fn: () => Promise<T> | T): Promise<T>;
-    /**
-     * Number of keys that currently have an active holder or at least one
-     * waiter. Returns 0 once all locks have fully drained.
-     * Exposed for testing; not part of the production surface.
-     */
-    size(): number;
-    /**
-     * Whether an entry exists for `key` (holder or waiters present).
-     * Exposed for testing; not part of the production surface.
-     */
-    hasKey(key: string): boolean;
-}
-//# sourceMappingURL=keyed-mutex.d.ts.map

package/dist/utils/keyed-mutex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-mutex.d.ts","sourceRoot":"","sources":["../../src/utils/keyed-mutex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IAEtD;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAwCvE;;;;OAIG;IACH,IAAI,IAAI,MAAM;IAId;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAG7B"}

package/dist/utils/keyed-mutex.js

@@ -1,77 +0,0 @@
-/**
- * KeyedMutex — per-key async serialization primitive.
- *
- * Concurrent calls with DIFFERENT keys run in parallel.
- * Concurrent calls with the SAME key are queued and run strictly FIFO.
- *
- * NON-REENTRANT by design: calling withKeyLock(k, ...) from *inside* a fn
- * that is already holding lock k will deadlock. Callers must not nest
- * same-key locks. If you need reentrance, restructure the call to pass the
- * already-computed value in or extract the critical section into a helper
- * that runs outside the lock.
- *
- * Memory: once a key has no holder and no waiters its internal entry is
- * deleted — the Map does not grow unboundedly.
- */
-export class KeyedMutex {
-    locks = new Map();
-    /**
-     * Acquire the lock for `key`, execute `fn`, release the lock, and return
-     * the resolved value of `fn`. If `fn` throws or rejects, the error is
-     * propagated to the caller and the lock is released so the next waiter
-     * can proceed.
-     */
-    async withKeyLock(key, fn) {
-        const existing = this.locks.get(key);
-        let releaseCurrent;
-        // A promise that the *next* waiter will chain on.
-        const current = new Promise((resolve) => {
-            releaseCurrent = resolve;
-        });
-        if (existing == null) {
-            // First caller for this key — create the entry.
-            this.locks.set(key, { tail: current, refCount: 1 });
-            // No predecessor to wait for; run immediately.
-        }
-        else {
-            // There is already a holder (or a queue). Chain behind the current tail.
-            existing.refCount += 1;
-            const predecessor = existing.tail;
-            // Update tail so the *next* arrival chains behind us.
-            existing.tail = current;
-            // Wait for the predecessor to finish.
-            await predecessor;
-        }
-        try {
-            return await fn();
-        }
-        finally {
-            // Release: let the next waiter proceed.
-            releaseCurrent();
-            // Decrement refcount; if nobody remains, prune the entry.
-            const entry = this.locks.get(key);
-            if (entry != null) {
-                entry.refCount -= 1;
-                if (entry.refCount === 0) {
-                    this.locks.delete(key);
-                }
-            }
-        }
-    }
-    /**
-     * Number of keys that currently have an active holder or at least one
-     * waiter. Returns 0 once all locks have fully drained.
-     * Exposed for testing; not part of the production surface.
-     */
-    size() {
-        return this.locks.size;
-    }
-    /**
-     * Whether an entry exists for `key` (holder or waiters present).
-     * Exposed for testing; not part of the production surface.
-     */
-    hasKey(key) {
-        return this.locks.has(key);
-    }
-}
-//# sourceMappingURL=keyed-mutex.js.map

package/dist/utils/keyed-mutex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-mutex.js","sourceRoot":"","sources":["../../src/utils/keyed-mutex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,MAAM,OAAO,UAAU;IACJ,KAAK,GAAG,IAAI,GAAG,EAAqB,CAAC;IAEtD;;;;;OAKG;IACH,KAAK,CAAC,WAAW,CAAI,GAAW,EAAE,EAAwB;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAErC,IAAI,cAA2B,CAAC;QAChC,kDAAkD;QAClD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAC5C,cAAc,GAAG,OAAO,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEH,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YACrB,gDAAgD;YAChD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;YACpD,+CAA+C;QACjD,CAAC;aAAM,CAAC;YACN,yEAAyE;YACzE,QAAQ,CAAC,QAAQ,IAAI,CAAC,CAAC;YACvB,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC;YAClC,sDAAsD;YACtD,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC;YACxB,sCAAsC;YACtC,MAAM,WAAW,CAAC;QACpB,CAAC;QAED,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;gBAAS,CAAC;YACT,wCAAwC;YACxC,cAAc,EAAE,CAAC;YAEjB,0DAA0D;YAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAClC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,KAAK,CAAC,QAAQ,IAAI,CAAC,CAAC;gBACpB,IAAI,KAAK,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;oBACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACzB,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,GAAW;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;CACF"}

package/examples/strategies/iguana/README.md

@@ -1,135 +0,0 @@
-# IGUANA (v2 supervised demo)
-
-Iguana is a **single-wallet, single-recipe** XYZ **macro index-trend** strategy:
-the closest thing to an index fund, but 24/7 on Hyperliquid. It trend-follows the
-two broad XYZ indices and trades the stronger move — **two assets, one decision
-per tick**. No stock-picking, no commodities, no pre-IPO. Onboarding tier.
-
-Ported from `senpi-skills/iguana` (producer v1.0.1, config v1.0.0) to the runtime
-v2 supervised external-scanner contract. The standalone producer daemon is gone;
-the runtime supervises `scanners/scan.py` and calls `scan()` every
-`interval_seconds` (300s).
-
-## The strategy (`scanners/scan.py`)
-
-Index-trend pipeline, run once per tick:
-
-1. **Whitelist** — the two broad XYZ indices `{xyz:SP500, xyz:XYZ100}`.
-2. **Trend strength** — for each non-held index, fetch 4h candles
-   (`market_get_asset_data`, `candle_intervals ["4h"]`) and compute the **4-day
-   trend strength**: the % change of the latest 4h close vs the close
-   `trendLookbackBars` (**24** = 4 days) bars ago.
-3. **Pick the strongest** — the index with the highest `|strength|` above
-   `minTrendPct` (**1.5%**).
-4. **Score** — base **3**, **+2** if `|strength| ≥ strongTrendPct` (**4.0%**),
-   **+1** if volume is rising (> **15%** over the last 6 bars). Emit only if
-   `score ≥ minScore` (**4**).
-5. **Direction** = sign of the trend (LONG if up, SHORT if down).
-6. **Emit the single strongest** index trend — at most one signal per tick.
-
-The pure trend/scoring functions (`trend_strength`, `trend_direction`,
-`pick_strongest_trend`, `volume_trend`, `build_thesis`) were already unit-tested
-in the source repo and are ported **verbatim** into `scoring.py`.
-
-Sizing rides on each signal's `data{}` so the `OPEN_POSITION` rule action sizes
-identically to the source:
-
-- **marginUsd** = `account_value × marginPct`, `marginPct` **0.20**. Dual-DEX
-  equity is collapsed via **`max()` not `sum()`** — one cross-margined wallet,
-  two sub-DEX views (summing double-counts the shared free balance → 2x sizing).
-- **leverage** = `min(config leverage 3, MAX_LEVERAGE 5)`.
-
-MCP tools used (all **read-only**): `market_get_asset_data` (4h candles),
-`strategy_get_clearinghouse_state`.
-
-State (the per-coin **240s recent-signal** dedup map) lives in `ctx.state` (the
-source kept it in `recent-signals.json`).
-
-## Why iguana emits at most one signal per tick
-
-Turbine/spider emit **all** gated candidates and let the runtime apply the slot
-ceiling. **Iguana is deliberately different: it emits ≤ 1 signal per tick** — the
-single strongest index trend. This is the **strategy**, not an oversight:
-iguana's thesis is literally "two assets, **one decision per tick**," and the
-source producer picked the single strongest trend and pushed exactly one signal.
-`slots: 1` matches the single-position thesis.
-
-## Layout
-
-```
-iguana/
-├── README.md
-├── recipe.yaml            # the single recipe (path: ./scanners, entrypoint: scan.py)
-└── scanners/
-    ├── scan.py            # scan(inputs, ctx) entrypoint (index-trend pipeline)
-    └── scoring.py         # pure trend/scoring functions (unit-tested, ported verbatim)
-```
-
-## Environment variables
-
-| Variable           | Required | Purpose |
-|--------------------|----------|---------|
-| `IGUANA_WALLET`    | yes      | Iguana's strategy wallet |
-| `SENPI_API_KEY`    | yes      | MCP auth for `ctx.senpi_mcp` (injected into the scaffold child) |
-| `SENPI_MCP_URL`    | yes      | MCP server URL |
-| `TELEGRAM_CHAT_ID` | optional | Notifications |
-
-## Install / run
-
-```bash
-IGUANA_WALLET=0x... \
-SENPI_API_KEY=... SENPI_MCP_URL=https://mcp.prod.senpi.ai/mcp \
-  openclaw senpi run examples/strategies/iguana/recipe.yaml
-```
-
-## Fidelity notes
-
-Source behaviors that changed (or did not map 1:1) under the v2 contract.
-Nothing load-bearing was silently dropped.
-
-### Dropped: the daemon loop + ingest POST
-
-The source ran a `producer_daemon(interval_seconds=300)` that POSTed signals to
-the ingest endpoint via `push_signal`. Under v2 the runtime **supervises** this
-module and calls `scan()` once per `interval_seconds`; `scan()` is **single-pass
-and synchronous** and **returns a `list[dict]`**. The scaffold owns delivery, the
-wire envelope, and `signal_id` dedup. The source's normalized [0,1] wire score
-(`min(score / 6, 1.0)`) is **not** recomputed in `scan()` — the raw additive
-score rides on `data{}` and the runtime owns wire scoring. (The `6.0` divisor is
-preserved in `scoring.py` for parity.)
-
-### Moved to `ctx.state`: the 240s recent-signal dedup
-
-The per-coin **240s** recent-signal dedup that the source kept in
-`recent-signals.json` now lives in `ctx.state`: each tick reads the latest
-`{coin: ts}` map, **prunes** it by the source window (`4 × TTL`), **skips** coins
-signaled within the TTL, **stamps** the chosen candidate, and appends the updated
-map for the next tick.
-
-### Action gate: `decision_mode: llm` → `rule`
-
-The source `OPEN_POSITION` action used `decision_mode: llm` with a pass-through
-prompt that copied the signal's `asset`/`direction`/`leverage`/`marginUsd`
-verbatim and pinned confidence — a rule wearing an LLM costume. This recipe uses
-`decision_mode: rule` directly.
-
-### DSL preset maps cleanly
-
-The source DSL preset maps 1:1 to the v2 schema (no dropped tiers): hard_timeout
-2880m (48h), weak_peak 480m@3, dead_weight **disabled**, phase1 max_loss 12 /
-retrace 8, and a 5-tier phase2 (5/0 · 10/40 · 18/60 · 30/75 · 50/85) — all
-`trigger_pct ≤ 100` and the T0 `lock_hw_pct 0` is in the allowed `[0, 100]` range.
-`dead_weight_cut` is disabled (`enabled: false`) with an inert
-`interval_in_minutes` placeholder so the parser is satisfied.
-
-### Guard rails: minutes/hours → seconds
-
-The v2 schema uses integer seconds everywhere. `cooldown_minutes 90` →
-`cooldown_seconds 5400`; `per_asset_cooldown_minutes 360` →
-`per_asset_cooldown_seconds 21600` (clears the schema's 300s floor);
-`data_retention_hours 96` → `data_retention_seconds 345600`.
-
-### Only read-only MCP calls
-
-`scan.py` never opens, closes, or cancels — it produces signals. A test asserts
-no `create_position` / `close_position` / `cancel_order` tool is ever called.

package/examples/strategies/iguana/recipe.yaml

@@ -1,137 +0,0 @@
-# ── IGUANA (v2 supervised) ───────────────────────────────────────────
-# XYZ macro index trend — the simplest possible XYZ equity exposure.
-# SINGLE wallet, SINGLE recipe, ONE supervised scanner.
-#
-# Ported from senpi-skills/iguana (producer v1.0.1, config v1.0.0) to the v2
-# supervised external-scanner contract. The producer daemon is gone: the runtime
-# supervises ./scanners/scan.py and calls scan(inputs, ctx) every
-# `interval_seconds` (300s). All gates + scoring preserved exactly; the pure
-# trend/scoring functions are ported VERBATIM (they were already unit-tested in
-# the source). See scan.py + scoring.py.
-name: iguana-tracker
-version: 2.0.0
-group: iguana                       # agent-facing handle (harmless for single-wallet)
-description: >
-  IGUANA — XYZ Macro Index Trend. "I want stock-market exposure on Hyperliquid
-  without picking stocks." Trend-follows the two broad XYZ indices xyz:SP500 +
-  xyz:XYZ100 — two assets, ONE decision per tick. Each tick computes a 4-day
-  trend strength (% change of the latest 4h close vs 24 bars ago) per index,
-  picks the stronger move past minTrendPct (1.5%), scores it (base 3, +2 if the
-  move is strong >= 4%, +1 if volume is rising), and emits the SINGLE strongest
-  index trend in its direction if score >= minScore (4). Conservative sizing
-  (20% margin, 3x). DSL: 48h hard_timeout (XYZ weekend pricing-gap risk),
-  weak_peak 8h@3, 5-tier phase2 ladder. ONBOARDING TIER.
-
-strategy:
-  wallet: "${IGUANA_WALLET}"
-  slots: 1                          # source slots 1 (iguana emits <=1 signal/tick — two assets, one decision)
-  margin_pct: 20                    # source margin_pct 20 (% of account per slot; scan.py carries the exact marginUsd)
-  default_leverage: 3               # source leverage 3 (capped at MAX_LEVERAGE 5 in scan.py)
-  trading_risk: conservative        # source trading_risk conservative
-  enabled: true
-
-scanners:
-  - name: position_tracker          # built-in: feeds DSL exit engine
-    type: position_tracker
-    interval_seconds: 10            # source position_tracker interval 10s
-
-  - name: iguana_signals            # supervised external scanner
-    type: external_scanner
-    path: ./scanners
-    entrypoint: scan.py
-    interval_seconds: 300           # source producer_daemon interval_seconds 300 (5min)
-    timeout_seconds: 180            # source tick_timeout 180
-    default_signal_validity_seconds: 600   # 2x tick; pass-through gate re-scores next tick
-    state_history_max_count: 200    # holds the per-coin 240s recent-signal dedup map records
-    inputs:
-      # ── universe + trend gates (config v1.0.0) ──
-      whitelist: ["xyz:SP500", "xyz:XYZ100"]   # the two broad XYZ indices
-      trendLookbackBars: 24         # 24 × 4h bars = 4 days
-      minTrendPct: 1.5              # minimum |4-day move| to call it a trend
-      strongTrendPct: 4.0           # |move| >= this scores the strong-trend bonus (+2)
-      minScore: 4                   # additive-score floor to emit
-      # ── sizing (config v1.0.0) ──
-      marginPct: 0.20               # margin = account_value * 0.20
-      leverage: 3                   # leverage (capped at 5 in scan.py)
-    signal_data_schema:
-      score: { type: number }
-      direction: { type: string }
-      reasons: { type: array, required: false }
-      trendPct: { type: number, required: false }
-      volumeTrendPct: { type: number, required: false }
-      heldAssets: { type: array, required: false }
-
-actions:
-  - name: position_tracker_action   # rule-based lifecycle → DSL
-    action_type: POSITION_TRACKER
-    decision_mode: rule
-    scanners: [position_tracker]
-
-  - name: iguana_entry              # OPEN_POSITION, rule mode (source LLM gate was pure pass-through)
-    action_type: OPEN_POSITION
-    decision_mode: rule
-    scanners: [iguana_signals]
-    params:
-      order_type: FEE_OPTIMIZED_LIMIT
-      fee_optimized_limit_options:
-        ensure_execution_as_taker: true    # source entry ensureExecutionAsTaker true — ride the trend NOW
-        execution_timeout_seconds: 30
-    context:
-      - type: signal
-        scanner: iguana_signals
-
-# ── EXIT (DSL — balanced, XYZ-tuned; preset preserved from source v1.0.0) ──
-#
-# Index trends extend over days/weeks; the 48h hard_timeout accommodates the
-# weekend pricing-gap risk on XYZ. weak_peak_cut bails from flat-but-tired
-# positions before the weekend gap. dead_weight_cut is disabled (source).
-exit:
-  engine: dsl
-  interval_seconds: 60              # source exit interval_seconds 60
-  order_type: FEE_OPTIMIZED_LIMIT
-  fee_optimized_limit_options:
-    ensure_execution_as_taker: true
-    execution_timeout_seconds: 30
-  dsl_preset:
-    hard_timeout:
-      enabled: true
-      interval_in_minutes: 2880     # source hard_timeout 2880min (48h — XYZ weekend pricing-gap risk)
-    weak_peak_cut:
-      enabled: true
-      interval_in_minutes: 480      # source weak_peak 480min (8h)
-      min_value: 3.0                # source weak_peak min 3.0%
-    dead_weight_cut:
-      enabled: false                # source disabled
-      interval_in_minutes: 60       # inert (enabled:false) — placeholder for the parser
-    phase1:
-      enabled: true
-      max_loss_pct: 12.0            # source phase1 max_loss 12
-      retrace_threshold: 8          # source phase1 retrace 8
-      consecutive_breaches_required: 1
-    phase2:
-      enabled: true
-      tiers:                        # source T0..T4 — carried verbatim (all trigger_pct <= 100)
-        - { trigger_pct: 5,  lock_hw_pct: 0 }
-        - { trigger_pct: 10, lock_hw_pct: 40 }
-        - { trigger_pct: 18, lock_hw_pct: 60 }
-        - { trigger_pct: 30, lock_hw_pct: 75 }
-        - { trigger_pct: 50, lock_hw_pct: 85 }
-
-# ── RISK guard rails (from source runtime.yaml; minutes/hours → seconds) ──
-risk:
-  data_retention_seconds: 345600    # 96h (was data_retention_hours 96)
-  guard_rails:
-    daily_loss_limit_pct: 12
-    max_entries_per_day: 2
-    bypass_max_entries_per_day_on_profit: false
-    max_consecutive_losses: 3
-    cooldown_seconds: 5400          # was cooldown_minutes 90
-    drawdown_halt_pct: 20
-    drawdown_reset_on_day_rollover: false
-    per_asset_cooldown_seconds: 21600   # was per_asset_cooldown_minutes 360 (6h)
-
-notifications:
-  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
-  dsl_lifecycle: true
-  dsl_notify_sl_updates: false
-  action_lifecycle: true