docs: clarify HF Gemma runs and OpenEnv traces

Documents live versus cached opponent modes, records verbose OpenEnv run artifacts, and makes Gemma HF router defaults explicit for reproducible experiments.

README.md

@@ -238,20 +238,32 @@ def r_coherence_stateless(prompt: str, completion: str) -> float:
 
 ### YAML config (recommended)
 
-Use one YAML config to control **both**:
+Use YAML configs to control **both**:
 - **server defaults** (opponent mode/model/cache, eval pack id), and
 - **runner defaults** (`inference.py` / `eval.py`: env URL, max overs, captain model/API).
 
-Example: `cricket_captain/configs/default.yaml`.
+Use `configs/default.yaml` when you want both the captain and live opponent to call HF router models. Use `configs/cached_eval.yaml` when you want a live captain model against replayed opponent decisions for reproducible comparison.
 
 ```bash
-# Start server with config
+# Start server with live HF opponent config
 cd cricket_captain
 PYTHONPATH=. python server/app.py --port 8001 --config configs/default.yaml
 
-# Run a short baseline using config defaults
+# Run a short HF Gemma captain baseline using config defaults
 export CRICKET_CAPTAIN_ENV_URL="ws://localhost:8001"
-python inference.py --config configs/default.yaml --episodes 3
+export HF_TOKEN="hf_..."
+python inference.py --config configs/default.yaml --episodes 1
+```
+
+The default config uses the HF router-compatible model `google/gemma-4-26B-A4B-it` for captain-side inference and live opponent defaults. In `llm_live` mode, the opponent actually calls that model during the run. In `llm_cached` mode, the opponent does **not** call `model`; it replays `cache_path`.
+
+For fair/reproducible eval:
+
+```bash
+PYTHONPATH=. python server/app.py --port 8001 --config configs/cached_eval.yaml
+export CRICKET_CAPTAIN_ENV_URL="ws://localhost:8001"
+export HF_TOKEN="hf_..."
+python inference.py --config configs/cached_eval.yaml --episodes 1
 ```
 
 ```bash
@@ -311,6 +323,30 @@ For fast iteration, start with short 5-over runs before full 20-over evaluation:
 
 See [`docs/experiment_workflow.md`](docs/experiment_workflow.md) for exact commands and rationale.
 
+### Latest 5-Over Smoke Checks
+
+OpenEnv end-to-end runs are saved under [`illustrations/`](illustrations/).
+
+```text
+Random captain + cached LLM opponent:
+  Score: 13.5 avg across 2 episodes
+  Mean reward: 0.984
+  Mean coherence: 0.555
+  Parse errors: 0.0%
+
+HF Gemma 4 captain + cached LLM opponent:
+  Model: google/gemma-4-26B-A4B-it via https://router.huggingface.co/v1
+  Trace: 40 OpenEnv turns with reset/step/action logs
+  Score: 7/0 after 2.2 overs
+  Reward sum: 0.168
+  Coherence: 0.657
+  Adaptation: 0.502
+  Opponent awareness: 0.750
+  Parse errors: 0.0%
+```
+
+These are smoke-test numbers, not final benchmark numbers. They show the OpenEnv websocket loop, HF model inference, cached opponent replay, tool parsing, observation updates, opponent plans, and reward metrics are all working.
+
 ### Baseline Results (Random Agent)
 
 ```

configs/cached_eval.yaml

@@ -0,0 +1,18 @@
+env:
+  # Used by server + runners for reproducible comparison runs.
+  eval_pack_id: adaptive_t20_v1
+  max_overs: 5
+  env_url: ws://localhost:8000
+
+opponent:
+  # llm_cached does not call `model` live. It replays pre-generated decisions
+  # from cache_path so every captain model faces the same opponent behavior.
+  mode: llm_cached
+  cache_path: data/opponent_cache/adaptive_t20_v1_official_gemma2b.jsonl
+
+captain:
+  # Captain still calls HF router live in this config.
+  model: google/gemma-4-26B-A4B-it
+  api_base: https://router.huggingface.co/v1
+  api_key_env: HF_TOKEN
+

configs/default.yaml

@@ -6,16 +6,17 @@ env:
 
 opponent:
   # heuristic | llm_live | llm_cached
-  mode: llm_cached
-  model: google/gemma-2-2b-it
+  # llm_live calls the model below during the run.
+  # For reproducible cached evaluation, use configs/cached_eval.yaml instead.
+  mode: llm_live
+  model: google/gemma-4-26B-A4B-it
   api_base: https://router.huggingface.co/v1
   api_key_env: HF_TOKEN
-  cache_path: data/opponent_cache/adaptive_t20_v1_official_gemma2b.jsonl
 
 captain:
   # For inference/eval runner when using an API model (OpenAI-compatible).
   # You can still pass --model random for baseline runs.
-  model: google/gemma-2-2b-it
+  model: google/gemma-4-26B-A4B-it
   api_base: https://router.huggingface.co/v1
   api_key_env: HF_TOKEN
 

