Upload folder using huggingface_hub

LOOP.md

@@ -0,0 +1,72 @@
+# The Recursive Self-Improving Loop
+
+How tradewatch's soft reflection (events → MEMORY.md prompt text) becomes a real
+gradient loop on Laguna XS.2, where improvement compounds across iterations through
+**both adapter weights and curriculum**.
+
+## The two improvement channels
+
+1. **Weights (parametric continuation):** each hosted RL run warm-starts from the prior
+   iteration's adapter via `checkpoint_id`. The model is never reset — discipline learned
+   in iter N carries into iter N+1. This is the thing tradewatch never had.
+2. **Curriculum (reflection-driven):** between runs, `recursive_loop.py reflect` reads the
+   prior adapter's OOS eval and shifts the next run's **objective** (sharpe → min_drawdown
+   → balanced) and **focus symbols** (the weakest performers). This is tradewatch's
+   `summarize_session_events` reflection — repurposed to steer RL instead of prompt notes.
+
+## One iteration
+
+```
+                    ┌──────────────────────────────────────────────┐
+                    │  configs/rl/iter_N.toml                       │
+                    │  model=poolside/Laguna-XS.2                    │
+                    │  checkpoint_id=<iter N-1 adapter>  ← weights   │
+                    │  [[env]] objective=..., symbols=[weak...]      │
+                    └───────────────────┬──────────────────────────┘
+   prime train run iter_N.toml          │  (FREE hosted RL, GRPO, 128 rollouts/step)
+                                        ▼
+                    LoRA adapter  ──►  prime deployments create
+                                        │   base:adapter_id, OpenAI-compatible
+                                        ▼
+   python scripts/laguna_eval.py --model base:adapter_id --split oos_symbols
+                    (writes strategy per HELD-OUT symbol, scores via rubric)
+                                        │  logs/eval_*.json
+                                        ▼
+   python scripts/recursive_loop.py reflect <eval.json> --checkpoint-id <adapter>
+                    (curriculum policy → objective + weak-symbol focus)
+                                        │
+                                        ▼
+                    configs/rl/iter_{N+1}.toml   ──►  loop repeats
+```
+
+Note Prime enforces **max 1 concurrent run/user**, so iterations are sequential — which
+is exactly what warm-starting requires anyway (iter N+1 needs iter N's adapter to exist).
+
+## Curriculum policy (`_choose_objective`, inspectable & deterministic)
+- valid≥0.8 but mean_total<0.5  → `min_drawdown` (strategies run but lose → control risk)
+- pct_wrote_code<0.7            → `sharpe` + more steps (model still learning to code)
+- otherwise                     → `balanced` (competent → broaden)
+- always: next run focuses the 3 weakest OOS symbols, rotates `seed` for fresh task mixes,
+  lengthens to 75 steps if learning stalled (<0.5).
+
+## Closing to tradewatch (the demo)
+The deployed adapter is OpenAI-compatible, so tradewatch's existing `HybrieClient` runs it
+live with one config change:
+```
+base_url = https://api.pinference.ai/api/v1
+model    = poolside/Laguna-XS.2:<adapter_id>
+```
+**Ablation money-shot:** run the adapter with MEMORY.md stripped from the prompt. If the
+discipline holds, it's provably in the weights — the memory became the adapter.
+
+## Run it
+```bash
+# bootstrap iteration 1
+python scripts/recursive_loop.py init --env-id <you>/stock-strategy-env --model poolside/Laguna-XS.2
+prime train run configs/rl/iter_1.toml
+prime deployments create <adapter_id>
+export PRIME_API_KEY=...
+python scripts/laguna_eval.py --model poolside/Laguna-XS.2:<adapter_id> --split oos_symbols
+python scripts/recursive_loop.py reflect logs/eval_*.json --checkpoint-id <adapter_id>
+# -> configs/rl/iter_2.toml ready; repeat
+```

SPEC.md

@@ -0,0 +1,137 @@
+# hack-x — Environment & Training Spec
+
+A self-improving crypto-trading **coding agent** trained with RL on Prime Lab.
+tradewatch's soft reflection loop (events → MEMORY.md prompt rules) becomes a real
+gradient loop: rollout → backtest verifier → GRPO → **LoRA adapter** → deploy → live demo.
+
+---
+
+## 1. The one-line thesis
+> Today tradewatch's trading discipline lives as *prompt text* (MEMORY.md). We make it
+> live as *adapter weights* by rewarding disciplined, profitable behavior on
+> out-of-sample replayed market history. The proof: the trained adapter stays
+> disciplined with MEMORY.md **removed from the prompt**.
+
+## 1b. tradewatch as seed (pull all of it — but know its limits)
+Mined both DB (4,875 events) and journal (708 rows). What's there:
+- **618 `analysis_decision` rows** with 18 market features each (price_usd, liquidity_usd,
+  volume_24h/1h, buys/sells 1h+24h, buy_sell_24h, vol/liq, price_change 5m→24h, age_hours,
+  fdv, market_cap) — this IS the agent's feature schema + seed/format examples.
+- Real verdicts + entry/target/stop + reasoning over 9 tokens (action-surface-B examples).
+- **9 confirmed pool addresses** → guaranteed-good fetch universe seed.
+- Trade outcomes (exits/PnL/skips) → rubric calibration.
+- **NOT present:** any stored OHLCV time series. `ohlcv_1h` was fetched live, never persisted.
+  Every market row is a point-in-time snapshot, not a replayable tape.
+- **Therefore:** tradewatch = seed of *decisions/features/pools* (the brains + universe);
+  GeckoTerminal fetch = the *replay price tape*. Both required; neither substitutes.
+
+## 1c. The three loops are independent (demo ≠ batch_size)
+- **Training loop:** batch_size=128 parallel replay-rollouts/step — a GRPO requirement only.
+- **Demo loop:** 1 (or few) LIVE paper session in tradewatch, trained adapter via
+  base:adapter_id. As small as we want. 128 was never the demo.
+- **Recursive loop (stretch):** reflect → checkpoint_id warm-start → retrain.
+
+## 2. Data (replay substrate) — crypto
+- **Source:** GeckoTerminal free OHLCV — `/networks/base/pools/{pool}/ohlcv/{tf}?aggregate=N&limit=L`
+  (already used in `scanner/base_scanner.py:843`). No key.
+- **Universe:** start from the 9 journal tokens (NOCK, VIRTUAL, DEUS, CTR, Surplus,
+  GITLAWB, VVV, DEGEN, PITCH) + expand via trending-pool discovery to ~30–50 Base pools.
+- **Bars & DEPTH CEILING (probed live 2026-05-30):** free OHLCV caps at **~1000 bars/pool,
+  `before_timestamp` pagination does NOT walk back further.** So:
+  - hourly (`tf=hour`): ~1000 bars ≈ **41 days**
+  - daily (`tf=day`): ~181 bars ≈ **6 months**
+  - **Implication:** shallow history → depth can't supply many decorrelated time windows.
+    **Breadth carries GRPO variance: tasks = symbol × window, universe = 30–50 pools.**
+- **Storage:** `data/ohlcv/<symbol>.parquet` (ts, o, h, l, c, v). Reproducible, no rate limits at train time.
+- **Splits (anti-leakage, structural):**
+  - per-symbol time split: train window | OOS window (chronological, no overlap)
+  - held-out OOS **symbols** (never seen in training) for generalization check
+  - with shallow per-symbol history, the symbol-holdout split does the heavy lifting
+- **Crypto-hardening (because reward is gameable here):**
+  - slippage + fee model on every fill (fixed bps + size-vs-liquidity impact)
+  - min-liquidity / min-volume gate per bar (illiquid bars can't be traded)
+  - survivorship caveat noted; mitigate by including tokens that later died
+
+## 3. Action surface — support BOTH (decide after baseline rollouts)
+The backtester accepts a uniform `target_positions` dict; two agent framings feed it:
+- **A. Strategy-code:** agent writes `strategy(features_window) -> target_positions`,
+  executed causally over the OOS window. Strongest "coding agent" framing.
+- **B. Structured decisions:** agent emits per-bar JSON (verdict/entry/target/stop),
+  reusing tradewatch's schema. Closer to existing code.
+Both reduce to the same backtest call → same rubric. We prototype both, pick via eval.
+
+## 4. Backtester (port `agents/paper_ledger.py`)
+- `ReplayFeed`: serves bars **only up to t** — lookahead impossible by construction
+  (the agent/strategy literally never receives `bars[t+1:]`).
+- Engine: step bar-by-bar, apply target_positions via slippage/fee model, mark-to-market,
+  track equity, cash, exposure, per-trade R:R, drawdown.
+- Metrics: Sharpe (primary), CAGR/return, max drawdown, equity/cash ratio, turnover, win rate.
+- Benchmarks computed on same window: **buy-and-hold**, MA-crossover, z-score mean-reversion.
+- Invariants (unit-tested): causality (no future leak), determinism (seed → identical run).
+
+## 5. verifiers environment (v0 stable API)
+Class: **`StatefulToolEnv`** (per-rollout state + stateful tools).
+
+```python
+def load_environment(
+    symbols: list[str] | str = "train",   # universe or split name
+    split: str = "train",                  # train | oos | oos_symbols
+    objective: str = "sharpe",             # sharpe | return | min_drawdown
+    max_turns: int = 8,
+    n_windows: int = 4,                     # OOS windows averaged per reward
+    seed: int = 0,
+) -> vf.Environment: ...
+```
+
+- `setup_state(state)`: pick task (symbol(s) × window × objective), build fresh ReplayFeed + ledger.
+- **Tools** (stateful, NOT per-rollout sandbox — global/in-proc exec to save credits):
+  - `get_features(lookback)` → indicators up to current bar (RSI, MACD, MAs, z-score,
+    BB, vol, buy/sell ratio, liquidity) — reuses scanner feature logic
+  - `run_backtest(strategy_or_decisions)` → in-sample metrics (the agent's feedback loop)
+  - `read_metrics()` → current equity/DD/Sharpe
+- `@vf.stop`: agent submits final strategy, or max_turns.
+- **Reward (Rubric, weighted) — computed on OOS, aggregated over n_windows × basket:**
+
+  | reward fn | weight | source |
+  |---|---|---|
+  | `r_sharpe` (normalized OOS Sharpe) | 0.40 | spine |
+  | `r_beats_benchmark` (vs buy-and-hold) | 0.20 | anti-overfit |
+  | `r_drawdown` (penalty for deep DD) | 0.15 | MEMORY: protect capital |
+  | `r_rr_discipline` (R:R≥2 compliance) | 0.10 | trading_agent._validate |
+  | `r_exposure` (sane equity/cash, no all-in) | 0.10 | MEMORY: sizing |
+  | `r_cost` (turnover/fee penalty) | 0.05 | realism |
+  | **HARD GATES → reward 0** | — | invalid code, lookahead, NaN equity, illiquid trades |
+
+  Outcome terms (sharpe + beats_benchmark) must dominate so the model can't fake
+  discipline while losing money.
+
+## 6. Training (Prime Hosted, FREE for Laguna)
+```toml
+model = "poolside/Laguna-XS.2"   # validate first on Qwen/Qwen3-4B-Instruct-2507
+max_steps = 50                    # small validation; scale after curve moves
+batch_size = 128                  # = parallel rollouts (the "128 sessions")
+rollouts_per_example = 8          # GRPO group — needs decorrelated windows
+learning_rate = 1e-4
+lora_alpha = 16
+[sampling]
+max_tokens = 512
+enable_thinking = false           # docs: start non-reasoning for agentic tasks
+[[env]]
+id = "<user>/stock-strategy-env"
+[eval]
+eval_base_model = true            # base-vs-trained comparison built in
+```
+Pipeline: `prime eval run` (sanity, baseline 10–80%) → small Qwen RL → Laguna RL →
+download LoRA → `prime deployments create` → `base:adapter_id`.
+
+## 7. Closing the loop
+- Deploy adapter → point tradewatch `HybrieClient` at `api.pinference.ai` → **live paper demo**.
+- **Ablation (money shot):** trained adapter, MEMORY.md stripped from prompt → discipline holds.
+- **Recursive (stretch):** `checkpoint_id` warm-start → reflect on failures →
+  adjust rubric weights / add tasks / `[buffer]` difficulty filtering → retrain.
+
+## 8. Non-negotiable risks
+1. Leakage → structural causal feed (not a detector).
+2. Reward variance → aggregate over basket × windows (or GRPO has no signal).
+3. Reward hacking → OOS + must-beat-benchmark + hard lookahead gate.
+4. Crypto noise → slippage/fee/liquidity model on every fill.

baseline_eval.txt

@@ -0,0 +1,219 @@
+Resolved source: stimulir/trade-pool
+Eval job_id: trade_pool_poolside_laguna_xs.2_20260530_112447_9949ef5b
+eval_dataset is not set, falling back to train dataset
+
+--- Evaluation ---
+Environment: trade-pool
+Model: poolside/laguna-xs.2
+Provider: https://api.pinference.ai/api/v1
+Examples: 4
+Rollouts per example: 1
+--- Example ---
+╭─────────────────────────────────── Step 0 ───────────────────────────────────╮
+│ ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┓ │
+│ ┃ Prompt                         ┃ Completion                     ┃ Reward ┃ │
+│ ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━┩ │
+│ │ system: You are a quantitative │ assistant:                     │   0.91 │ │
+│ │ trading strategy engineer. You │ [reasoning]                    │        │ │
+│ │ write a Python function that   │                                │        │ │
+│ │ decides a target position each │ Let me analyze the price data  │        │ │
+│ │ bar, using ONLY causal         │ and develop a strategy that    │        │ │
+│ │ technical features.            │ follows the given rules.       │        │ │
+│ │                                │                                │        │ │
+│ │ You must output a single       │ Looking at the recent 30       │        │ │
+│ │ Python code block defining     │ closes, I can see the price    │        │ │
+│ │ exactly:                       │ has been declining from around │        │ │
+│ │                                │ 0.0245 to 0.0177, which is a   │        │ │
+│ │ ```python                      │ significant drop. This could   │        │ │
+│ │ def strategy(features,         │ be a "post-dip curl" setup if  │        │ │
+│ │ position):                     │ we see a recovery.             │        │ │
+│ │     # features: dict of the    │                                │        │ │
+│ │ current bar's indicators (see  │ Let me design a strategy that: │        │ │
+│ │ list below), all causal        │ 1. Uses RSI to identify        │        │ │
+│ │     # position: your current   │ oversold conditions            │        │ │
+│ │ target position, a float in    │ 2. Uses MACD for momentum      │        │ │
+│ │ [-1, 1]                        │ confirmation                   │        │ │
+│ │     # return: new target       │ 3. Uses moving averages for    │        │ │
+│ │ position, float in [-1, 1]     │ trend direction                │        │ │
+│ │ (1=full long, -1=full short,   │ 4. Uses Bollinger Bands for    │        │ │
+│ │ 0=flat)                        │ position sizing                │        │ │
+│ │     ...                        │ 5. Incorporates volatility for │        │ │
+│ │     return new_position        │ risk management                │        │ │
+│ │ ```                            │ 6. Follows the capital         │        │ │
+│ │                                │ protection rules               │        │ │
+│ │ Available features (floats,    │                                │        │ │
+│ │ computed on data up to the     │ Key patterns to look for:      │        │ │
+│ │ current bar only):             │ - Post-dip curl: RSI rising    │        │ │
+│ │ close, sma_10, sma_20, sma_50, │ from oversold (<30), MACD hist │        │ │
+│ │ ema_12, ema_26, rsi_14, macd,  │ turning positive after a drop  │        │ │
+│ │ macd_signal, macd_hist,        │ - Healthy momentum: SMA_10 >   │        │ │
+│ │ zscore_20, bb_lo, bb_mid,      │ SMA_20, MACD > MACD_signal     │        │ │
+│ │ bb_hi, ret_1, vol_20           │ - Avoid: Price too far from    │        │ │
+│ │                                │ Bollinger Mid, high            │        │ │
+│ │ Hard rules:                    │ volatility, thin liquidity     │        │ │
+│ │ - No imports, no IO, no future │                                │        │ │
+│ │ data. You only get the current │                                │        │ │
+│ │ bar's features.                │                                │        │ │
+│ │ - Favor capital protection:    │ ```python                      │        │ │
+│ │ control drawdown, avoid being  │ def strategy(features,         │        │ │
+│ │ all-in blindly.                │ position):                     │        │ │
+│ │ - Your strategy is scored on a │     # Extract features         │        │ │
+│ │ HELD-OUT window and must beat  │     close = features['close']  │        │ │
+│ │ buy-and-hold.                  │     sma_10 =                   │        │ │
+│ │                                │ features['sma_10']             │        │ │
+│ │ Trading discipline distilled   │     sma_20 =                   │        │ │
+│ │ from 618 real prior trading    │ features['sma_20']             │        │ │
+│ │ decisions (94 BUY, 489 WATCH,  │     sma_50 =                   │        │ │
+│ │ 35 AVOID):                     │ features['sma_50']             │        │ │
+│ │                                │     ema_12 =                   │        │ │
+│ │ Patterns that earned a BUY     │ features['ema_12']             │        │ │
+│ │ (translate these into your     │     ema_26 =                   │        │ │
+│ │ strategy's entry logic):       │ features['ema_26']             │        │ │
+│ │ - "Post-dip curl": a 24h drop  │     rsi_14 =                   │        │ │
+│ │ followed by a 1h recovery with │ features['rsi_14']             │        │ │
+│ │ a strong short-term buy/sell   │     macd = features['macd']    │        │ │
+│ │   ratio (>1.5). Enter on the   │     macd_signal =              │        │ │
+│ │ curl, not the dip. → buy when  │ features['macd_signal']        │        │ │
+│ │ recent return turns up after a │     macd_hist =                │        │ │
+│ │   drawdown and momentum (rsi   │ features['macd_hist']          │        │ │
+│ │ rising from oversold,          │     zscore_20 =                │        │ │
+│ │ macd_hist turning positive)    │ features['zscore_20']          │        │ │
+│ │ confirms.                      │     bb_lo = features['bb_lo']  │        │ │
+│ │ - "Healthy momentum            │     bb_mid =                   │        │ │
+│ │ continuation": positive 1h AND │ features['bb_mid']             │        │ │
+│ │ 24h change with buy pressure   │     bb_hi = features['bb_hi']  │        │ │
+│ │ and                            │     ret_1 = features['ret_1']  │        │ │
+│ │   volume/liquidity > 1. →      │     vol_20 =                   │        │ │
+│ │ trend-follow when sma_10 >     │ features['vol_20']             │        │ │
+│ │ sma_20 and macd > macd_signal. │                                │        │ │
+│ │ - Size up only with liquidity  │     # Initialize new position  │        │ │
+│ │ + volume backing the move;     │     new_position = position    │        │ │
+│ │ size down when volatility is   │                                │        │ │
+│ │ high.                          │     # Capital protection:      │        │ │
+│ │                                │ avoid overexposure when        │        │ │
+│ │ Conditions that earned         │ already up significantly       │        │ │
+│ │ WATCH/AVOID (translate into    │     if ret_1 > 0.05:  #        │        │ │
+│ │ your exits and risk limits):   │ Already up 5% on the hour      │        │ │
+│ │ - Already +30% on the day →    │         return min(position,   │        │ │
+│ │ entry timing is poor; do not   │ 0.3)  # Reduce exposure        │        │ │
+│ │ chase. → avoid full long when  │                                │        │ │
+│ │   ret_1 is extremely high or   │     # Avoid full long when     │        │ │
+│ │ price is far above bb_mid.     │ price is far above middle      │        │ │
+│ │ - Volume/liquidity < 1.0 or    │ Bollinger Band                 │        │ │
+│ │ thin liquidity → lower         │     if close > bb_mid * 1.03:  │        │ │
+│ │ conviction; reduce exposure.   │ # 3% above BB mid              │        │ │
+│ │ - Sell-heavy short-term flow   │         return max(position,   │        │ │
+│ │ after entry → cut quickly;     │ -0.2)  # Cap long exposure     │        │ │
+│ │ don't wait for a vague         │                                │        │ │
+│ │ recovery.                      │     # Base position sizing     │        │ │
+│ │                                │ inversely related to           │        │ │
+│ │ Capital-protection rules       │ volatility                     │        │ │
+│ │ (every BUY required these):    │     vol_factor = max(0.5, 1.0  │        │ │
+│ │ - Always define a stop below   │ - vol_20)  # Reduce size when  │        │ │
+│ │ entry and a target above;      │ volatility high                │        │ │
+│ │ favor reward:risk >= 2:1.      │                                │        │ │
+│ │ - Protect capital first:       │     # Post-dip curl pattern:   │        │ │
+│ │ control drawdown over chasing  │ RSI coming back from oversold  │        │ │
+│ │ upside.                        │ with MACD improvement          │        │ │
+│ │ - Don't average down losers;   │     dip_recovery = False       │        │ │
+│ │ don't let a winner round-trip  │     if rsi_14 < 30 and         │        │ │
+│ │ — tighten when flow weakens.   │ macd_hist > 0:  # Oversold     │        │ │
+│ │                                │ with positive momentum         │        │ │
+│ │                                │         dip_recovery = True    │        │ │
+│ │                                │                                │        │ │
+│ │ user: Token: NOCK              │     # Healthy momentum: short  │        │ │
+│ │ In-sample bars available: 600  │ and medium term trend          │        │ │
+│ │ Recent closes (last 30):       │ confirmation                   │        │ │
+│ │ [0.024502, 0.02227, 0.022973,  │     momentum_ok = sma_10 >     │        │ │
+│ │ 0.022138, 0.022407, 0.02138,   │ sma_20 and macd > macd_signal  │        │ │
+│ │ 0.02204, 0.025153, 0.023984,   │                                │        │ │
+│ │ 0.025721, 0.024264, 0.023896,  │     # Trend following with     │        │ │
+│ │ 0.023152, 0.022478, 0.023024,  │ moving averages                │        │ │
+│ │ 0.022491, 0.022522, 0.02344,   │     trend_up = ema_12 > ema_26 │        │ │
+│ │ 0.023711, 0.022644, 0.022412,  │ and sma_20 > sma_50            │        │ │
+│ │ 0.022769, 0.02276, 0.023428,   │                                │        │ │
+│ │ 0.022117, 0.021182, 0.020521,  │     # Entry signals            │        │ │
+│ │ 0.019539, 0.018417, 0.017665]  │     if dip_recovery and        │        │ │
+│ │                                │ momentum_ok:                   │        │ │
+│ │ Write a `strategy(features,    │         # Post-dip entry with  │        │ │
+│ │ position)` function. Use       │ strong confirmation            │        │ │
+│ │ indicators like RSI (rsi_14),  │         new_position = min(0.6 │        │ │
+│ │ MACD                           │ * vol_factor, 0.6)             │        │ │
+│ │ (macd/macd_signal/macd_hist),  │     elif trend_up and          │        │ │
+│ │ moving averages (sma_*/ema_*), │ momentum_ok and zscore_20 <    │        │ │
+│ │ z-score (zscore_20), Bollinger │ 1.5:                           │        │ │
+│ │ bands (bb_*), and volatility   │         # Trend continuation   │        │ │
+│ │ (vol_20). Return a target      │ with reasonable valuation      │        │ │
+│ │ position in [-1, 1].           │         new_position = min(0.4 │        │ │
+│ │                                │ * vol_factor, 0.4)             │        │ │
+│ │                                │     elif zscore_20 < -1.0 and  │        │ │
+│ │                                │ macd_hist > -0.001:            │        │ │
+│ │                                │         # Mean reversion setup │        │ │
+│ │                                │ near lower Bollinger Band      │        │ │
+│ │                                │         new_position = min(0.3 │        │ │
+│ │                                │ * vol_factor, 0.3)             │        │ │
+│ │                                │     else:                      │        │ │
+│ │                                │         # Reduce exposure if   │        │ │
+│ │                                │ no clear signal                │        │ │
+│ │                                │         new_position =         │        │ │
+│ │                                │ position * 0.7                 │        │ │
+│ │                                │                                │        │ │
+│ │                                │     # Exit management: reduce  │        │ │
+│ │                                │ position if momentum weakens   │        │ │
+│ │                                │     if macd_hist < 0 and       │        │ │
+│ │                                │ position > 0.2:                │        │ │
+│ │                                │         new_position =         │        │ │
+│ │                                │ max(new_position, -0.1)  #     │        │ │
+│ │                                │ Quick exit                     │        │ │
+│ │                                │     elif rsi_14 > 70 and       │        │ │
+│ │                                │ position > 0.3:                │        │ │
+│ │                                │         new_position =         │        │ │
+│ │                                │ max(new_position, 0.0)  # Take │        │ │
+│ │                                │ profits on overbought          │        │ │
+│ │                                │                                │        │ │
+│ │                                │     # Ensure position bounds   │        │ │
+│ │                                │     new_position = max(-1.0,   │        │ │
+│ │                                │ min(1.0, new_position))        │        │ │
+│ │                                │                                │        │ │
+│ │                                │     return new_position        │        │ │
+│ │                                │ ```                            │        │ │
+│ │                                │ </assistant>                   │        │ │
+│ └────────────────────────────────┴────────────────────────────────┴────────┘ │
+╰──────────────────────────────────────────────────────────────────────────────╯
+--- All ---
+Rewards:
+reward: avg - 0.495, std - 0.328
+r1: [0.915, 0.587, 0.0, 0.478]
+reward_sharpe: avg - 0.448, std - 0.320
+r1: [0.873, 0.577, 0.0, 0.344]
+reward_beats_benchmark: avg - 0.250, std - 0.433
+r1: [1.0, 0.0, 0.0, 0.0]
+reward_drawdown: avg - 0.652, std - 0.381
+r1: [0.943, 0.878, 0.0, 0.788]
+reward_exposure: avg - 0.750, std - 0.433
+r1: [1.0, 1.0, 0.0, 1.0]
+reward_cost: avg - 0.355, std - 0.206
+r1: [0.482, 0.5, 0.0, 0.438]
+reward_valid: avg - 0.750, std - 0.433
+r1: [1.0, 1.0, 0.0, 1.0]
+num_turns: avg - 1.000, std - 0.000
+r1: [1.0, 1.0, 1.0, 1.0]
+Info:
+is_truncated: avg - 0.000, std - 0.000
+stop_conditions: max_turns_reached: 1.000
+Timing:
+  total      min - 6s, mean - 15s, max - 29s
+  setup      min - 0ms, mean - 0ms, max - 0ms
+  generation min - 6s, mean - 15s, max - 29s
+  model      min - 6s, mean - 15s, max - 29s
+  env        min - 0ms, mean - 0ms, max - 0ms
+  scoring    min - 1ms, mean - 41ms, max - 55ms
+  overhead   min - 0ms, mean - 0ms, max - 1ms
+Usage:
+input_tokens (avg): 1061.500
+output_tokens (avg): 2066.000
+final_input_tokens (avg): 1061.500
+final_output_tokens (avg): 2066.000
+
+Performance:
+event_loop_lag: mean=7ms, p99=3ms, max=2s (n=335)

configs/iter_1.toml

@@ -0,0 +1,26 @@
+# AUTO-GENERATED iteration 1 — recursive self-improving loop
+# objective=sharpe  focus_symbols=all  warm_start=cold
+model = "poolside/Laguna-XS.2"
+max_steps = 50
+batch_size = 128
+rollouts_per_example = 8
+learning_rate = 0.0001
+lora_alpha = 16
+# checkpoint_id = (none — cold start)
+[sampling]
+max_tokens = 768
+enable_thinking = false
+
+[[env]]
+id = "stimulir/trade-pool"
+args = { split = "train", seed = 0, objective = "sharpe" }
+
+[eval]
+interval = 25
+eval_base_model = true
+[[eval.env]]
+id = "stimulir/trade-pool"
+args = { split = "oos_symbols", seed = 0, objective = "sharpe" }
+
+[adapters]
+interval = 0

configs/laguna-stock-strategy.toml

@@ -0,0 +1,27 @@
+# RL training config — coding agent writes causal crypto strategies, scored by OOS backtest.
+# Validate on Qwen first (cheap), then swap model to poolside/Laguna-XS.2 (FREE hosted).
+
+model = "Qwen/Qwen3-4B-Instruct-2507"   # → "poolside/Laguna-XS.2" once env is validated
+max_steps = 50                           # small validation run; scale after reward curve moves
+batch_size = 128                         # parallel rollouts/step (the "128 sessions") — GRPO group source
+rollouts_per_example = 8                 # GRPO group size; decorrelated tasks supply variance
+learning_rate = 1e-4
+lora_alpha = 16
+
+[sampling]
+max_tokens = 768                         # room to write a strategy function
+enable_thinking = false                  # docs: start non-reasoning for agentic tasks
+
+[[env]]
+id = "REPLACE_WITH/stock-strategy-env"   # set after `prime env push`
+args = { split = "train", seed = 0 }
+
+[eval]
+interval = 25
+eval_base_model = true                   # base-vs-trained comparison built in
+[[eval.env]]
+id = "REPLACE_WITH/stock-strategy-env"
+args = { split = "oos_symbols", seed = 0 }   # generalization: HELD-OUT symbols
+
+[adapters]
+interval = 0                             # upload LoRA adapter at run end

reward_curve.txt

@@ -0,0 +1 @@
+step 49: 0.3657

trade_pool/__init__.py

@@ -0,0 +1,214 @@
+"""trade_pool — a verifiers RL environment where a coding agent writes a
+causal crypto trading strategy, scored by an out-of-sample backtest.
+
+The agent receives a task (a token's in-sample price history + the feature surface),
+writes a Python `strategy(features, position) -> target_position` function, and is
+rewarded by how that strategy performs on a HELD-OUT window — must beat buy-and-hold,
+control drawdown, and keep sane exposure. tradewatch's MEMORY.md discipline becomes
+the rubric; RL turns it into adapter weights.
+"""
+
+from __future__ import annotations
+
+import json
+
+import numpy as np
+import verifiers as vf
+from datasets import Dataset
+
+from .backtester import benchmarks, run_backtest
+from .data import build_tasks
+from .executor import compile_strategy, extract_code
+from .seed_principles import principles_block
+
+FEATURE_NAMES = [
+    "close", "sma_10", "sma_20", "sma_50", "ema_12", "ema_26", "rsi_14",
+    "macd", "macd_signal", "macd_hist", "zscore_20", "bb_lo", "bb_mid", "bb_hi",
+    "ret_1", "vol_20",
+]
+
+SYSTEM_PROMPT = """You are a quantitative trading strategy engineer. You write a Python \
+function that decides a target position each bar, using ONLY causal technical features.
+
+You must output a single Python code block defining exactly:
+
+```python
+def strategy(features, position):
+    # features: dict of the current bar's indicators (see list below), all causal
+    # position: your current target position, a float in [-1, 1]
+    # return: new target position, float in [-1, 1]  (1=full long, -1=full short, 0=flat)
+    ...
+    return new_position
+```
+
+Available features (floats, computed on data up to the current bar only):
+{features}
+
+Hard rules:
+- No imports, no IO, no future data. You only get the current bar's features.
+- Favor capital protection: control drawdown, avoid being all-in blindly.
+- Your strategy is scored on a HELD-OUT window and must beat buy-and-hold.
+
+{seed_principles}
+"""
+
+
+def _task_to_prompt(task: dict) -> str:
+    close = task["train_close"]
+    tail = close[-30:] if len(close) > 30 else close
+    return (
+        f"Token: {task['symbol']}\n"
+        f"In-sample bars available: {len(close)}\n"
+        f"Recent closes (last {len(tail)}): {[round(c, 6) for c in tail]}\n\n"
+        "Write a `strategy(features, position)` function. Use indicators like RSI "
+        "(rsi_14), MACD (macd/macd_signal/macd_hist), moving averages (sma_*/ema_*), "
+        "z-score (zscore_20), Bollinger bands (bb_*), and volatility (vol_20). "
+        "Return a target position in [-1, 1]."
+    )
+
+
+# ── Rubric reward functions (each receives completion + the task info via state) ──
+
+# Memoize per (symbol, code) so the 6 reward fns trigger ONE backtest set per rollout,
+# not 6×(1 strategy + 3 benchmarks). Bounded so it can't grow unboundedly across a run.
+_SCORE_CACHE: dict[tuple, dict] = {}
+_PARTICIPATION_FLOOR = 0.03   # avg |exposure| below this = "did nothing", risk rewards void
+
+
+def _score_strategy(completion, info) -> dict:
+    """Compile + backtest the agent's strategy on the OOS window. Memoized."""
+    text = completion if isinstance(completion, str) else completion[-1]["content"]
+    code = extract_code(text)
+    key = (info["symbol"], hash(code))
+    if key in _SCORE_CACHE:
+        return _SCORE_CACHE[key]
+
+    fn, err = compile_strategy(code)
+    oos = np.asarray(info["oos_close"], dtype=float)
+    warmup = min(50, len(oos) // 3)
+    if fn is None:
+        out = {"error": err, "res": None, "bench": None}
+    else:
+        res = run_backtest(oos, fn, warmup=warmup)
+        bench = benchmarks(oos, warmup=warmup)
+        out = {"error": res.error, "res": res, "bench": bench}
+    if len(_SCORE_CACHE) > 4096:
+        _SCORE_CACHE.clear()
+    _SCORE_CACHE[key] = out
+    return out
+
+
+def _participates(res) -> bool:
+    return res is not None and res.avg_exposure >= _PARTICIPATION_FLOOR
+
+
+def reward_sharpe(completion, info, **kwargs) -> float:
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"]:
+        return 0.0
+    # squash Sharpe to [0,1] via logistic; Sharpe 0 -> 0.5, 2 -> ~0.88.
+    # A flat strategy gets sharpe 0 -> 0.5; gate it so do-nothing can't bank 0.5.
+    if not _participates(s["res"]):
+        return 0.0
+    return float(1.0 / (1.0 + np.exp(-s["res"].sharpe)))
+
+
+def reward_beats_benchmark(completion, info, **kwargs) -> float:
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"] or s["bench"] is None or not _participates(s["res"]):
+        return 0.0
+    bh = s["bench"]["buy_and_hold"].sharpe
+    return 1.0 if s["res"].sharpe > bh else 0.0
+
+
+def reward_drawdown(completion, info, **kwargs) -> float:
+    # Drawdown reward only counts if the strategy actually traded — otherwise
+    # "do nothing" banks a perfect 1.0 for taking zero risk (the inactivity exploit).
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"] or not _participates(s["res"]):
+        return 0.0
+    return float(max(0.0, 1.0 - s["res"].max_drawdown))
+
+
+def reward_exposure(completion, info, **kwargs) -> float:
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"] or not _participates(s["res"]):
+        return 0.0
+    e = s["res"].avg_exposure
+    return 1.0 if 0.1 <= e <= 0.85 else max(0.0, 1.0 - abs(e - 0.5))
+
+
+def reward_cost(completion, info, **kwargs) -> float:
+    # Likewise gated: zero turnover (no trades) must not earn the low-cost reward.
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"] or not _participates(s["res"]):
+        return 0.0
+    return float(max(0.0, 1.0 - s["res"].turnover / 20.0))
+
+
+def reward_valid(completion, info, **kwargs) -> float:
+    # Valid = compiles AND actually trades. A syntactically-valid do-nothing is not
+    # a valid trading strategy for our purposes.
+    s = _score_strategy(completion, info)
+    if s["res"] is None or s["error"]:
+        return 0.0
+    return 1.0 if _participates(s["res"]) else 0.0
+
+
+# Objective presets = rubric weight vectors. The recursive self-improving loop selects
+# an objective (or passes explicit reward_weights) per iteration, so curriculum can shift
+# emphasis (e.g. toward drawdown control if the trained model is taking too much risk)
+# WITHOUT rebuilding the wheel — these arrive via the TOML [[env]] args block.
+#                  [sharpe, beats_bh, drawdown, exposure, cost, valid]
+OBJECTIVE_WEIGHTS = {
+    "sharpe":       [0.40, 0.20, 0.15, 0.10, 0.05, 0.10],
+    "min_drawdown": [0.20, 0.15, 0.35, 0.15, 0.05, 0.10],
+    "balanced":     [0.30, 0.25, 0.20, 0.10, 0.05, 0.10],
+}
+
+
+def load_environment(
+    split: str = "train",
+    seed: int = 0,
+    objective: str = "sharpe",
+    reward_weights: list[float] | None = None,
+    symbols: list[str] | None = None,
+    use_seed_principles: bool = True,
+    max_turns: int = 1,
+) -> vf.Environment:
+    """Entry point Prime calls (args come from the TOML [[env]] args block).
+
+    Curriculum knobs for the recursive loop:
+      split          train | oos | oos_symbols   (which symbol pool)
+      seed           rotates the symbol shuffle  (exposes new task mixes per iteration)
+      objective      sharpe | min_drawdown | balanced   (rubric weight preset)
+      reward_weights explicit 6-vector, overrides objective
+      symbols        restrict to these symbols (curriculum: focus on weak performers)
+      use_seed_principles  inject tradewatch's 618-decision discipline block (default on);
+                     set False for the "memory is the adapter" ablation (strip the prompt
+                     discipline and test whether trained weights retain it)
+    """
+    tasks = build_tasks(split=split, seed=seed)
+    if symbols:
+        wanted = {s.upper() for s in symbols}
+        tasks = [t for t in tasks if t["symbol"].upper() in wanted] or tasks
+    seed_block = principles_block() if use_seed_principles else ""
+    system = SYSTEM_PROMPT.format(features=", ".join(FEATURE_NAMES), seed_principles=seed_block)
+    rows = []
+    for t in tasks:
+        rows.append({
+            "prompt": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": _task_to_prompt(t)},
+            ],
+            "info": {"symbol": t["symbol"], "oos_close": t["oos_close"]},
+        })
+    dataset = Dataset.from_list(rows)
+
+    weights = reward_weights or OBJECTIVE_WEIGHTS.get(objective, OBJECTIVE_WEIGHTS["sharpe"])
+    rubric = vf.Rubric(
+        funcs=[reward_sharpe, reward_beats_benchmark, reward_drawdown,
+               reward_exposure, reward_cost, reward_valid],
+        weights=weights,
+    )
+    return vf.SingleTurnEnv(dataset=dataset, rubric=rubric)

trade_pool/backtester.py

@@ -0,0 +1,162 @@
+"""Causal replay backtester — the RL verifier's beating heart.
+
+Ports tradewatch's paper_ledger.py accounting into a vectorised, deterministic,
+LEAK-PROOF backtest. A strategy is a pure function:
+
+    def strategy(features_up_to_t: dict[str, float], position: float) -> float
+        # returns target position in [-1, 1]  (fraction of equity; <0 = short)
+
+The engine calls it bar-by-bar, passing ONLY features at indices <= t. The strategy
+can never see the future because future bars are not in the dict it receives. Fills
+happen at the NEXT bar's open-equivalent (close[t] used as decision price, close[t+1]
+as fill realisation) with slippage + fees, so a decision at t cannot be filled at t's
+hindsight-perfect price.
+
+Metrics: Sharpe (primary), CAGR, max drawdown, equity/cash exposure, turnover, win rate.
+Benchmarks: buy-and-hold, MA-crossover, z-score mean-reversion.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from .features import feature_frame, sma, zscore
+
+
+@dataclass
+class BacktestResult:
+    equity_curve: np.ndarray
+    returns: np.ndarray
+    sharpe: float
+    cagr: float
+    max_drawdown: float
+    turnover: float
+    win_rate: float
+    final_equity: float
+    avg_exposure: float
+    n_trades: int
+    error: str | None = None
+    meta: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "sharpe": round(self.sharpe, 4),
+            "cagr": round(self.cagr, 4),
+            "max_drawdown": round(self.max_drawdown, 4),
+            "turnover": round(self.turnover, 4),
+            "win_rate": round(self.win_rate, 4),
+            "final_equity": round(self.final_equity, 4),
+            "avg_exposure": round(self.avg_exposure, 4),
+            "n_trades": self.n_trades,
+            "error": self.error,
+        }
+
+
+# Periods-per-year for annualisation (daily bars by default; 24*365 for hourly).
+def _ann_factor(bars_per_year: float) -> float:
+    return float(np.sqrt(bars_per_year))
+
+
+def _metrics(equity: np.ndarray, exposures: np.ndarray, bars_per_year: float,
+             error: str | None = None) -> BacktestResult:
+    equity = np.asarray(equity, dtype=float)
+    if len(equity) < 2 or np.any(~np.isfinite(equity)) or np.any(equity <= 0):
+        return BacktestResult(equity, np.zeros(1), 0.0, 0.0, 1.0, 0.0, 0.0,
+                              float(equity[-1]) if len(equity) else 0.0, 0.0, 0,
+                              error=error or "degenerate equity")
+    rets = np.diff(equity) / equity[:-1]
+    sd = rets.std()
+    sharpe = float(rets.mean() / sd * _ann_factor(bars_per_year)) if sd > 1e-12 else 0.0
+    n = len(equity)
+    years = n / bars_per_year
+    cagr = float((equity[-1] / equity[0]) ** (1 / years) - 1) if years > 0 and equity[0] > 0 else 0.0
+    peak = np.maximum.accumulate(equity)
+    max_dd = float(np.max((peak - equity) / peak)) if len(peak) else 0.0
+    exp = np.asarray(exposures, dtype=float)
+    turnover = float(np.sum(np.abs(np.diff(np.insert(exp, 0, 0.0)))))
+    n_trades = int(np.sum(np.abs(np.diff(np.insert(exp, 0, 0.0))) > 1e-9))
+    win_rate = float(np.mean(rets > 0)) if len(rets) else 0.0
+    return BacktestResult(equity, rets, sharpe, cagr, max_dd, turnover, win_rate,
+                          float(equity[-1]), float(np.mean(np.abs(exp))), n_trades, error=error)
+
+
+def run_backtest(
+    close: np.ndarray,
+    strategy_fn,
+    *,
+    fee_bps: float = 30.0,        # 0.30% per unit turnover (DEX-realistic)
+    slippage_bps: float = 20.0,   # 0.20% adverse slippage on fills
+    bars_per_year: float = 365.0,
+    allow_short: bool = True,
+    warmup: int = 50,             # bars reserved for feature warmup (no trading)
+) -> BacktestResult:
+    """Step the strategy causally over `close`, return performance metrics.
+
+    Fill model: decision made on info up to t, position realised against return
+    from t -> t+1, minus fees/slippage proportional to position change.
+    """
+    close = np.asarray(close, dtype=float)
+    if len(close) < warmup + 5:
+        return _metrics(np.array([1.0, 1.0]), np.zeros(1), bars_per_year, error="too few bars")
+
+    feats = feature_frame(close)
+    rets = np.zeros(len(close))
+    rets[1:] = np.diff(close) / np.where(close[:-1] == 0, np.nan, close[:-1])
+    rets = np.nan_to_num(rets)
+
+    equity = [1.0]
+    exposures = []
+    pos = 0.0
+    cost_rate = (fee_bps + slippage_bps) / 1e4
+
+    for t in range(warmup, len(close) - 1):
+        # features visible at t (scalar snapshot, causal by construction)
+        view = {k: (float(v[t]) if np.isfinite(v[t]) else 0.0) for k, v in feats.items()}
+        try:
+            target = float(strategy_fn(view, pos))
+        except Exception as e:  # noqa: BLE001 - strategy bugs => penalised, not crash
+            return _metrics(np.array(equity + [equity[-1]]), np.array(exposures + [pos]),
+                            bars_per_year, error=f"strategy raised: {type(e).__name__}: {e}")
+        if not np.isfinite(target):
+            target = 0.0
+        lo = -1.0 if allow_short else 0.0
+        target = max(lo, min(1.0, target))
+
+        trade_cost = abs(target - pos) * cost_rate
+        # equity evolves with NEXT bar's realised return at the chosen exposure
+        pnl = target * rets[t + 1]
+        new_equity = equity[-1] * (1.0 + pnl - trade_cost)
+        equity.append(new_equity)
+        exposures.append(target)
+        pos = target
+
+    return _metrics(np.array(equity), np.array(exposures), bars_per_year)
+
+
+# ── Benchmarks (the anti-overfit baselines a strategy must beat) ──────────────
+
+def _buy_and_hold(view, pos):
+    return 1.0
+
+
+def _ma_crossover(view, pos):
+    return 1.0 if view.get("sma_10", 0) > view.get("sma_20", 0) else 0.0
+
+
+def _zscore_meanrev(view, pos):
+    z = view.get("zscore_20", 0.0)
+    if z < -1.5:
+        return 1.0
+    if z > 1.5:
+        return -1.0
+    return pos  # hold
+
+
+def benchmarks(close: np.ndarray, **kw) -> dict[str, BacktestResult]:
+    return {
+        "buy_and_hold": run_backtest(close, _buy_and_hold, **kw),
+        "ma_crossover": run_backtest(close, _ma_crossover, **kw),
+        "zscore_meanrev": run_backtest(close, _zscore_meanrev, **kw),
+    }

trade_pool/data.py

@@ -0,0 +1,81 @@
+"""Load the replay tape and build the train / OOS / OOS-symbol task splits.
+
+Shallow per-symbol history (free GeckoTerminal cap ~1000 bars) means breadth carries
+the GRPO variance: a task = (symbol, window). The symbol-holdout split is the real
+generalization test.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+# Resolve the tape relative to THIS file so it works after the env is built into a
+# wheel and installed into site-packages on Prime's infra (where the repo's top-level
+# data/ dir does not exist). Packaged copy is authoritative; repo dir is a dev fallback.
+_PKG_DATA = Path(__file__).resolve().parent / "data" / "ohlcv"
+_REPO_DATA = Path(__file__).resolve().parents[3] / "data" / "ohlcv"
+DATA = _PKG_DATA if _PKG_DATA.exists() and any(_PKG_DATA.glob("*.parquet")) else _REPO_DATA
+
+# Quote-side / blue-chip pairs that aren't tradeable "strategy" targets — excluded.
+_EXCLUDE = {"USDC", "WETH", "CBBTC", "USDT", "DAI"}
+
+
+def _load_series() -> dict[str, np.ndarray]:
+    series: dict[str, np.ndarray] = {}
+    for f in sorted(glob.glob(str(DATA / "*.parquet"))):
+        sym = os.path.basename(f).split("__")[0].upper()
+        if sym in _EXCLUDE:
+            continue
+        close = pd.read_parquet(f)["c"].to_numpy(dtype=float)
+        if len(close) >= 120 and np.all(np.isfinite(close)) and np.all(close > 0):
+            # keep the most liquid pool per symbol (first sorted = arbitrary but stable)
+            if sym not in series or len(close) > len(series[sym]):
+                series[sym] = close
+    return series
+
+
+def build_tasks(split: str = "train", oos_frac: float = 0.4, seed: int = 0) -> list[dict]:
+    """Return a list of task dicts: {symbol, train_close, oos_close}.
+
+    - train: symbols sorted, first 70% of symbols; in-sample = early bars, oos = late bars
+    - oos: same symbols, evaluated on held-out late window
+    - oos_symbols: the held-out 30% of symbols (never seen in training)
+    """
+    series = _load_series()
+    symbols = sorted(series.keys())
+    rng = np.random.default_rng(seed)
+    rng.shuffle(symbols)
+    cut = max(1, int(len(symbols) * 0.7))
+    train_syms, holdout_syms = symbols[:cut], symbols[cut:]
+    use = holdout_syms if split == "oos_symbols" else train_syms
+
+    tasks = []
+    for sym in use:
+        close = series[sym]
+        split_at = int(len(close) * (1 - oos_frac))
+        tasks.append({
+            "symbol": sym,
+            "train_close": close[:split_at].tolist(),
+            "oos_close": close[split_at:].tolist(),
+            "n_bars": len(close),
+        })
+    return tasks
+
+
+def universe_summary() -> dict:
+    series = _load_series()
+    return {"n_symbols": len(series), "symbols": sorted(series.keys()),
+            "bars": {k: len(v) for k, v in series.items()}}
+
+
+if __name__ == "__main__":
+    print(json.dumps(universe_summary(), indent=2))
+    for split in ("train", "oos_symbols"):
+        t = build_tasks(split)
+        print(f"{split}: {len(t)} tasks -> {[x['symbol'] for x in t]}")

trade_pool/executor.py

@@ -0,0 +1,67 @@
+"""Safely turn agent-written Python into a callable strategy(view, pos) -> float.
+
+In-process restricted exec (NOT a per-rollout sandbox — the hackathon docs warn that
+per-rollout sandboxes burn credits fast). The strategy surface is deliberately tiny:
+a pure function over a feature dict + current position. No imports, no IO, no builtins
+beyond a safe math allowlist. A strategy that tries to escape returns an error string,
+which the rubric maps to reward 0.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Callable
+
+_SAFE_BUILTINS = {
+    "abs": abs, "min": min, "max": max, "round": round, "float": float,
+    "int": int, "bool": bool, "len": len, "sum": sum, "pow": pow,
+    "True": True, "False": False, "None": None,
+}
+_SAFE_MATH = {k: getattr(math, k) for k in (
+    "sqrt", "log", "log10", "exp", "fabs", "floor", "ceil", "tanh", "isnan", "isfinite", "pi", "e"
+)}
+
+_FORBIDDEN = ("import", "__", "open(", "eval(", "exec(", "globals(", "locals(",
+              "compile(", "getattr(", "setattr(", "input(", "lambda os")
+
+
+def compile_strategy(code: str) -> tuple[Callable | None, str | None]:
+    """Compile agent code that must define `def strategy(features, position):`.
+
+    Returns (callable, None) on success or (None, error_message) on failure.
+    """
+    if not code or "def strategy" not in code:
+        return None, "code must define `def strategy(features, position):`"
+    lowered = code.lower()
+    for tok in _FORBIDDEN:
+        if tok in lowered:
+            return None, f"forbidden token in strategy: {tok!r}"
+
+    sandbox_globals = {"__builtins__": _SAFE_BUILTINS, "math": _SAFE_MATH, **_SAFE_MATH}
+    try:
+        compiled = compile(code, "<strategy>", "exec")
+        exec(compiled, sandbox_globals)  # noqa: S102 - restricted globals, no builtins
+    except Exception as e:  # noqa: BLE001
+        return None, f"compile/exec error: {type(e).__name__}: {e}"
+
+    fn = sandbox_globals.get("strategy")
+    if not callable(fn):
+        return None, "`strategy` is not callable"
+
+    def wrapped(view: dict, pos: float) -> float:
+        return fn(view, pos)
+
+    return wrapped, None
+
+
+def extract_code(completion: str) -> str:
+    """Pull a python code block out of a model completion (```python ... ``` or raw)."""
+    if "```" in completion:
+        parts = completion.split("```")
+        for i in range(1, len(parts), 2):
+            block = parts[i]
+            if block.startswith("python"):
+                block = block[len("python"):]
+            if "def strategy" in block:
+                return block.strip()
+    return completion.strip()

trade_pool/features.py

@@ -0,0 +1,110 @@
+"""Causal technical indicators over an OHLCV frame.
+
+Every function takes a 1-D array/series of closes (or OHLCV) and returns a series
+aligned to the SAME index, where value[i] uses ONLY data at indices <= i. This is
+the structural anti-lookahead guarantee: a strategy can request features at bar t
+and physically cannot see t+1.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def sma(close: np.ndarray, window: int) -> np.ndarray:
+    out = np.full_like(close, np.nan, dtype=float)
+    if window <= 0:
+        return out
+    csum = np.cumsum(np.insert(close, 0, 0.0))
+    out[window - 1:] = (csum[window:] - csum[:-window]) / window
+    return out
+
+
+def ema(close: np.ndarray, window: int) -> np.ndarray:
+    out = np.full_like(close, np.nan, dtype=float)
+    if len(close) == 0 or window <= 0:
+        return out
+    alpha = 2.0 / (window + 1.0)
+    out[0] = close[0]
+    for i in range(1, len(close)):
+        out[i] = alpha * close[i] + (1 - alpha) * out[i - 1]
+    return out
+
+
+def rsi(close: np.ndarray, window: int = 14) -> np.ndarray:
+    out = np.full_like(close, np.nan, dtype=float)
+    if len(close) < window + 1:
+        return out
+    delta = np.diff(close)
+    gain = np.where(delta > 0, delta, 0.0)
+    loss = np.where(delta < 0, -delta, 0.0)
+    avg_gain = np.mean(gain[:window])
+    avg_loss = np.mean(loss[:window])
+    for i in range(window, len(close)):
+        if i > window:
+            avg_gain = (avg_gain * (window - 1) + gain[i - 1]) / window
+            avg_loss = (avg_loss * (window - 1) + loss[i - 1]) / window
+        rs = avg_gain / avg_loss if avg_loss > 1e-12 else np.inf
+        out[i] = 100.0 - (100.0 / (1.0 + rs))
+    return out
+
+
+def macd(close: np.ndarray, fast: int = 12, slow: int = 26, signal: int = 9):
+    macd_line = ema(close, fast) - ema(close, slow)
+    signal_line = ema(np.nan_to_num(macd_line), signal)
+    return macd_line, signal_line, macd_line - signal_line
+
+
+def zscore(close: np.ndarray, window: int = 20) -> np.ndarray:
+    out = np.full_like(close, np.nan, dtype=float)
+    for i in range(window - 1, len(close)):
+        w = close[i - window + 1: i + 1]
+        mu, sd = w.mean(), w.std()
+        out[i] = (close[i] - mu) / sd if sd > 1e-12 else 0.0
+    return out
+
+
+def bollinger(close: np.ndarray, window: int = 20, k: float = 2.0):
+    mid = sma(close, window)
+    out_w = np.full_like(close, np.nan, dtype=float)
+    for i in range(window - 1, len(close)):
+        out_w[i] = close[i - window + 1: i + 1].std()
+    return mid - k * out_w, mid, mid + k * out_w
+
+
+def returns(close: np.ndarray) -> np.ndarray:
+    out = np.zeros_like(close, dtype=float)
+    out[1:] = np.diff(close) / np.where(close[:-1] == 0, np.nan, close[:-1])
+    return np.nan_to_num(out)
+
+
+def volatility(close: np.ndarray, window: int = 20) -> np.ndarray:
+    r = returns(close)
+    out = np.full_like(close, np.nan, dtype=float)
+    for i in range(window - 1, len(close)):
+        out[i] = r[i - window + 1: i + 1].std()
+    return out
+
+
+# The full feature surface exposed to a strategy at bar t (all causal).
+def feature_frame(close: np.ndarray) -> dict[str, np.ndarray]:
+    macd_line, macd_signal, macd_hist = macd(close)
+    bb_lo, bb_mid, bb_hi = bollinger(close)
+    return {
+        "close": close,
+        "sma_10": sma(close, 10),
+        "sma_20": sma(close, 20),
+        "sma_50": sma(close, 50),
+        "ema_12": ema(close, 12),
+        "ema_26": ema(close, 26),
+        "rsi_14": rsi(close, 14),
+        "macd": macd_line,
+        "macd_signal": macd_signal,
+        "macd_hist": macd_hist,
+        "zscore_20": zscore(close, 20),
+        "bb_lo": bb_lo,
+        "bb_mid": bb_mid,
+        "bb_hi": bb_hi,
+        "ret_1": returns(close),
+        "vol_20": volatility(close, 20),
+    }

trade_pool/seed_principles.py

@@ -0,0 +1,67 @@
+"""Distil tradewatch's 618 real trading decisions into grounded principles + exemplars
+that ground the strategy-writing prompt.
+
+These are NOT invented discipline rules — they are mined from actual BUY/AVOID decisions
+the tradewatch agent made on live Base-chain tokens, so the discipline the coding agent
+encodes into strategy logic is traceable to real prior trading, not a paraphrase. The
+distilled block is baked into the wheel (committed below as a constant) so it ships with
+the env and needs no runtime access to the tradewatch repo.
+
+Regenerate with:  python -m trade_pool.seed_principles --rebuild  (dev only)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+# Baked-in distillation (committed). Mined from data/seed/decisions.jsonl:
+# 94 BUY / 489 WATCH / 35 AVOID across 9 tokens, all with reasoning.
+SEED_PRINCIPLES = """\
+Trading discipline distilled from 618 real prior trading decisions (94 BUY, 489 WATCH, 35 AVOID):
+
+Patterns that earned a BUY (translate these into your strategy's entry logic):
+- "Post-dip curl": a 24h drop followed by a 1h recovery with a strong short-term buy/sell
+  ratio (>1.5). Enter on the curl, not the dip. → buy when recent return turns up after a
+  drawdown and momentum (rsi rising from oversold, macd_hist turning positive) confirms.
+- "Healthy momentum continuation": positive 1h AND 24h change with buy pressure and
+  volume/liquidity > 1. → trend-follow when sma_10 > sma_20 and macd > macd_signal.
+- Size up only with liquidity + volume backing the move; size down when volatility is high.
+
+Conditions that earned WATCH/AVOID (translate into your exits and risk limits):
+- Already +30% on the day → entry timing is poor; do not chase. → avoid full long when
+  ret_1 is extremely high or price is far above bb_mid.
+- Volume/liquidity < 1.0 or thin liquidity → lower conviction; reduce exposure.
+- Sell-heavy short-term flow after entry → cut quickly; don't wait for a vague recovery.
+
+Capital-protection rules (every BUY required these):
+- Always define a stop below entry and a target above; favor reward:risk >= 2:1.
+- Protect capital first: control drawdown over chasing upside.
+- Don't average down losers; don't let a winner round-trip — tighten when flow weakens.
+"""
+
+
+def principles_block() -> str:
+    return SEED_PRINCIPLES
+
+
+# ── Dev-only: regenerate the constant from the raw journal extraction ──
+def _rebuild() -> str:
+    seed = Path(__file__).resolve().parents[3] / "data" / "seed" / "decisions.jsonl"
+    rows = [json.loads(l) for l in seed.read_text().splitlines() if l.strip()]
+    buys = [r for r in rows if r.get("verdict") == "BUY"]
+    patterns = {}
+    for r in buys:
+        p = (r.get("pattern") or "unlabeled").strip()
+        patterns[p] = patterns.get(p, 0) + 1
+    print(f"{len(rows)} decisions | BUY patterns: {patterns}")
+    print("Edit SEED_PRINCIPLES by hand from these — keep it compact and strategy-actionable.")
+    return ""
+
+
+if __name__ == "__main__":
+    import sys
+    if "--rebuild" in sys.argv:
+        _rebuild()
+    else:
+        print(principles_block())