docs/benchmark_explainer.md

@@ -226,6 +226,14 @@ Calls an OpenAI-compatible LLM with a fixed prompt. Useful for:
 - realistic opponent behavior,
 - self-play-style experiments.
 
+The current default live opponent/captain model is:
+
+```text
+google/gemma-4-26B-A4B-it via https://router.huggingface.co/v1
+```
+
+In this mode, the opponent actually calls the configured model during the run.
+
 ### `llm_cached`
 
 Reads pre-recorded opponent decisions from JSONL. Useful for:
@@ -234,6 +242,8 @@ Reads pre-recorded opponent decisions from JSONL. Useful for:
 - reproducibility,
 - preventing eval randomness.
 
+In this mode, the opponent does **not** call the configured model live. It replays the JSONL cache so every compared captain faces the same opponent decisions.
+
 The key idea:
 
 > Teams can change their agent however they want, but the evaluation opponent should be frozen.

docs/experiment_workflow.md

@@ -26,7 +26,7 @@ Do not start with full 20-over training unless the 5-over loop is stable.
 
 ## 2. Current Opponent Modes
 
-Opponent behavior is controlled by `CRICKET_OPPONENT_MODE` or `--opponent-mode`.
+Opponent behavior is controlled by YAML (`configs/default.yaml` / `configs/cached_eval.yaml`), `CRICKET_OPPONENT_MODE`, or `--opponent-mode`.
 
 The code supports three modes in `server/opponent_policy.py`.
 
@@ -63,14 +63,15 @@ Cons:
 
 ```bash
 export CRICKET_OPPONENT_MODE=llm_live
-export CRICKET_OPPONENT_MODEL=gpt-4o-mini
-export CRICKET_OPPONENT_API_KEY=...
+export CRICKET_OPPONENT_MODEL=google/gemma-4-26B-A4B-it
+export CRICKET_OPPONENT_API_BASE=https://router.huggingface.co/v1
+export HF_TOKEN=...
 ```
 
-The default live opponent model in code is:
+The default live opponent model in code/config is:
 
 ```text
-gpt-4o-mini
+google/gemma-4-26B-A4B-it
 ```
 
 This mode calls an OpenAI-compatible API from `LLMOpponentPolicy`.
@@ -98,10 +99,10 @@ Cons:
 
 ```bash
 export CRICKET_OPPONENT_MODE=llm_cached
-export CRICKET_OPPONENT_CACHE=data/opponent_cache/adaptive_t20_v1.jsonl
+export CRICKET_OPPONENT_CACHE=data/opponent_cache/adaptive_t20_v1_official_gemma2b.jsonl
 ```
 
-This mode replays pre-recorded opponent decisions.
+This mode replays pre-recorded opponent decisions. It does **not** call `CRICKET_OPPONENT_MODEL` live during the run; `cache_path` is the source of opponent behavior.
 
 Use it for:
 
@@ -119,28 +120,31 @@ This gives the benefit of an LLM opponent while ensuring every model faces the s
 
 ## 3. What Model Is The Opposite Team?
 
-Currently:
+Currently, the default live opponent is:
 
 ```text
-default opponent = heuristic policy
+google/gemma-4-26B-A4B-it via https://router.huggingface.co/v1
 ```
 
-If `llm_live` is enabled:
+Important distinction:
 
 ```text
-default LLM opponent = gpt-4o-mini
+llm_live   -> calls the configured model during the run
+llm_cached -> ignores live model calls and replays cache_path
+heuristic  -> uses local rule-based cricket policy
 ```
 
 This can be changed with:
 
 ```bash
+export CRICKET_OPPONENT_MODE=llm_live
 export CRICKET_OPPONENT_MODEL=<model-name>
 ```
 
 For example:
 
 ```bash
-export CRICKET_OPPONENT_MODEL=gpt-4o-mini
+export CRICKET_OPPONENT_MODEL=google/gemma-4-26B-A4B-it
 ```
 
 or with another OpenAI-compatible server:
@@ -312,16 +316,33 @@ Use for:
 - comparing before/after quickly,
 - cheap experiments.
 
-At the moment, the environment supports `max_overs`, but `inference.py` and `eval.py` do not expose a `--max-overs` flag yet. That should be added next.
+Both `inference.py` and `eval.py` support `--max-overs`, and the YAML configs set `max_overs: 5` by default for quick iteration.
 
-Target command after adding the flag:
+Random captain sanity check:
 
 ```bash
 PYTHONPATH=. python inference.py \
   --model random \
   --episodes 5 \
   --max-overs 5 \
-  --env-url "$CRICKET_CAPTAIN_ENV_URL"
+  --env-url "$CRICKET_CAPTAIN_ENV_URL" \
+  --eval-pack-id adaptive_t20_v1 \
+  --opponent-mode llm_cached
+```
+
+HF Gemma captain with live HF inference:
+
+```bash
+export HF_TOKEN="hf_..."
+PYTHONPATH=. python inference.py \
+  --model google/gemma-4-26B-A4B-it \
+  --api-base https://router.huggingface.co/v1 \
+  --api-key "$HF_TOKEN" \
+  --episodes 1 \
+  --max-overs 5 \
+  --env-url "$CRICKET_CAPTAIN_ENV_URL" \
+  --eval-pack-id adaptive_t20_v1 \
+  --opponent-mode llm_cached
 ```
 
 ### 20-Over Evaluation
@@ -402,26 +423,34 @@ Minimum final numbers to report:
 - score/wickets,
 - chase or defense success rate.
 
-## 14. Immediate Next Engineering Improvement
+## 14. Latest Smoke-Test Evidence
 
-Add these CLI flags:
+The current reproducible run artifacts live under `illustrations/`.
 
 ```text
-inference.py --max-overs 5
-eval.py --max-overs 5
-inference.py --use-eval-pack-start
-eval.py --use-eval-pack-start
+Random captain + cached LLM opponent:
+  mean score: 13.5 across 2 episodes
+  mean reward: 0.984
+  mean coherence: 0.555
+  parse errors: 0.0%
+
+HF Gemma 4 captain + cached LLM opponent:
+  model: google/gemma-4-26B-A4B-it
+  trace: 40 OpenEnv turns with reset/step/action logs
+  score: 7/0 after 2.2 overs
+  reward sum: 0.168
+  coherence: 0.657
+  adaptation: 0.502
+  opponent awareness: 0.750
+  parse errors: 0.0%
 ```
 
-This will make quick 5-over experiments clean and repeatable.
+These are smoke checks, not final leaderboard numbers. They demonstrate that OpenEnv websocket interaction, HF router inference, tool-call parsing, cached opponent replay, observation updates, opponent plans, and reward metrics are all functioning.
 
-After that, run:
+## 15. Immediate Next Engineering Improvement
 
-```text
-random 5-over baseline
-base LLM 5-over baseline
-short GRPO
-trained 5-over eval
-```
+Next useful work:
 
-Then move to full 20-over evaluation.
+- Generate a fresh cached-opponent file using `google/gemma-4-26B-A4B-it` in `llm_live` mode.
+- Run a 5-over base-model comparison across random, Gemma 4, and one trained checkpoint.
+- Move the strongest setup to 20-over evaluation.

illustrations/README.md

@@ -0,0 +1,12 @@
+## Illustrations (reproducible experiments)
+
+Each subfolder here is a self-contained experiment snapshot:
+- **how to run** (exact command)
+- **what changed** (config/opponent/eval pack)
+- **results** (captured stdout + notes)
+
+### Index
+
+- `exp_2026-04-25_5over_random_llm_cached/`: sanity check run (5-over), random captain, cached LLM opponent.
+- `exp_2026-04-25_5over_gemma4_hf/`: successful HF router run with Gemma 4 captain, cached LLM opponent, including a verbose OpenEnv reset/step trace.
+

illustrations/exp_2026-04-25_5over_gemma4_hf/README.md

@@ -0,0 +1,59 @@
+## Experiment: 5-over HF Gemma 4 captain, cached opponent
+
+### Goal
+
+Run a real Hugging Face-hosted Gemma captain model through the OpenAI-compatible HF router, instead of the random baseline.
+
+### Model
+
+- **Captain model**: `google/gemma-4-26B-A4B-it`
+- **API base**: `https://router.huggingface.co/v1`
+- **Opponent mode**: `llm_cached`
+- **Eval pack**: `adaptive_t20_v1`
+- **Max overs**: `5`
+
+Note: HF router listed this Gemma 4 model as available. The earlier `google/gemma-2-2b-it` id was rejected by the router/provider configuration.
+
+### Required token
+
+HF router inference requires a token:
+
+```bash
+export HF_TOKEN="hf_..."
+```
+
+### Run
+
+From `cricket_captain/`:
+
+```bash
+export CRICKET_CAPTAIN_ENV_URL="ws://localhost:8001"
+export HF_TOKEN="hf_..."
+
+python inference.py \
+  --model google/gemma-4-26B-A4B-it \
+  --api-base https://router.huggingface.co/v1 \
+  --api-key "$HF_TOKEN" \
+  --episodes 1 \
+  --task stage2_full \
+  --max-overs 5 \
+  --env-url "$CRICKET_CAPTAIN_ENV_URL" \
+  --eval-pack-id adaptive_t20_v1 \
+  --opponent-mode llm_cached
+```
+
+### Results
+
+See `run_output.txt`.
+
+The file is intentionally verbose. It logs:
+
+- OpenEnv websocket connection and `reset(options=...)`
+- observation fields returned by the server
+- raw HF Gemma model responses
+- parsed `CricketAction` objects
+- every OpenEnv `step(action)` call
+- reward after each step
+- updated match context, opponent plan, and last-ball result
+- final state metrics
+

illustrations/exp_2026-04-25_5over_gemma4_hf/run_output.txt

@@ -0,0 +1,385 @@
+# 5-over OpenEnv trace: HF Gemma captain vs cached LLM opponent
+timestamp_utc: 2026-04-25T08:47:40.021678+00:00
+env_url: ws://localhost:8001
+captain_model: google/gemma-4-26B-A4B-it
+api_base: https://router.huggingface.co/v1
+reset_options: {'task': 'stage2_full', 'random_start': False, 'eval_pack_id': 'adaptive_t20_v1', 'opponent_mode': 'llm_cached', 'max_overs': 5}
+token: [REDACTED]
+
+[openenv] connecting websocket client...
+[openenv] connected
+[openenv] reset(options=...)
+[openenv] reset -> done=False reward=0.0
+[observation] game_state=toss strategic_phase=toss eval_pack_id=adaptive_t20_v1
+[observation] available_tools=['call_toss']
+[observation] prompt_preview="[CricketCaptain] TOSS | FIRST INNINGS\nOver 0.0 | Score: 0/0\nPhase: POWERPLAY | Strategic turn: TOSS\nBowler: PACE | Field: Balanced\nCurrent batter: Opener (balanced)\nCurrent bowler: Strike Pacer (pace)\n\nTool: call_toss(call: 'heads'|'tails', decision: 'bat'|'bowl')\n\nLast ball: Match setup. Use 'call_toss' to begin."
+
+--- turn 0 ---
+[before] game_state=toss strategic_phase=toss last_ball="Match setup. Use 'call_toss' to begin."
+[model.raw] {"call_toss": {"call": "heads", "decision": "bat"}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'call_toss', 'arguments': {'call': 'heads', 'decision': 'bat'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'pace', 'field_setting': 'Balanced', 'strategic_phase': 'pre_over', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Toss result: tails. Opponent won and chose to bat. You are Bowling.'
+
+--- turn 1 ---
+[before] game_state=bowling strategic_phase=pre_over last_ball='Toss result: tails. Opponent won and chose to bat. You are Bowling.'
+[model.raw] {"set_field_setting": {"setting": "Aggressive"}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'set_field_setting', 'arguments': {'setting': 'Aggressive'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_over', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Field set to Aggressive.'
+
+--- turn 2 ---
+[before] game_state=bowling strategic_phase=pre_over last_ball='Field set to Aggressive.'
+[model.raw] {"set_bowling_strategy": {"bowler_type": "Pace", "line": "Outside off stump", "length": "Full/Good length", "delivery_type": "Fast/Swing", "rationale": "Exploit the powerplay with aggressive line and length to induce an edge or drive against the aggressive field."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'set_bowling_strategy', 'arguments': {'bowler_type': 'Pace', 'line': 'Outside off stump', 'length': 'Full/Good length', 'delivery_type': 'Fast/Swing', 'rationale': 'Exploit the powerplay with aggressive line and length to induce an edge or drive against the aggressive field.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Bowling strategy updated.'
+
+--- turn 3 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Bowling strategy updated.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Outside off stump", "length": "Full", "delivery_type": "Outswinger", "rationale": "Aiming for the corridor of uncertainty to test the opener's technique early in the innings."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Outside off stump', 'length': 'Full', 'delivery_type': 'Outswinger', 'rationale': "Aiming for the corridor of uncertainty to test the opener's technique early in the innings."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Outswinger.'
+
+--- turn 4 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Outswinger.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 1, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Worked off the hips — dot ball.'
+
+--- turn 5 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Worked off the hips — dot ball.'
+[model.raw] {"reflect_after_ball": {"reflection": "Good start with a dot ball. The outswinger tested the batter's technique. I will maintain the same line and length to build pressure."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "Good start with a dot ball. The outswinger tested the batter's technique. I will maintain the same line and length to build pressure."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 1, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 6 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Outside off stump", "length": "Full", "delivery_type": "Outswinger", "rationale": "Continuing the pressure by targeting the same corridor of uncertainty to exploit the aggressive field."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Outside off stump', 'length': 'Full', 'delivery_type': 'Outswinger', 'rationale': 'Continuing the pressure by targeting the same corridor of uncertainty to exploit the aggressive field.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 1, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Outswinger.'
+
+--- turn 7 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Outswinger.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 2, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Launched over long-on — dot ball!'
+
+--- turn 8 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Launched over long-on — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "The batter attempted a big shot but failed to connect, resulting in a dot. The pressure is mounting. I'll stick to the plan of targeting the off-stump to keep them searching for runs and prevent them from settling."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "The batter attempted a big shot but failed to connect, resulting in a dot. The pressure is mounting. I'll stick to the plan of targeting the off-stump to keep them searching for runs and prevent them from settling."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 2, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 9 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 3, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Worked off the hips — dot ball.'
+
+--- turn 10 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Worked off the hips — dot ball.'
+[model.raw] {"reflect_after_ball": {"reflection": "Two dot balls in a row. The batter is struggling to find timing against the outswinger. I will maintain the same line and length to keep the pressure high and force a mistake."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'Two dot balls in a row. The batter is struggling to find timing against the outswinger. I will maintain the same line and length to keep the pressure high and force a mistake.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 3, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 11 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 4, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Driven through the covers — dot ball!'
+
+--- turn 12 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Driven through the covers — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "Three dot balls in the opening over. The batter is trying to play through the covers, but the outswinger is keeping them from finding the boundary. I'll maintain the full length and outside off-stump line to continue testing their technique and keep the pressure on."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "Three dot balls in the opening over. The batter is trying to play through the covers, but the outswinger is keeping them from finding the boundary. I'll maintain the full length and outside off-stump line to continue testing their technique and keep the pressure on."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 4, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 13 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 5, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Launched over long-on — dot ball!'
+
+--- turn 14 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Launched over long-on — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "Four dot balls in the over. The batter is attempting high-risk shots like the lofted drive over long-on, but the length is keeping them from getting under the ball. I will stick to the plan of targeting the outside edge to induce a mistake or a mistimed shot."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'Four dot balls in the over. The batter is attempting high-risk shots like the lofted drive over long-on, but the length is keeping them from getting under the ball. I will stick to the plan of targeting the outside edge to induce a mistake or a mistimed shot.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 0, 'ball': 5, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 15 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Worked off the hips — dot ball.'
+
+--- turn 16 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Worked off the hips — dot ball.'
+[model.raw] {"reflect_after_ball": {"reflection": "Five dot balls in the first over. The batter is struggling to find gaps or timing, playing mostly defensively or mistiming shots. I'll maintain the same line and length to keep the pressure high and see if they lose patience."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "Five dot balls in the first over. The batter is struggling to find gaps or timing, playing mostly defensively or mistiming shots. I'll maintain the same line and length to keep the pressure high and see if they lose patience."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 0, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 17 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 1, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Worked off the hips — dot ball.'
+
+--- turn 18 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Worked off the hips — dot ball.'
+[model.raw] {"reflect_after_ball": {"reflection": "Six dot balls in the opening over. The batter has failed to score or rotate strike. The pressure is immense. I will maintain the aggressive field and continue with the outswingers to see if the batter attempts a reckless shot to break the shackles in the next over."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'Six dot balls in the opening over. The batter has failed to score or rotate strike. The pressure is immense. I will maintain the aggressive field and continue with the outswingers to see if the batter attempts a reckless shot to break the shackles in the next over.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 1, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 19 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 2, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Launched over long-on — dot ball!'
+
+--- turn 20 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Launched over long-on — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "The batter attempted a massive shot but failed to connect cleanly, resulting in another dot ball. They are clearly looking to dominate the powerplay early. I will stick to the plan of targeting the outside edge with outswingers to induce an error, as the aggressive field is working to restrict scoring."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'The batter attempted a massive shot but failed to connect cleanly, resulting in another dot ball. They are clearly looking to dominate the powerplay early. I will stick to the plan of targeting the outside edge with outswingers to induce an error, as the aggressive field is working to restrict scoring.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 2, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 21 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Outside off stump", "length": "Full", "delivery_type": "Outswinger", "rationale": "The batter is looking to hit big; I will continue to target the corridor of uncertainty with full-length outswingers to induce an edge or a mistimed drive."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Outside off stump', 'length': 'Full', 'delivery_type': 'Outswinger', 'rationale': 'The batter is looking to hit big; I will continue to target the corridor of uncertainty with full-length outswingers to induce an edge or a mistimed drive.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 2, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Outswinger.'
+
+--- turn 22 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Outswinger.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 3, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Driven through the covers — dot ball!'
+
+--- turn 23 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Driven through the covers — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "Another dot ball. The batter is finding the gaps but not getting the boundary. They are playing with high intent. I will maintain the pressure by sticking to the outswingers, but I'll keep an eye on the length to ensure I don't become too predictable and get milked for singles."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "Another dot ball. The batter is finding the gaps but not getting the boundary. They are playing with high intent. I will maintain the pressure by sticking to the outswingers, but I'll keep an eye on the length to ensure I don't become too predictable and get milked for singles."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 3, 'score': 0, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 24 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 3, 'score': 1, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Wide delivery — extra run added. Ball to be replayed.'
+
+--- turn 25 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Wide delivery — extra run added. Ball to be replayed.'
+[model.raw] {"reflect_after_ball": {"reflection": "The wide was a lapse in control. I need to tighten up the line and ensure the outswinger is hitting the target without straying too far down the leg side or too wide to be easily punished. I'll stick to the plan but focus on execution accuracy."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "The wide was a lapse in control. I need to tighten up the line and ensure the outswinger is hitting the target without straying too far down the leg side or too wide to be easily punished. I'll stick to the plan but focus on execution accuracy."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 3, 'score': 1, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 26 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Outside off stump", "length": "Full", "delivery_type": "Outswinger", "rationale": "Need to regain control after the wide. I will stick to the outswinger plan but focus on a tighter line just outside off stump to force the batter to play at it without providing width for easy scoring."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Outside off stump', 'length': 'Full', 'delivery_type': 'Outswinger', 'rationale': 'Need to regain control after the wide. I will stick to the outswinger plan but focus on a tighter line just outside off stump to force the batter to play at it without providing width for easy scoring.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 3, 'score': 1, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Outswinger.'
+
+--- turn 27 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Outswinger.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.006
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 4, 'score': 2, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Driven through the covers — a single!'
+
+--- turn 28 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Driven through the covers — a single!'
+[model.raw] {"reflect_after_ball": {"reflection": "The batter is using the pace and finding the gaps easily. The single through covers shows they are comfortable playing the full length. I need to vary the length slightly or tighten the line even more to prevent them from getting into a rhythm and milking the singles."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'The batter is using the pace and finding the gaps easily. The single through covers shows they are comfortable playing the full length. I need to vary the length slightly or tighten the line even more to prevent them from getting into a rhythm and milking the singles.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 4, 'score': 2, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 29 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "On off stump", "length": "Good length", "delivery_type": "Back of a length cutter", "rationale": "The batter is finding the covers easily with full deliveries. I'll change the pace and length to a back-of-a-length cutter on the off stump to disrupt their rhythm and prevent them from driving through the covers."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'On off stump', 'length': 'Good length', 'delivery_type': 'Back of a length cutter', 'rationale': "The batter is finding the covers easily with full deliveries. I'll change the pace and length to a back-of-a-length cutter on the off stump to disrupt their rhythm and prevent them from driving through the covers."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 4, 'score': 2, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Back of a length cutter.'
+
+--- turn 30 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Back of a length cutter.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 5, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Worked off the hips — a FOUR.'
+
+--- turn 31 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Worked off the hips — a FOUR.'
+[model.raw] {"reflect_after_ball": {"reflection": "The cutter was misjudged or played too easily off the hips, resulting in a boundary. The batter is clearly looking to punish anything that isn't perfectly executed. I need to return to a more standard length or perhaps a quicker delivery to prevent them from playing them off the hips so easily. I'll try to bring the line back slightly wider to force them to reach, or go for a quicker, fuller delivery to see if I can get them playing late."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "The cutter was misjudged or played too easily off the hips, resulting in a boundary. The batter is clearly looking to punish anything that isn't perfectly executed. I need to return to a more standard length or perhaps a quicker delivery to prevent them from playing them off the hips so easily. I'll try to bring the line back slightly wider to force them to reach, or go for a quicker, fuller delivery to see if I can get them playing late."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.005
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 5, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 32 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Wide of off stump", "length": "Full", "delivery_type": "Fast yorker length", "rationale": "The batter just hit a boundary off the cutter. I need to stop them from playing off the hips. By moving the line wider and aiming for a fuller, quicker delivery, I'll force them to reach and prevent them from using the pace or the cutter's grip to work it through the leg side or covers."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Wide of off stump', 'length': 'Full', 'delivery_type': 'Fast yorker length', 'rationale': "The batter just hit a boundary off the cutter. I need to stop them from playing off the hips. By moving the line wider and aiming for a fuller, quicker delivery, I'll force them to reach and prevent them from using the pace or the cutter's grip to work it through the leg side or covers."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 1, 'ball': 5, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'rotate', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Fast yorker length.'
+
+--- turn 33 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Fast yorker length.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 0, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Driven through the covers — dot ball!'
+
+--- turn 34 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Driven through the covers — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "The full, wide delivery worked well to prevent the boundary and resulted in a dot ball. The batter was forced to reach, which disrupted their ability to play off the hips. I have successfully regained control. I will maintain this pressure by sticking to a similar line and length, perhaps slightly more attacking to see if I can induce an edge or a mistake while they are adjusting to the width."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': 'The full, wide delivery worked well to prevent the boundary and resulted in a dot ball. The batter was forced to reach, which disrupted their ability to play off the hips. I have successfully regained control. I will maintain this pressure by sticking to a similar line and length, perhaps slightly more attacking to see if I can induce an edge or a mistake while they are adjusting to the width.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 0, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 35 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"plan_delivery": {"bowler_type": "Pace", "line": "Wide of off stump", "length": "Full", "delivery_type": "Fast yorker length", "rationale": "The previous delivery was a dot ball, successfully forcing the batter to reach. I will stick to this plan to maintain pressure and exploit the width, aiming to keep the batter from settling into a rhythm."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'plan_delivery', 'arguments': {'bowler_type': 'Pace', 'line': 'Wide of off stump', 'length': 'Full', 'delivery_type': 'Fast yorker length', 'rationale': 'The previous delivery was a dot ball, successfully forcing the batter to reach. I will stick to this plan to maintain pressure and exploit the width, aiming to keep the batter from settling into a rhythm.'}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.000
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 0, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'ball_resolution', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'boundary', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Delivery plan set: Fast yorker length.'
+
+--- turn 36 ---
+[before] game_state=bowling strategic_phase=ball_resolution last_ball='Delivery plan set: Fast yorker length.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.006
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 1, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Launched over long-on — dot ball!'
+
+--- turn 37 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Launched over long-on — dot ball!'
+[model.raw] {"reflect_after_ball": {"reflection": "The batter attempted a high-risk launch over long-on but failed to connect for a boundary, resulting in a dot ball. This shows they are trying to force the pace against my wide line. While I've kept them from scoring, the intent to attack is high. I need to stay disciplined with my line to prevent them from getting under the ball, but I might consider slightly varying the length to a good length to see if they're over-committing to the drive/loft."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "The batter attempted a high-risk launch over long-on but failed to connect for a boundary, resulting in a dot ball. This shows they are trying to force the pace against my wide line. While I've kept them from scoring, the intent to attack is high. I need to stay disciplined with my line to prevent them from getting under the ball, but I might consider slightly varying the length to a good length to see if they're over-committing to the drive/loft."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 1, 'score': 6, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+--- turn 38 ---
+[before] game_state=bowling strategic_phase=pre_ball last_ball='Reflection recorded.'
+[model.raw] {"bowl_delivery": {}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'bowl_delivery', 'arguments': {}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.006
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 2, 'score': 7, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'post_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Launched over long-on — a single!'
+
+--- turn 39 ---
+[before] game_state=bowling strategic_phase=post_ball last_ball='Launched over long-on — a single!'
+[model.raw] {"reflect_after_ball": {"reflection": "The batter managed to get a single by launching the ball over long-on, breaking the dot ball pressure. They are clearly looking to exploit the width and power through the air. I need to adjust my length slightly to avoid being too predictable or too full, which allows them to get under the ball. I'll move from a yorker length to a slightly fuller 'good length' to make it harder to loft, while maintaining the wide line to keep them away from their hitting zone."}}
+[parser] parse_error=False action={'metadata': {}, 'tool': 'reflect_after_ball', 'arguments': {'reflection': "The batter managed to get a single by launching the ball over long-on, breaking the dot ball pressure. They are clearly looking to exploit the width and power through the air. I need to adjust my length slightly to avoid being too predictable or too full, which allows them to get under the ball. I'll move from a yorker length to a slightly fuller 'good length' to make it harder to loft, while maintaining the wide line to keep them away from their hitting zone."}}
+[openenv] step(action)
+[openenv] step -> done=False reward=0.007
+[after] score_context={'game_state': 'bowling', 'innings': 'first', 'over': 2, 'ball': 2, 'score': 7, 'wickets': 0, 'target': None, 'phase': 'powerplay', 'bowler_type': 'Pace', 'field_setting': 'Aggressive', 'strategic_phase': 'pre_ball', 'current_batter': {'name': 'Opener', 'style': 'balanced', 'aggression': 0.55}, 'current_bowler': {'name': 'Strike Pacer', 'type': 'pace', 'style': 'swing'}, 'opponent_plan': {'shot_intent': 'six', 'aggression': 0.7, 'rationale': 'Opponent bats with powerplay phase risk and 0 wickets down.'}, 'eval_pack_id': 'adaptive_t20_v1'}
+[after] last_ball='Reflection recorded.'
+
+[openenv] state()
+[final] score=7/0 over=2.2
+[final] game_state=bowling target=None tool_calls=40
+[final] rewards_sum=0.168
+[final] mean_coherence=0.657
+[final] mean_adaptation=0.502
+[final] mean_opponent_awareness=0.750
+[final] parse_error_rate=0.0%
+[final] transcript_events=85

illustrations/exp_2026-04-25_5over_random_llm_cached/README.md

@@ -0,0 +1,32 @@
+## Experiment: 5-over sanity check (random captain, cached opponent)
+
+### Goal
+
+Verify end-to-end wiring works (server ↔ runner ↔ tools/metrics) for a short innings.
+
+### Setup
+
+- **Server**: must be reachable at `ws://localhost:8001/ws` (or set `CRICKET_CAPTAIN_ENV_URL`)
+- **Eval pack**: `adaptive_t20_v1`
+- **Opponent mode**: `llm_cached`
+
+### Run
+
+From `cricket_captain/`:
+
+```bash
+export CRICKET_CAPTAIN_ENV_URL="ws://localhost:8001"
+python inference.py \
+  --model random \
+  --episodes 2 \
+  --task stage2_full \
+  --max-overs 5 \
+  --env-url "$CRICKET_CAPTAIN_ENV_URL" \
+  --eval-pack-id adaptive_t20_v1 \
+  --opponent-mode llm_cached
+```
+
+### Results
+
+See `run_output.txt`.
+

illustrations/exp_2026-04-25_5over_random_llm_cached/run_output.txt

@@ -0,0 +1,10 @@
+Using RandomAgent baseline
+Episode   1/2 | Score:  14/2 (5 ov) | Reward:  0.817 | Coherence: 0.548 | Adapt: 0.615 | ParseErr: 0.0%
+Episode   2/2 | Score:  13/0 (3 ov) | Reward:  1.151 | Coherence: 0.562 | Adapt: 0.580 | ParseErr: 0.0%
+
+=== Summary ===
+  total_score         : mean=13.500  std=0.707
+  wickets_lost        : mean=1.000  std=1.414
+  total_reward        : mean=0.984  std=0.236
+  mean_coherence      : mean=0.555  std=0.010
+  parse_error_rate    : mean=0.000  std=0.000

inference.py

@@ -64,6 +64,46 @@ Always respond with exactly one JSON object on a single line, no markdown."""
 SHOT_AGGRESSION_ORDER = ["leave", "defensive", "single", "rotate", "boundary", "six"]
 
 
+def _coerce_aggression(value: Any, default: float = 0.5) -> float:
+    if isinstance(value, (int, float)):
+        return max(0.0, min(1.0, float(value)))
+    text = str(value).strip().lower()
+    word_map = {
+        "very low": 0.15,
+        "low": 0.25,
+        "conservative": 0.25,
+        "defensive": 0.25,
+        "moderate": 0.5,
+        "medium": 0.5,
+        "balanced": 0.5,
+        "normal": 0.5,
+        "high": 0.75,
+        "aggressive": 0.75,
+        "very high": 0.9,
+        "attack": 0.8,
+        "attacking": 0.8,
+    }
+    try:
+        return max(0.0, min(1.0, float(text)))
+    except ValueError:
+        return word_map.get(text, default)
+
+
+def _normalize_action_args(tool: str, args: dict[str, Any]) -> dict[str, Any]:
+    """Normalize common LLM variants before sending to the server."""
+    normalized = dict(args)
+    if tool in ("set_strategy", "select_batter") and "aggression" in normalized:
+        normalized["aggression"] = _coerce_aggression(normalized["aggression"])
+    if tool == "plan_shot" and str(normalized.get("risk", "")).lower() == "moderate":
+        normalized["risk"] = "balanced"
+    if tool == "call_toss":
+        call = str(normalized.get("call", "heads")).lower()
+        decision = str(normalized.get("decision", "bat")).lower()
+        normalized["call"] = call if call in ("heads", "tails") else "heads"
+        normalized["decision"] = decision if decision in ("bat", "bowl") else "bat"
+    return normalized
+
+
 class RandomAgent:
     """Baseline: random valid tool calls based on availability."""
 
@@ -191,8 +231,8 @@ class OpenAIAgent:
         resp = self._client.chat.completions.create(
             model=self._model,
             messages=messages,
-            temperature=0.7,
-            max_tokens=200,
+            temperature=0.2,
+            max_tokens=300,
         )
         return resp.choices[0].message.content.strip()
 
@@ -203,16 +243,24 @@ def _parse_action(raw: str) -> tuple[CricketAction | None, bool]:
         lines = raw.split("\n")
         raw = "\n".join(lines[1:-1]) if len(lines) > 2 else raw
     try:
-        data = json.loads(raw)
-        tool = data.get("tool", "")
+        if not raw.startswith("{"):
+            start = raw.find("{")
+            if start >= 0:
+                raw = raw[start:]
+        data, _ = json.JSONDecoder().raw_decode(raw)
         valid_tools = (
             "set_strategy", "analyze_situation", "play_delivery",
             "call_toss", "bowl_delivery", "set_bowling_strategy", "set_field_setting",
             "choose_bowler", "select_batter", "plan_delivery", "plan_shot", "reflect_after_ball"
         )
+        if "tool" not in data and len(data) == 1:
+            maybe_tool, maybe_args = next(iter(data.items()))
+            if maybe_tool in valid_tools and isinstance(maybe_args, dict):
+                data = {"tool": maybe_tool, "arguments": maybe_args}
+        tool = data.get("tool", "")
         if tool not in valid_tools:
             return None, True
-        return CricketAction(tool=tool, arguments=data.get("arguments", {})), False
+        return CricketAction(tool=tool, arguments=_normalize_action_args(tool, data.get("arguments", {}))), False
     except Exception:
         return None, True
 

server/opponent_policy.py

@@ -164,7 +164,7 @@ class LLMOpponentPolicy:
         self._fallback = fallback
         # Default to an HF-hosted model via HF router unless overridden.
         # This mirrors the OpenAI-compatible Hugging Face router pattern used by other OpenEnv submissions.
-        self._model = model or os.environ.get("CRICKET_OPPONENT_MODEL", "google/gemma-2-2b-it")
+        self._model = model or os.environ.get("CRICKET_OPPONENT_MODEL", "google/gemma-4-26B-A4B-it")
         self._temperature = temperature
         try:
             import openai