synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

examples/task_apps/crafter/task_app/synth_envs_hosted/rollout.py

@@ -0,0 +1,2233 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import logging
+import os
+import time as _time
+from datetime import datetime
+from typing import Any, Mapping
+
+from fastapi import APIRouter, HTTPException, Request, status
+from pydantic import BaseModel, Field
+from synth_ai.tracing_v3 import BaseLMResponse
+from synth_ai.task.tracing_utils import unique_sft_path
+from synth_ai.tracing_v3.abstractions import EnvironmentEvent, LMCAISEvent, TimeRecord
+from synth_ai.task.contracts import RolloutMode
+from synth_ai.tracing_v3.llm_call_record_helpers import create_llm_call_record_from_response
+from synth_ai.tracing_v3.session_tracer import SessionTracer
+
+from .registry import registry
+
+logger = logging.getLogger(__name__)
+
+
+# --- Seeding utilities (robust, optional deps) ---
+def _set_global_seed(seed_value: int) -> dict[str, Any]:
+    """Set global RNG seeds across common libraries; return details for logging/restoration.
+
+    Returns a dict containing which libraries were seeded and prior states if obtainable.
+    """
+    seeded: dict[str, Any] = {"seed": int(seed_value), "libs": []}
+    with contextlib.suppress(Exception):
+        import random as _random  # type: ignore
+
+        _random.seed(seed_value)
+        seeded["libs"].append("random")
+    with contextlib.suppress(Exception):
+        import numpy as _np  # type: ignore
+
+        _np.random.seed(seed_value)
+        seeded["libs"].append("numpy")
+    with contextlib.suppress(Exception):
+        import torch as _torch  # type: ignore
+
+        if hasattr(_torch, "manual_seed"):
+            _torch.manual_seed(seed_value)
+            seeded["libs"].append("torch")
+        # Make CUDA deterministic if present (best-effort)
+        with contextlib.suppress(Exception):
+            if getattr(_torch, "cuda", None) and _torch.cuda.is_available():
+                _torch.cuda.manual_seed_all(seed_value)
+                seeded.setdefault("cuda", True)
+        # CUDNN deterministic flags (optional)
+        with contextlib.suppress(Exception):
+            if getattr(_torch, "backends", None) and getattr(_torch.backends, "cudnn", None):
+                _torch.backends.cudnn.deterministic = True  # type: ignore[attr-defined]
+                _torch.backends.cudnn.benchmark = False  # type: ignore[attr-defined]
+    return seeded
+
+
+def _clear_seed_side_effects() -> None:
+    """Best-effort cleanup to avoid global deterministic side-effects between requests."""
+    # We cannot truly restore prior RNG states without capturing them; we just avoid
+    # leaving aggressive deterministic flags enabled where it matters.
+    with contextlib.suppress(Exception):
+        import torch as _torch  # type: ignore
+
+        with contextlib.suppress(Exception):
+            if getattr(_torch, "backends", None) and getattr(_torch.backends, "cudnn", None):
+                # Re-enable cudnn.benchmark default True only if it was True; safest is False -> leave as is.
+                # We'll keep deterministic False to avoid global impact; benchmark left False for stability.
+                _torch.backends.cudnn.deterministic = False  # type: ignore[attr-defined]
+
+
+router = APIRouter()
+
+
+class RolloutEnvSpec(BaseModel):
+    env_id: str | None = None
+    env_name: str | None = None
+    config: dict[str, Any] = {}
+    seed: int | None = None
+
+
+class RolloutPolicySpec(BaseModel):
+    policy_id: str | None = None
+    policy_name: str | None = None
+    config: dict[str, Any] = {}
+
+
+class RolloutBranchConfig(BaseModel):
+    branch_every_n_steps: int = 0
+    branch_on_condition: str | None = None
+    max_branches: int = 0
+    branch_policy: bool = False
+    branch_env: bool = False
+
+
+class RolloutRecordConfig(BaseModel):
+    trajectories: bool = True
+    logprobs: bool = False
+    value: bool = False
+    return_trace: bool = False
+    trace_format: str = "compact"
+
+
+class RolloutSafetyConfig(BaseModel):
+    max_ops: int = 100000
+    max_time_s: float = 3600.0
+
+
+class RolloutRequest(BaseModel):
+    run_id: str
+    env: RolloutEnvSpec
+    policy: RolloutPolicySpec
+    ops: list[str]  # ["agent", "env", ...]
+    record: RolloutRecordConfig = RolloutRecordConfig()
+    on_done: str = "reset"  # "reset" | "terminate"
+    branch: RolloutBranchConfig | None = None
+    safety: RolloutSafetyConfig = RolloutSafetyConfig()
+    # Optional run/session context
+    training_session_id: str | None = None
+    synth_base_url: str | None = None
+    # Mode controls URL transformation: REQUIRED to make intent explicit
+    mode: RolloutMode
+
+
+class RolloutStep(BaseModel):
+    obs: dict[str, Any]
+    tool_calls: list[dict[str, Any]]
+    reward: float | None = None
+    done: bool = False
+    truncated: bool | None = None
+    logprob: float | None = None
+    value: float | None = None
+    info: dict[str, Any] | None = None
+
+
+class RolloutTrajectory(BaseModel):
+    env_id: str
+    policy_id: str
+    steps: list[RolloutStep]
+    final: dict[str, Any] | None = None
+    length: int
+    decision_samples: list[dict[str, Any]] | None = None
+    inference_url: str | None = None
+
+
+def _normalize_step_strategy(raw_strategy: Any) -> str:
+    if not isinstance(raw_strategy, str):
+        return "consistent"
+    candidate = raw_strategy.strip().lower()
+    if not candidate:
+        return "consistent"
+    mapping = {
+        "simple": "consistent",
+        "consistent": "consistent",
+        "consistent_stepwise": "consistent",
+        "decision_consistent": "consistent",
+        "per_achievement": "per_achievement",
+        "per-achievement": "per_achievement",
+        "perachievement": "per_achievement",
+        "achievement_weighted": "per_achievement",
+        "complex": "per_achievement",
+    }
+    return mapping.get(candidate, "consistent")
+
+
+def _coerce_weights(raw_weights: Any) -> dict[str, float]:
+    weights: dict[str, float] = {}
+    if isinstance(raw_weights, dict):
+        for key, value in raw_weights.items():
+            try:
+                weights[str(key)] = float(value)
+            except Exception:
+                continue
+    return weights
+
+
+def _coerce_k_limits(raw_limits: Any) -> dict[str, int]:
+    limits: dict[str, int] = {}
+    if isinstance(raw_limits, dict):
+        for key, value in raw_limits.items():
+            try:
+                limits[str(key)] = int(value)
+            except Exception:
+                continue
+    return limits
+
+
+def _coerce_int_value(value: Any) -> int | None:
+    if isinstance(value, bool):
+        return int(value)
+    try:
+        return int(value)  # type: ignore[arg-type]
+    except Exception:
+        try:
+            return int(float(value))  # type: ignore[arg-type]
+        except Exception:
+            return None
+
+
+def _compute_resource_reward(
+    prev_inventory: Mapping[str, Any] | None,
+    new_inventory: Mapping[str, Any] | None,
+    prev_counts: Mapping[str, Any] | None,
+    new_counts: Mapping[str, Any] | None,
+) -> tuple[float, list[dict[str, Any]], dict[str, int], dict[str, int]]:
+    reward_total = 0.0
+    components: list[dict[str, Any]] = []
+    inventory_deltas: dict[str, int] = {}
+    achievement_deltas: dict[str, int] = {}
+
+    resource_weights = {
+        "wood": 0.10,
+        "sapling": 0.08,
+        "stone": 0.15,
+        "coal": 0.18,
+        "iron": 0.22,
+        "plant": 0.06,
+        "meat": 0.12,
+        "drink": 0.07,
+        "food": 0.07,
+        "water": 0.07,
+        "energy": 0.04,
+    }
+    tool_weights = {
+        "wood_pickaxe": 0.40,
+        "stone_pickaxe": 0.55,
+        "iron_pickaxe": 0.75,
+        "wood_sword": 0.35,
+        "stone_sword": 0.50,
+        "iron_sword": 0.70,
+        "furnace": 0.45,
+        "table": 0.30,
+        "bow": 0.45,
+    }
+    achievement_weights = {
+        "collect_wood": 0.08,
+        "collect_sapling": 0.06,
+        "collect_stone": 0.10,
+        "collect_coal": 0.12,
+        "collect_iron": 0.14,
+        "collect_drink": 0.06,
+        "collect_food": 0.06,
+        "collect_plant": 0.06,
+    }
+    default_resource_weight = 0.05
+    default_achievement_weight = 0.05
+
+    prev_inv = prev_inventory or {}
+    new_inv = new_inventory or {}
+    for key, raw_value in new_inv.items():
+        new_val = _coerce_int_value(raw_value)
+        if new_val is None:
+            continue
+        prev_val = _coerce_int_value(prev_inv.get(key, 0)) or 0
+        delta = new_val - prev_val
+        if delta <= 0:
+            continue
+        weight = resource_weights.get(key)
+        if weight is None and key in tool_weights:
+            weight = tool_weights[key]
+        if weight is None:
+            weight = default_resource_weight
+        gain = weight * delta
+        reward_total += gain
+        inventory_deltas[str(key)] = delta
+        components.append(
+            {
+                "type": "inventory",
+                "item": str(key),
+                "delta": delta,
+                "weight": weight,
+                "reward": gain,
+            }
+        )
+
+    prev_ct = prev_counts or {}
+    new_ct = new_counts or {}
+    for key, raw_value in new_ct.items():
+        new_val = _coerce_int_value(raw_value)
+        if new_val is None:
+            continue
+        prev_val = _coerce_int_value(prev_ct.get(key, 0)) or 0
+        delta = new_val - prev_val
+        if delta <= 0:
+            continue
+        weight = achievement_weights.get(key, default_achievement_weight)
+        gain = weight * delta
+        reward_total += gain
+        achievement_deltas[str(key)] = delta
+        components.append(
+            {
+                "type": "achievement_count",
+                "name": str(key),
+                "delta": delta,
+                "weight": weight,
+                "reward": gain,
+            }
+        )
+
+    return reward_total, components, inventory_deltas, achievement_deltas
+
+
+def compute_stepwise_reward(
+    prev_achievements: dict[str, bool],
+    new_achievements: dict[str, bool],
+    decision_index: int,
+    actions_summary: list[dict[str, Any]],
+    indicator_lambda: float,
+    *,
+    strategy: str | None = None,
+    weights: dict[str, float] | None = None,
+    k_limits: dict[str, int] | None = None,
+    episode_counts: dict[str, int] | None = None,
+    prev_inventory: dict[str, int] | None = None,
+    new_inventory: dict[str, int] | None = None,
+    prev_counts: dict[str, int] | None = None,
+    new_counts: dict[str, int] | None = None,
+) -> tuple[dict[str, Any], dict[str, Any], dict[str, float]]:
+    """Compute stepwise reward metadata given achievement states before/after a decision."""
+
+    prev_map = prev_achievements or {}
+    next_map = new_achievements or {}
+
+    unlocked = [name for name, value in next_map.items() if value and not prev_map.get(name, False)]
+    indicator_from_achievements = 1 if unlocked else 0
+    normalized_strategy = _normalize_step_strategy(strategy)
+    base_reward = 0.0
+    reward_components: list[dict[str, Any]] = []
+    credited: list[str] = []
+
+    if indicator_from_achievements:
+        if normalized_strategy == "per_achievement":
+            weight_map = weights or {}
+            limit_map = k_limits or {}
+            counts = episode_counts if isinstance(episode_counts, dict) else {}
+            for name in unlocked:
+                try:
+                    limit_val = int(limit_map.get(name, 1))
+                except Exception:
+                    limit_val = 1
+                # limit_val <= 0 implies unlimited rewards
+                unlimited = limit_val <= 0
+                try:
+                    prev_count = int(counts.get(name, 0))
+                except Exception:
+                    prev_count = 0
+                should_credit = unlimited or (prev_count < max(limit_val, 0))
+                if should_credit:
+                    try:
+                        weight_val = float(weight_map.get(name, 1.0))
+                    except Exception:
+                        weight_val = 1.0
+                    base_reward += weight_val
+                    reward_components.append(
+                        {
+                            "achievement": name,
+                            "weight": weight_val,
+                            "count_prior": prev_count,
+                            "count_limit": limit_val,
+                        }
+                    )
+                    credited.append(name)
+                    if episode_counts is not None:
+                        episode_counts[name] = prev_count + 1
+        else:
+            base_reward = 1.0
+            reward_components.append(
+                {
+                    "achievement": "__indicator__",
+                    "weight": 1.0,
+                    "count_prior": 0,
+                    "count_limit": 1,
+                }
+            )
+
+    resource_reward = 0.0
+    resource_components: list[dict[str, Any]] = []
+    inventory_deltas: dict[str, int] = {}
+    achievement_deltas: dict[str, int] = {}
+    if normalized_strategy == "per_achievement":
+        (
+            resource_reward,
+            resource_components,
+            inventory_deltas,
+            achievement_deltas,
+        ) = _compute_resource_reward(prev_inventory, new_inventory, prev_counts, new_counts)
+        if resource_components:
+            reward_components.extend(resource_components)
+        base_reward += resource_reward
+
+    indicator = 1 if base_reward > 0 else 0
+    if indicator == 0 and indicator_from_achievements:
+        indicator = indicator_from_achievements
+    lambda_effective = indicator_lambda if indicator_lambda not in (None, 0) else 1.0
+    reward_value = float(lambda_effective) * float(base_reward)
+
+    stepwise_info = {
+        "decision_index": decision_index,
+        "indicator": indicator,
+        "new_achievements": unlocked,
+        "reward": reward_value,
+        "strategy": normalized_strategy,
+        "base_reward": float(base_reward),
+    }
+    if indicator_from_achievements and not unlocked:
+        stepwise_info["indicator_from_achievements"] = indicator_from_achievements
+    if reward_components:
+        stepwise_info["components"] = reward_components
+    if credited:
+        stepwise_info["credited_achievements"] = credited
+    if resource_reward:
+        stepwise_info["resource_reward"] = float(resource_reward)
+    if inventory_deltas:
+        stepwise_info["inventory_deltas"] = inventory_deltas
+    if achievement_deltas:
+        stepwise_info["achievement_count_deltas"] = achievement_deltas
+
+    decision_sample = {
+        "decision_index": decision_index,
+        "indicator": indicator,
+        "r_i": reward_value,
+        "base": float(base_reward),
+        "strategy": normalized_strategy,
+        "actions": actions_summary,
+    }
+    if reward_components:
+        decision_sample["components"] = reward_components
+    if resource_reward:
+        decision_sample["resource_reward"] = float(resource_reward)
+
+    stats = {
+        "indicator": float(indicator),
+        "reward": reward_value,
+        "new_achievements_count": float(len(unlocked)),
+        "base_reward": float(base_reward),
+        "credited_achievements_count": float(len(credited)),
+    }
+    if resource_reward:
+        stats["resource_reward"] = float(resource_reward)
+    return stepwise_info, decision_sample, stats
+
+
+class RolloutMetrics(BaseModel):
+    episode_returns: list[float]
+    mean_return: float
+    num_steps: int
+    num_episodes: int = 0
+    outcome_score: float | None = None
+    events_score: float | None = None
+    details: dict[str, Any] = Field(default_factory=dict)
+
+
+class RolloutResponse(BaseModel):
+    run_id: str
+    trajectories: list[RolloutTrajectory]
+    branches: dict[str, list[str]] = Field(default_factory=dict)
+    metrics: RolloutMetrics
+    aborted: bool = False
+    ops_executed: int = 0
+    trace: dict[str, Any] | None = None
+    pipeline_metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class RolloutTracingContext:
+    """Helper managing tracing_v3 recording and optional SFT dumps for a rollout."""
+
+    def __init__(
+        self,
+        tracer: SessionTracer | None,
+        request: RolloutRequest,
+        fastapi_request: Request,
+    ) -> None:
+        self.tracer = tracer
+        self.enabled = tracer is not None
+        self.request = request
+        self.fastapi_request = fastapi_request
+        self.run_id = request.run_id
+        self.current_step_id: str | None = None
+        self.current_turn: int | None = None
+        self.lm_calls_summary: list[dict[str, Any]] = []
+        self.decision_rewards: list[dict[str, Any]] = []
+        self.sft_records: list[dict[str, Any]] = []
+        self.latest_system_messages: list[str] = []
+        self.latest_user_messages: list[str] = []
+        self.latest_system_prompt_content: list[Any] = []
+        self.latest_user_prompt_content: list[Any] = []
+        self.trace_format = (
+            getattr(request.record, "trace_format", "compact") or "compact"
+        ).lower()
+        self.return_trace = bool(getattr(request.record, "return_trace", False))
+        print(
+            f"[TRACE_DEBUG] RolloutTracingContext init: trace_format={self.trace_format} return_trace={self.return_trace}",
+            flush=True,
+        )
+        self.sft_output_dir = getattr(fastapi_request.app.state, "sft_output_dir", None)
+        self.session_trace = None
+        self.metadata_updates: dict[str, Any] = {}
+        self.policy_name = request.policy.policy_name or ""
+        self.env_name = request.env.env_name or ""
+        self.metadata_base: dict[str, Any] = {
+            "run_id": self.run_id,
+            "policy_name": self.policy_name,
+            "policy_id": request.policy.policy_id,
+            "env_name": self.env_name,
+            "env_id": request.env.env_id,
+            "seed": request.env.seed,
+            "training_session_id": request.training_session_id,
+            "synth_base_url": request.synth_base_url,
+        }
+
+        # Expose context for downstream calls inside this request lifecycle
+        fastapi_request.state.rollout_tracing = self
+        fastapi_request.state.rollout_run_id = self.run_id
+
+    async def start_session(self) -> None:
+        if not self.enabled or self.tracer is None:
+            print("[TRACE_DEBUG] start_session skipped: tracer disabled", flush=True)
+            return
+        try:
+            await self.tracer.initialize()
+            print("[TRACE_DEBUG] tracer initialized", flush=True)
+        except Exception as exc:
+            logger.debug("TRACING_INIT_FAIL: %s", exc)
+            # Hard fail: tracing requested but cannot initialize
+            raise
+        try:
+            await self.tracer.start_session(
+                session_id=self.run_id, metadata=dict(self.metadata_base)
+            )
+            print(f"[TRACE_DEBUG] start_session succeeded for run_id={self.run_id}", flush=True)
+        except Exception as exc:
+            logger.info("TRACING_START_FAIL: %s", exc)
+            # Hard fail: tracing requested but cannot start session
+            raise
+
+    async def start_decision(self, turn_number: int) -> None:
+        self.current_turn = turn_number
+        self.current_step_id = f"decision_{turn_number}"
+        if not self.enabled or self.tracer is None:
+            return
+        try:
+            await self.tracer.start_timestep(step_id=self.current_step_id, turn_number=turn_number)
+        except Exception as exc:
+            logger.debug("TRACING_STEP_START_FAIL: %s", exc)
+
+    async def end_decision(self) -> None:
+        if not self.enabled or self.tracer is None:
+            return
+        try:
+            await self.tracer.end_timestep(step_id=self.current_step_id)
+        except Exception as exc:
+            logger.debug("TRACING_STEP_END_FAIL: %s", exc)
+        finally:
+            self.current_step_id = None
+
+    def _message_metadata(self) -> dict[str, Any]:
+        return {
+            "turn": self.current_turn,
+            "step_id": self.current_step_id,
+        }
+
+    async def record_policy_prompts(
+        self,
+        system_messages: list[Any],
+        user_messages: list[Any],
+    ) -> None:
+        self.latest_system_messages = [self._prompt_text(entry) for entry in system_messages]
+        self.latest_user_messages = [self._prompt_text(entry) for entry in user_messages]
+        self.latest_system_prompt_content = [
+            self._prompt_content(entry, role="system") for entry in system_messages
+        ]
+        self.latest_user_prompt_content = [
+            self._prompt_content(entry, role="user") for entry in user_messages
+        ]
+        if not self.enabled or self.tracer is None:
+            return
+        for entry in system_messages:
+            try:
+                await self.tracer.record_message(
+                    content=self._prompt_payload(entry, role="system"),
+                    message_type="system",  # Use standard message type
+                    metadata=self._message_metadata(),
+                )
+            except Exception as exc:
+                logger.debug("TRACING_SYSTEM_MSG_FAIL: %s", exc)
+        for entry in user_messages:
+            try:
+                await self.tracer.record_message(
+                    content=self._prompt_payload(entry, role="user"),
+                    message_type="user",  # Use standard message type
+                    metadata=self._message_metadata(),
+                )
+            except Exception as exc:
+                logger.debug("TRACING_USER_MSG_FAIL: %s", exc)
+        
+        # Debug: Check message count
+        if self.tracer and self.tracer._current_trace:
+            msg_count = len(self.tracer._current_trace.markov_blanket_message_history)
+            print(f"[TRACE_DEBUG] After record_policy_prompts: {msg_count} messages", flush=True)
+
+    def _content_to_text(self, content: Any) -> str:
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts: list[str] = []
+            for seg in content:
+                if isinstance(seg, dict):
+                    text_val = seg.get("text") or seg.get("content")
+                    if isinstance(text_val, str):
+                        parts.append(text_val)
+            return "".join(parts)
+        if content is None:
+            return ""
+        return str(content)
+
+    def _prompt_text(self, entry: Any) -> str:
+        if isinstance(entry, dict):
+            text = entry.get("text")
+            if isinstance(text, str):
+                return text
+            content = entry.get("content")
+            return self._content_to_text(content)
+        return self._content_to_text(entry)
+
+    def _prompt_payload(self, entry: Any, *, role: str) -> dict[str, Any]:
+        if isinstance(entry, dict):
+            payload = dict(entry)
+            payload.setdefault("role", role)
+            return payload
+        return {
+            "role": role,
+            "text": self._prompt_text(entry),
+            "content": entry,
+        }
+
+    def _prompt_content(self, entry: Any, *, role: str) -> Any:
+        payload = self._prompt_payload(entry, role=role)
+        return payload.get("content", payload.get("text"))
+
+    def _content_has_image(self, content: Any) -> bool:
+        if isinstance(content, list):
+            return any(
+                isinstance(seg, dict)
+                and seg.get("type") in {"image", "image_url"}
+                for seg in content
+            )
+        if isinstance(content, dict):
+            if content.get("type") in {"image", "image_url"}:
+                return True
+            inner = content.get("content")
+            if isinstance(inner, list):
+                return any(
+                    isinstance(seg, dict)
+                    and seg.get("type") in {"image", "image_url"}
+                    for seg in inner
+                )
+        return False
+
+    def _safe_json(self, payload: Any, limit: int = 4000) -> str:
+        try:
+            text = json.dumps(payload, ensure_ascii=False)
+        except Exception:
+            text = str(payload)
+        if len(text) > limit:
+            return text[:limit] + "…"
+        return text
+
+    async def record_tool_invocation(self, tool_calls: list[dict[str, Any]] | None) -> None:
+        if tool_calls is None:
+            return
+        if self.enabled and self.tracer is not None:
+            try:
+                payload = {
+                    "role": "assistant",
+                    "tool_calls": tool_calls,
+                }
+                await self.tracer.record_message(
+                    content=payload,
+                    message_type="assistant",
+                    metadata={**self._message_metadata(), "is_tool_call": True},
+                )
+                if self.tracer._current_trace:
+                    print(
+                        f"[TRACE_DEBUG] After tool invocation: messages={len(self.tracer._current_trace.markov_blanket_message_history)}",
+                        flush=True,
+                    )
+            except Exception as exc:
+                logger.debug("TRACING_TOOL_MSG_FAIL: %s", exc)
+
+    async def _record_event(self, event: Any) -> int | None:
+        if not self.enabled or self.tracer is None:
+            return None
+        try:
+            return await self.tracer.record_event(event)
+        except Exception as exc:
+            logger.debug("TRACING_EVENT_FAIL: %s", exc)
+            return None
+
+    async def record_llm_call(
+        self,
+        *,
+        inference_request: dict[str, Any],
+        inference_response: dict[str, Any],
+        tool_calls: list[dict[str, Any]] | None,
+        provider: str,
+        model_name: str,
+        started_at: datetime,
+        completed_at: datetime,
+        latency_ms: int | None,
+    ) -> None:
+        usage = inference_response.get("usage") or {}
+        input_tokens = usage.get("input_tokens") or usage.get("prompt_tokens")
+        output_tokens = usage.get("output_tokens") or usage.get("completion_tokens")
+        total_tokens = usage.get("total_tokens")
+        cost_usd = usage.get("cost_usd") or usage.get("cost") or usage.get("total_cost")
+
+        assistant_message = None
+        choices = inference_response.get("choices") or []
+        if choices:
+            assistant_message = choices[0].get("message") or {}
+        assistant_content = (
+            assistant_message.get("content") if isinstance(assistant_message, dict) else None
+        )
+
+        raw_response = self._content_to_text(assistant_content)
+        if not raw_response:
+            raw_response = self._safe_json(inference_response, limit=2000)
+
+        base_response = BaseLMResponse(
+            raw_response=raw_response,
+            tool_calls=assistant_message.get("tool_calls")
+            if isinstance(assistant_message, dict)
+            else None,
+            usage=usage or None,
+            api_type="chat_completions",
+        )
+
+        request_messages = inference_request.get("messages") or []
+        try:
+            temperature = float(inference_request.get("temperature"))
+        except Exception:
+            temperature = 0.0
+
+        call_record = create_llm_call_record_from_response(
+            response=base_response,
+            model_name=model_name,
+            provider=provider,
+            messages=request_messages,
+            temperature=temperature,
+            request_params=inference_request,
+            tools=inference_request.get("tools"),
+            started_at=started_at,
+            completed_at=completed_at,
+            latency_ms=latency_ms,
+        )
+
+        event_metadata = {
+            "policy_id": self.request.policy.policy_id,
+            "turn": self.current_turn,
+            "run_id": self.run_id,
+        }
+
+        event = LMCAISEvent(
+            system_instance_id=f"policy:{self.policy_name or 'unknown'}",
+            time_record=TimeRecord(event_time=completed_at.timestamp()),
+            model_name=model_name,
+            provider=provider,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+            cost_usd=cost_usd,
+            latency_ms=latency_ms,
+            call_records=[call_record],
+            metadata=event_metadata,
+        )
+
+        await self._record_event(event)
+
+        self.lm_calls_summary.append(
+            {
+                "turn": self.current_turn,
+                "model": model_name,
+                "provider": provider,
+                "total_tokens": total_tokens,
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "latency_ms": latency_ms,
+                "tool_calls": len(tool_calls or []),
+            }
+        )
+
+        assistant_structured = assistant_content if assistant_content is not None else ""
+        assistant_text = self._content_to_text(assistant_content)
+
+        if self.enabled and self.tracer is not None:
+            assistant_payload: dict[str, Any] = {
+                "role": "assistant",
+                "content": assistant_structured,
+                "text": assistant_text,
+            }
+            if isinstance(assistant_message, dict):
+                if assistant_message.get("tool_calls"):
+                    assistant_payload["tool_calls"] = assistant_message.get("tool_calls")
+                if assistant_message.get("reasoning"):
+                    assistant_payload["reasoning"] = assistant_message.get("reasoning")
+                if assistant_message.get("thinking"):
+                    assistant_payload["thinking"] = assistant_message.get("thinking")
+            try:
+                await self.tracer.record_message(
+                    content=assistant_payload,
+                    message_type="assistant",
+                    metadata=self._message_metadata(),
+                )
+            except Exception as exc:
+                logger.debug("TRACING_ASSISTANT_MSG_FAIL: %s", exc)
+
+        if self.sft_output_dir is not None:
+            assistant_structured = assistant_content if assistant_content is not None else ""
+            dialogue_structured: list[dict[str, Any]] = []
+            for content in self.latest_system_prompt_content:
+                if content is None:
+                    continue
+                dialogue_structured.append({"role": "system", "content": content})
+            for content in self.latest_user_prompt_content:
+                if content is None:
+                    continue
+                dialogue_structured.append({"role": "user", "content": content})
+            dialogue_text = (
+                [{"role": "system", "content": s} for s in self.latest_system_messages]
+                + [{"role": "user", "content": u} for u in self.latest_user_messages]
+            )
+            user_has_image = any(
+                self._content_has_image(content) for content in self.latest_user_prompt_content
+            )
+            assistant_has_image = self._content_has_image(assistant_structured)
+            record = {
+                "run_id": self.run_id,
+                "turn": self.current_turn,
+                "model": model_name,
+                "provider": provider,
+                "dialogue": dialogue_structured,
+                "dialogue_text": dialogue_text,
+                "assistant": {
+                    "content": assistant_structured,
+                    "content_text": assistant_text,
+                    "tool_calls": assistant_message.get("tool_calls")
+                    if isinstance(assistant_message, dict)
+                    else [],
+                    "has_image": assistant_has_image,
+                },
+                "metadata": {
+                    "user_has_image": user_has_image,
+                    "assistant_has_image": assistant_has_image,
+                    "has_image": user_has_image or assistant_has_image,
+                },
+                "timestamp": datetime.utcnow().isoformat(),
+            }
+            self.sft_records.append(record)
+
+    async def record_environment_event(
+        self,
+        *,
+        env_handle: Any,
+        prev_obs: dict[str, Any] | None,
+        env_response: Any,
+        next_obs: dict[str, Any] | None,
+        metadata: dict[str, Any] | None = None,
+    ) -> int | None:
+        if not self.enabled or self.tracer is None:
+            return None
+
+        try:
+            prev_summary = (
+                _summarize_observation_for_storage(env_handle, prev_obs or {})
+                if prev_obs is not None
+                else None
+            )
+        except Exception:
+            prev_summary = None
+        try:
+            next_summary = (
+                _summarize_observation_for_storage(env_handle, next_obs or {})
+                if next_obs is not None
+                else None
+            )
+        except Exception:
+            next_summary = None
+
+        reward_val = getattr(env_response, "reward", None)
+        try:
+            reward_float = float(reward_val) if reward_val is not None else 0.0
+        except Exception:
+            reward_float = 0.0
+
+        event = EnvironmentEvent(
+            system_instance_id=f"environment:{self.env_name or 'unknown'}",
+            time_record=TimeRecord(event_time=datetime.utcnow().timestamp()),
+            reward=reward_float,
+            terminated=bool(getattr(env_response, "done", False)),
+            truncated=bool(getattr(env_response, "truncated", False)),
+            system_state_before=prev_summary,
+            system_state_after=next_summary,
+            metadata={
+                "turn": self.current_turn,
+                "run_id": self.run_id,
+                **(metadata or {}),
+            },
+        )
+
+        return await self._record_event(event)
+
+    async def record_decision_reward(
+        self,
+        *,
+        event_id: int | None,
+        decision_meta: dict[str, Any] | None,
+    ) -> None:
+        decision_meta = decision_meta or {}
+        ach_delta = int(decision_meta.get("ach_delta", 0))
+        unique_delta = int(decision_meta.get("unique_delta", 0))
+        all_ach = list(decision_meta.get("all") or [])
+        unique_ach = list(decision_meta.get("unique") or [])
+
+        self.decision_rewards.append(
+            {
+                "turn": self.current_turn,
+                "ach_delta": ach_delta,
+                "unique_delta": unique_delta,
+                "achievements": all_ach,
+                "unique_achievements": unique_ach,
+            }
+        )
+
+        if not self.enabled or self.tracer is None or event_id is None:
+            return
+        try:
+            await self.tracer.record_event_reward(
+                event_id=event_id,
+                turn_number=self.current_turn,
+                reward_value=float(ach_delta),
+                reward_type="achievement_delta",
+                annotation={"achievements": all_ach},
+                source="environment",
+            )
+            if unique_delta:
+                await self.tracer.record_event_reward(
+                    event_id=event_id,
+                    turn_number=self.current_turn,
+                    reward_value=float(unique_delta),
+                    reward_type="unique_achievement_delta",
+                    annotation={"achievements": unique_ach},
+                    source="environment",
+                )
+        except Exception as exc:
+            logger.debug("TRACING_REWARD_FAIL: %s", exc)
+
+    def update_metadata(self, **kwargs: Any) -> None:
+        self.metadata_updates.update({k: v for k, v in kwargs.items() if v is not None})
+
+    async def finalize(
+        self,
+        *,
+        total_reward: float,
+        achievement_state: dict[str, bool] | None,
+        total_steps: int,
+    ) -> Any:
+        final_achievements = [key for key, val in (achievement_state or {}).items() if val]
+        self.metadata_updates.setdefault("final_achievements", final_achievements)
+        if self.enabled and self.tracer is not None:
+            try:
+                await self.tracer.record_outcome_reward(
+                    total_reward=int(total_reward),
+                    achievements_count=len(final_achievements),
+                    total_steps=int(total_steps),
+                    reward_metadata=dict(self.metadata_updates),
+                )
+            except Exception as exc:
+                logger.debug("TRACING_OUTCOME_FAIL: %s", exc)
+            try:
+                # Debug: Check message count before end_session
+                if self.tracer._current_trace:
+                    msg_count = len(self.tracer._current_trace.markov_blanket_message_history)
+                    print(f"[TRACE_DEBUG] Before end_session: {msg_count} messages in trace", flush=True)
+
+                self.session_trace = await self.tracer.end_session()
+                
+                # Debug: Check if session was saved
+                if self.session_trace:
+                    print(
+                        f"[TRACE_DEBUG] Session ended successfully, session_id={self.session_trace.session_id}",
+                        flush=True,
+                    )
+                    self.session_trace.metadata.update(self.metadata_updates)
+                    print(
+                        f"[TRACE_DEBUG] session_trace.metadata keys: {list(self.session_trace.metadata.keys())}",
+                        flush=True,
+                    )
+                else:
+                    print("[TRACE_DEBUG] end_session returned None!", flush=True)
+            except Exception as exc:
+                logger.warning(f"TRACING_END_SESSION_FAIL: {exc}", exc_info=True)
+                self.session_trace = None
+            with contextlib.suppress(Exception):
+                await self.tracer.close()
+
+        if self.sft_records and self.sft_output_dir:
+            self.write_sft_records()
+
+        # Clear context from request state to avoid leaks
+        self.fastapi_request.state.rollout_tracing = None
+
+        return self.session_trace
+
+    def write_sft_records(self) -> None:
+        if not self.sft_output_dir or not self.sft_records:
+            return
+        try:
+            path = unique_sft_path(self.sft_output_dir, run_id=self.run_id)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with path.open("w", encoding="utf-8") as fh:
+                for record in self.sft_records:
+                    json.dump(record, fh, ensure_ascii=False)
+                    fh.write("\n")
+            logger.info(f"SFT_WRITTEN: {path}")
+        except Exception as exc:
+            logger.warning(f"SFT_WRITE_FAIL: {exc}")
+        finally:
+            self.sft_records.clear()
+
+    def build_trace_payload(self, session_trace: Any) -> dict[str, Any] | None:
+        if not self.return_trace or session_trace is None:
+            return None
+        
+        # For both "full" and "structured" formats, return the complete session trace
+        # The CLI (synth-ai eval) expects this for proper trace storage
+        if self.trace_format in ("full", "structured"):
+            payload = session_trace.to_dict()
+            payload.setdefault("metadata", {}).update(self.metadata_updates)
+            print(
+                f"[TRACE_DEBUG] build_trace_payload returning structured trace with messages={len(payload.get('markov_blanket_message_history') or [])}",
+                flush=True,
+            )
+            return payload
+        
+        # For "compact" format, return only summary stats
+        metadata = dict(session_trace.metadata)
+        metadata.update(self.metadata_updates)
+        return {
+            "session_id": session_trace.session_id,
+            "created_at": session_trace.created_at.isoformat(),
+            "metadata": metadata,
+            "events_count": len(session_trace.event_history),
+            "messages_count": len(session_trace.markov_blanket_message_history),
+            "lm_calls": self.lm_calls_summary,
+            "decision_rewards": self.decision_rewards,
+        }
+
+
+def _summarize_observation_for_storage(
+    env_handle: Any, observation: dict[str, Any]
+) -> dict[str, Any]:
+    """Return a compact dict for trajectory storage instead of the raw observation.
+
+    - For Crafter, use the same summary used for the policy user prompt
+    - For others, keep a minimal subset or plain text preview
+    """
+    # Try Crafter-specific formatter
+    crafter_wrapper = None
+    with contextlib.suppress(Exception):
+        from .envs.crafter.environment import (
+            CrafterEnvironmentWrapper as _CrafterWrapper,  # type: ignore
+        )
+
+        crafter_wrapper = _CrafterWrapper  # type: ignore[assignment]
+
+    if crafter_wrapper is not None and isinstance(
+        getattr(env_handle, "env", None), crafter_wrapper
+    ):
+        with contextlib.suppress(Exception):
+            from .envs.crafter.shared import format_observation as _fmt  # type: ignore
+
+            text = _fmt(observation or {})
+            return {"text": text}
+
+    # Generic fallback: extract a few small fields if present; avoid huge arrays
+    with contextlib.suppress(Exception):
+        inv = observation.get("inventory") if isinstance(observation, dict) else None
+        ach = observation.get("achievements_status") if isinstance(observation, dict) else None
+        pos = observation.get("player_position") if isinstance(observation, dict) else None
+        health = None
+        if isinstance(inv, dict):
+            health = inv.get("health")
+        summary = {
+            "position": pos,
+            "health": health,
+            "inventory_keys": sorted(k for k, v in (inv or {}).items() if v)[:10]
+            if isinstance(inv, dict)
+            else None,
+            "achievements_unlocked": sorted(k for k, v in (ach or {}).items() if v)[:10]
+            if isinstance(ach, dict)
+            else None,
+        }
+        return {"text": json.dumps(summary, ensure_ascii=False)}
+
+    # Last resort: plain string preview
+    try:
+        return {"text": str(observation)[:10000]}
+    except Exception:
+        return {"text": ""}
+
+
+class RunAbortRequest(BaseModel):
+    run_id: str
+
+
+class RunAbortResponse(BaseModel):
+    ok: bool
+    run_id: str
+
+
+class RunStatusResponse(BaseModel):
+    run_id: str
+    status: str
+    started_at: datetime
+    finished_at: datetime | None = None
+
+
+@router.post("/rollout", response_model=RolloutResponse)
+async def execute_rollout(
+    request: RolloutRequest,
+    req: Request,
+) -> RolloutResponse:
+    """Execute a rollout with coordinated environment and policy steps."""
+    logger.info("ROLLOUT: mode = %s", request.mode)
+    
+    # Emit rollout identifier early for correlation
+    with contextlib.suppress(Exception):
+        _rid = getattr(request, "run_id", None)
+        _pol = getattr(request.policy, "policy_name", None) or getattr(request.policy, "policy_id", None)
+        _env = getattr(request.env, "env_name", None) or getattr(request.env, "env_id", None)
+        logger.info("ROLLOUT_BEGIN: run_id=%s policy=%s env=%s mode=%s", _rid, _pol, _env, request.mode)
+        print(f"[rollout] begin run_id={_rid} policy={_pol} env={_env}", flush=True)
+    # Enforce per-episode step cap via env-specific parameters; default to 20 if omitted
+    try:
+        _env_params = {}
+        if isinstance(request.env, RolloutEnvSpec) and isinstance(request.env.config, dict):
+            _env_params = dict(request.env.config.get("env_params") or {})
+        max_steps_per_episode = int(_env_params.get("max_steps_per_episode") or 20)
+        assert max_steps_per_episode > 0, "max_steps_per_episode must be a positive integer"
+    except Exception as _mse:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail={
+                "error": "invalid_env_params",
+                "message": f"Invalid or missing env_params.max_steps_per_episode: {_mse}",
+            },
+        ) from _mse
+    # Truncate incoming ops to the enforced cap (each step is [agent, env])
+    ops_seq: list[str] = list(request.ops or [])
+    allowed_ops = max(0, int(max_steps_per_episode) * 2)
+    if len(ops_seq) > allowed_ops:
+        with contextlib.suppress(Exception):
+            logger.info(
+                "ROLL_OUT: truncating ops to cap: requested_ops=%s allowed_ops=%s",
+                str(len(ops_seq)),
+                str(allowed_ops),
+            )
+        ops_seq = ops_seq[:allowed_ops]
+    # Simple API key auth for inbound rollout
+    header_key = req.headers.get("x-api-key")
+    env_key = os.getenv("ENVIRONMENT_API_KEY")
+    dev_key = os.getenv("DEV_ENVIRONMENT_API_KEY")
+    # Accept either ENVIRONMENT_API_KEY or DEV_ENVIRONMENT_API_KEY
+    expected_keys = [k for k in (env_key, dev_key) if k]
+    if not expected_keys:
+        missing = []
+        if not env_key:
+            missing.append("ENVIRONMENT_API_KEY")
+        if not dev_key:
+            missing.append("DEV_ENVIRONMENT_API_KEY")
+        msg = f"Auth not configured: missing {', '.join(missing)} in task service environment"
+        logger.error(msg)
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=msg)
+    if not header_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key: X-API-Key header not provided",
+        )
+    if header_key not in expected_keys:
+        # Do not leak secrets; include short prefix for diagnostics
+        exp_src = env_key if env_key else (dev_key or "")
+        exp_prefix = (exp_src[:7] + "…") if len(exp_src) >= 7 else "set"
+        got_prefix = (header_key[:7] + "…") if len(header_key) >= 7 else "set"
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid API key: header does not match expected (got={got_prefix}, expected_prefix={exp_prefix})",
+        )
+
+    # Log contextual fields for traceability
+    if request.training_session_id:
+        logger.info(f"ROLL_OUT: training_session_id={request.training_session_id}")
+    if request.synth_base_url:
+        logger.info(f"ROLL_OUT: synth_base_url={request.synth_base_url}")
+
+    # Log masked OpenAI API key presence for diagnostics
+    with contextlib.suppress(Exception):
+        _oa = os.getenv("OPENAI_API_KEY")
+        if _oa:
+            _pref = (_oa[:6] + "…") if len(_oa) >= 6 else "set"
+            logger.info(f"ROLL_OUT: OPENAI_API_KEY present (prefix={_pref})")
+        else:
+            logger.warning("ROLL_OUT: OPENAI_API_KEY missing")
+
+    # Make synth_base_url available for outbound calls in this app
+    with contextlib.suppress(Exception):
+        task_app = req.app.state.task_app
+        if request.synth_base_url:
+            task_app.synth_base_url = request.synth_base_url
+
+    tracer_factory = getattr(req.app.state, "session_tracer_factory", None)
+    tracer_instance: SessionTracer | None = None
+    if callable(tracer_factory):
+        try:
+            inst = tracer_factory()
+            tracer_instance = inst if isinstance(inst, SessionTracer) else None
+        except Exception as exc:
+            logger.debug(f"TRACER_FACTORY_FAIL: {exc}")
+    tracing_context = RolloutTracingContext(tracer_instance, request, req)
+    await tracing_context.start_session()
+
+    # Register run
+    registry.register_run(request.run_id)
+
+    # Track resources created during this rollout so we can guarantee cleanup
+    created_env_id: str | None = None
+    created_policy_id: str | None = None
+    env_seed_used: int | None = None
+    trajectory_steps: list[RolloutStep] = []
+    decision_samples: list[dict[str, Any]] = []
+    pending_tool_calls: Any = None
+    current_obs: Any = {}
+    total_reward: float = 0.0
+    ops_executed = 0
+    last_agent_response_ts: float | None = None
+    last_policy_meta: dict[str, Any] | None = None
+    last_env_step_ms: float | None = None
+    last_env_step_completed_ts: float | None = None
+    decision_open = False
+    finalized = False
+    prev_achievements: dict[str, bool] = {}
+    session_trace = None
+    step_rewards_active = False
+
+    try:
+        # Initialize deterministic seed early for the entire rollout
+        seed_value: int | None = None
+        try:
+            if request.env and request.env.seed is not None:
+                seed_value = int(request.env.seed)
+            else:
+                # Derive a stable seed from run_id
+                import hashlib as _hashlib  # local import to avoid global deps
+
+                _digest = _hashlib.sha256(request.run_id.encode("utf-8")).hexdigest()
+                # Use lower 32 bits to fit common RNG ranges
+                seed_value = int(_digest[:8], 16)
+        except Exception:
+            # Fallback to time-based seed if anything goes wrong
+            try:
+                seed_value = int((_time.time_ns() // 1_000_000) % (2**31 - 1))
+            except Exception:
+                seed_value = 42
+
+        _seed_info = _set_global_seed(int(seed_value))
+        with contextlib.suppress(Exception):
+            logger.info(
+                "ROLL_OUT: RNG seeded seed=%s libs=%s",
+                str(_seed_info.get("seed")),
+                ",".join(_seed_info.get("libs", [])),
+            )
+        # Resolve or create environment
+        if request.env.env_id:
+            env_handle = registry.get_env(request.env.env_id)
+            if not env_handle:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Environment {request.env.env_id} not found",
+                )
+            env_id = request.env.env_id
+        else:
+            # Create new environment
+            from .environment_routes import EnvCreateRequest, create_environment
+
+            if not request.env.env_name:
+                raise ValueError("FATAL: env_name is required - NO FALLBACKS!")
+
+            # Propagate training_session_id via env config for downstream usage
+            _env_config = dict(request.env.config or {})
+            if request.training_session_id is not None:
+                _env_config.setdefault("training_session_id", request.training_session_id)
+            env_response = await create_environment(
+                EnvCreateRequest(
+                    env_name=request.env.env_name,
+                    config=_env_config,
+                    seed=request.env.seed,
+                    rl_run_id=request.run_id,
+                )
+            )
+            env_id = env_response.env_id
+            env_handle = registry.get_env(env_id)
+            created_env_id = env_id
+
+        tracing_context.update_metadata(env_id=env_id)
+
+        # Resolve or create policy
+        if request.policy.policy_id:
+            policy_handle = registry.get_policy(request.policy.policy_id)
+            if not policy_handle:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Policy {request.policy.policy_id} not found",
+                )
+            policy_id = request.policy.policy_id
+        else:
+            # Create new policy
+            from .policy_routes import PolicyCreateRequest, create_policy
+
+            if not request.policy.policy_name:
+                raise ValueError("FATAL: policy_name is required - NO FALLBACKS!")
+
+            # Propagate training_session_id and synth_base_url via policy config
+            _policy_config = dict(request.policy.config or {})
+            if request.training_session_id is not None:
+                _policy_config.setdefault("training_session_id", request.training_session_id)
+            if request.synth_base_url is not None:
+                _policy_config.setdefault("synth_base_url", request.synth_base_url)
+            policy_response = await create_policy(
+                PolicyCreateRequest(
+                    policy_name=request.policy.policy_name,
+                    config=_policy_config,
+                    rl_run_id=request.run_id,
+                    bound_env_id=env_id,
+                    mode=request.mode,  # Pass through mode for URL transformation control
+                ),
+                req,
+            )
+            policy_id = policy_response.policy_id
+            policy_handle = registry.get_policy(policy_id)
+            created_policy_id = policy_id
+
+        tracing_context.update_metadata(policy_id=policy_id)
+
+        # Bind policy to environment if not already bound
+        if policy_handle and not policy_handle.bound_env_id:
+            policy_handle.bound_env_id = env_id
+
+        # Record seed bound to environment for end-of-rollout verification/logging
+        try:
+            env_seed_used = int(getattr(env_handle, "seed", 0) or 0)
+        except Exception:
+            env_seed_used = None
+        tracing_context.update_metadata(env_seed=env_seed_used)
+        # Initialize trajectory
+        trajectory_steps = []
+        pending_tool_calls = None
+        current_obs = env_handle.last_observation
+        total_reward = 0.0
+        ops_executed = 0
+        last_agent_response_ts = None
+        last_policy_meta = None
+        last_env_step_ms = None
+        last_env_step_completed_ts = None
+
+        # Stepwise reward configuration (Crafter shaping; gate on explicit enable)
+        step_rewards_cfg_raw: dict[str, Any] = {}
+        try:
+            if isinstance(request.policy.config, dict):
+                step_rewards_cfg_raw = dict(request.policy.config.get("step_rewards") or {})
+        except Exception:
+            step_rewards_cfg_raw = {}
+        if not step_rewards_cfg_raw:
+            try:
+                if isinstance(request.env.config, dict):
+                    step_rewards_cfg_raw = dict(request.env.config.get("step_rewards") or {})
+            except Exception:
+                step_rewards_cfg_raw = {}
+
+        step_rewards_enabled = bool(step_rewards_cfg_raw.get("enabled", False))
+        step_rewards_mode = str(step_rewards_cfg_raw.get("mode") or "off").lower()
+        step_rewards_strategy = _normalize_step_strategy(step_rewards_cfg_raw.get("strategy"))
+        step_rewards_weights = _coerce_weights(step_rewards_cfg_raw.get("weights"))
+        step_rewards_k_limits = _coerce_k_limits(step_rewards_cfg_raw.get("k_limits"))
+        try:
+            step_rewards_indicator_lambda = float(
+                step_rewards_cfg_raw.get("indicator_lambda") or 0.0
+            )
+        except Exception:
+            step_rewards_indicator_lambda = 0.0
+        try:
+            step_rewards_beta = float(step_rewards_cfg_raw.get("step_beta") or 0.0)
+        except Exception:
+            step_rewards_beta = 0.0
+        step_rewards_active = step_rewards_enabled and step_rewards_mode == "decision_stepwise"
+
+        def _extract_achievements(obs: Any) -> dict[str, bool]:
+            if not isinstance(obs, dict):
+                return {}
+            ach = obs.get("achievements_status")
+            if isinstance(ach, dict):
+                return {str(k): bool(v) for k, v in ach.items()}
+            return {}
+
+        def _extract_inventory(obs: Any) -> dict[str, int]:
+            if not isinstance(obs, dict):
+                return {}
+            inv = obs.get("inventory")
+            if not isinstance(inv, dict):
+                return {}
+            cleaned: dict[str, int] = {}
+            for key, value in inv.items():
+                coerced = _coerce_int_value(value)
+                if coerced is None:
+                    continue
+                cleaned[str(key)] = coerced
+            return cleaned
+
+        def _extract_achievement_counts(obs: Any) -> dict[str, int]:
+            if not isinstance(obs, dict):
+                return {}
+            counts = obs.get("achievements_counts")
+            if not isinstance(counts, dict):
+                return {}
+            cleaned: dict[str, int] = {}
+            for key, value in counts.items():
+                coerced = _coerce_int_value(value)
+                if coerced is None:
+                    continue
+                cleaned[str(key)] = coerced
+            return cleaned
+
+        def _summarize_tool_calls(tool_calls: Any) -> list[dict[str, Any]]:
+            if not tool_calls:
+                return []
+            try:
+                items = (
+                    tool_calls
+                    if isinstance(tool_calls, list)
+                    else list(tool_calls)  # tolerates tuples or pydantic lists
+                )
+            except Exception:
+                return []
+            summary: list[dict[str, Any]] = []
+            for tc in items:
+                tool_name = None
+                args: Any = {}
+                if isinstance(tc, dict):
+                    tool_name = tc.get("tool") or tc.get("tool_name") or tc.get("name")
+                    raw_args = tc.get("arguments") or tc.get("args") or {}
+                else:
+                    tool_name = getattr(tc, "tool", None) or getattr(tc, "tool_name", None)
+                    raw_args = getattr(tc, "arguments", None) or getattr(tc, "args", None) or {}
+                args = raw_args
+                if isinstance(raw_args, str):
+                    try:
+                        args = json.loads(raw_args)
+                    except Exception:
+                        args = raw_args
+                summary.append({"tool": tool_name, "args": args})
+            return summary
+
+        decision_samples: list[dict[str, Any]] = []
+        decision_index = 0
+        decision_open = False
+        session_trace = None
+        finalized = False
+        prev_achievements = _extract_achievements(current_obs)
+        prev_inventory_state = _extract_inventory(current_obs)
+        prev_achievement_counts_state = _extract_achievement_counts(current_obs)
+        # Track episode-level achievements that have been seen as true at any point so far
+        episode_seen_achievements: set[str] = {
+            k for k, v in (prev_achievements or {}).items() if bool(v)
+        }
+        episode_achievement_counts: dict[str, int] = {}
+        stepwise_indicator_sum = 0.0
+        stepwise_reward_sum = 0.0
+        stepwise_resource_reward_sum = 0.0
+        stepwise_new_achievements_total = 0
+        final_achievement_count = sum(1 for v in prev_achievements.values() if v)
+
+        # Execute ops sequence (capped by env_params.max_steps_per_episode)
+        for op_idx, op in enumerate(ops_seq):
+            # Check for abort
+            if registry.is_run_aborted(request.run_id):
+                logger.info(f"Run {request.run_id} aborted at op {op_idx}")
+                break
+
+            # Check safety limits
+            if ops_executed >= request.safety.max_ops:
+                logger.warning(f"Reached max_ops limit ({request.safety.max_ops})")
+                break
+
+            if op == "agent":
+                # Policy step
+                from .policy_routes import PolicyStepRequest, step_policy
+
+                if not decision_open:
+                    await tracing_context.start_decision(decision_index)
+                    decision_open = True
+
+                agent_request_start = _time.perf_counter()
+                if last_agent_response_ts is not None and last_policy_meta is not None:
+                    with contextlib.suppress(Exception):
+                        timing_prev = last_policy_meta.setdefault("timing", {})
+                        decision_ms = max(
+                            0.0,
+                            (agent_request_start - float(last_agent_response_ts)) * 1000.0,
+                        )
+                        # Update timing on prior policy meta (kept by previous env step)
+                        timing_prev["decision_ms"] = decision_ms
+                        if last_env_step_ms is not None:
+                            timing_prev["env_step_ms"] = float(last_env_step_ms)
+                            timing_prev["overhead_ms"] = max(
+                                0.0, decision_ms - float(last_env_step_ms)
+                            )
+                        else:
+                            timing_prev.setdefault("overhead_ms", 0.0)
+                        timing_prev["decision_ready_s"] = agent_request_start
+                        # Also backfill the last appended trajectory step so the trainer
+                        # can always see decision_ms without relying on shared dict refs.
+                        if trajectory_steps:
+                            with contextlib.suppress(Exception):
+                                _last = trajectory_steps[-1]
+                                _info = dict(_last.info or {})
+                                _meta = dict(_info.get("meta") or {})
+                                _timing = dict(_meta.get("timing") or {})
+                                _timing["decision_ms"] = decision_ms
+                                if last_env_step_ms is not None:
+                                    _timing.setdefault("env_step_ms", float(last_env_step_ms))
+                                    _timing.setdefault(
+                                        "overhead_ms",
+                                        max(0.0, decision_ms - float(last_env_step_ms)),
+                                    )
+                                else:
+                                    _timing.setdefault("overhead_ms", 0.0)
+                                _meta["timing"] = _timing
+                                _info["meta"] = _meta
+                                _last.info = _info
+                last_env_step_ms = None
+                last_env_step_completed_ts = None
+
+                # Build metadata for policy (carry previous tool_calls and env result)
+                metadata = {}
+                if pending_tool_calls:
+                    metadata["prev_tool_calls"] = pending_tool_calls
+                if len(trajectory_steps) > 0:
+                    last_step = trajectory_steps[-1]
+                    # Prefer the last executed tool calls to seed history
+                    if last_step.tool_calls:
+                        metadata["prev_tool_calls"] = last_step.tool_calls
+                    # Provide a compact env result snapshot
+                    metadata["prev_env_result"] = {
+                        "observation": last_step.obs,
+                        "reward": last_step.reward,
+                        "done": last_step.done,
+                        "truncated": last_step.truncated,
+                        "info": last_step.info,
+                    }
+
+                # Log compact metadata summary to confirm history threading
+                with contextlib.suppress(Exception):
+                    _prev_calls = metadata.get("prev_tool_calls")
+                    _count = len(_prev_calls) if isinstance(_prev_calls, list) else 0
+                    _first_guess = None
+                    if _count > 0 and isinstance(_prev_calls[0], dict):
+                        _args = _prev_calls[0].get("arguments", None)
+                        if isinstance(_args, str):
+                            import json as _json
+                            with contextlib.suppress(Exception):
+                                _args = _json.loads(_args)
+                        if not isinstance(_args, dict):
+                            _args = {}
+                        _first_guess = _args.get("guess") or _args.get("word")
+                    logger.info(
+                        "POLICY_METADATA: prev_tool_calls=%d first_guess=%r has_prev_env_result=%s",
+                        _count,
+                        _first_guess,
+                        str("prev_env_result" in metadata),
+                    )
+
+                try:
+                    policy_response = await step_policy(
+                        PolicyStepRequest(
+                            policy_id=policy_id,
+                            observation=current_obs,
+                            metadata=metadata,
+                        ),
+                        req,
+                    )
+                except Exception as _pe:
+                    # Hard fail the rollout on policy step error (e.g., inference auth 4xx)
+                    logger.error(
+                        "POLICY_STEP_HARD_FAIL: run_id=%s op_idx=%s err=%s",
+                        request.run_id,
+                        str(op_idx),
+                        str(_pe),
+                    )
+                    raise HTTPException(status_code=500, detail=f"policy_step_failed: {str(_pe)}")
+
+                agent_response_ts = _time.perf_counter()
+                if isinstance(policy_response.meta, dict):
+                    with contextlib.suppress(Exception):
+                        timing_cur = policy_response.meta.setdefault("timing", {})
+                        timing_cur["agent_request_start_s"] = agent_request_start
+                        timing_cur["agent_response_s"] = agent_response_ts
+                        if "inference_ms" in policy_response.meta:
+                            with contextlib.suppress(Exception):
+                                timing_cur.setdefault(
+                                    "inference_ms",
+                                    float(policy_response.meta["inference_ms"]),
+                                )
+                                timing_cur.setdefault(
+                                    "inference_s",
+                                    float(policy_response.meta["inference_ms"]) / 1000.0,
+                                )
+                    last_policy_meta = policy_response.meta
+                else:
+                    last_policy_meta = None
+                last_agent_response_ts = agent_response_ts
+
+                # Diagnostic: summarize policy step target and tool calls
+                try:
+                    model_name = None
+                    target_url = None
+                    if isinstance(policy_response.meta, dict):
+                        req_body = policy_response.meta.get("inference_request") or {}
+                        model_name = req_body.get("model")
+                        target_url = policy_response.meta.get("inference_url")
+                    _tc = policy_response.tool_calls or []
+                    print(
+                        {
+                            "rollout.policy_step": True,
+                            "run_id": request.run_id,
+                            "model": model_name,
+                            "inference_url": target_url,
+                            "tool_calls_count": len(_tc) if isinstance(_tc, list) else 0,
+                        },
+                        flush=True,
+                    )
+                except Exception:
+                    pass
+
+                pending_tool_calls = policy_response.tool_calls
+                # Log summarized agent tool calls
+                with contextlib.suppress(Exception):
+                    _tc = pending_tool_calls or []
+                    _summary = []
+                    for _item in (_tc if isinstance(_tc, list) else []):
+                        try:
+                            if isinstance(_item, dict):
+                                _tool = _item.get("tool")
+                                _args = _item.get("args")
+                                _keys = list(_args.keys()) if isinstance(_args, dict) else []
+                                _summary.append({"tool": _tool, "args_keys": _keys})
+                        except Exception:
+                            continue
+                    _rid = getattr(request, "run_id", None)
+                    logger.info("AGENT_TOOL_CALLS: run_id=%s count=%d summary=%s", _rid, len(_tc), _summary)
+                    print(f"[rollout] agent tool_calls run_id={_rid} count={len(_tc)} summary={_summary}", flush=True)
+                await tracing_context.record_tool_invocation(pending_tool_calls)
+                ops_executed += 1
+
+            elif op == "env":
+                if not pending_tool_calls:
+                    # Instead of failing, inject a no-op action to keep the rollout going
+                    with contextlib.suppress(Exception):
+                        logger.warning(
+                            "POLICY_STEP_NOOP: missing tool_calls; injecting noop action run_id=%s op_idx=%s",
+                            request.run_id,
+                            str(op_idx),
+                        )
+                    # Create a noop tool call in the format expected by the environment
+                    pending_tool_calls = [
+                        {
+                            "id": f"noop_{op_idx}",
+                            "tool": "interact",
+                            "arguments": {"action": "noop"},
+                        }
+                    ]
+
+                # Environment step
+                from .environment_routes import EnvStepRequest, step_environment
+
+                env_step_error: Exception | None = None
+                env_response = None
+                env_step_start = _time.perf_counter()
+                try:
+                    env_response = await step_environment(
+                        EnvStepRequest(
+                            env_id=env_id,
+                            tool_calls=pending_tool_calls,
+                        )
+                    )
+                except Exception as _ee:
+                    env_step_error = _ee
+                env_step_end = _time.perf_counter()
+                env_step_duration_ms = (env_step_end - env_step_start) * 1000.0
+                last_env_step_ms = env_step_duration_ms
+                last_env_step_completed_ts = env_step_end
+                if last_policy_meta is not None:
+                    with contextlib.suppress(Exception):
+                        timing_env = last_policy_meta.setdefault("timing", {})
+                        timing_env["env_step_ms"] = env_step_duration_ms
+                        timing_env["env_step_end_s"] = env_step_end
+
+                if env_step_error is not None:
+                    with contextlib.suppress(Exception):
+                        logger.warning(
+                            "ENV_STEP_FAIL: failing rollout run_id=%s op_idx=%s err=%s",
+                            request.run_id,
+                            str(op_idx),
+                            str(env_step_error),
+                        )
+                    raise HTTPException(
+                        status_code=500,
+                        detail=f"env_step_failed: {str(env_step_error)}",
+                    )
+
+                # Reaching here means env step succeeded
+                assert env_response is not None
+
+                # Record step, including policy meta if present for timing/tokens observability
+                _info = env_response.info if isinstance(env_response.info, dict) else {}
+                # Attach policy meta from the immediately preceding agent step
+                with contextlib.suppress(Exception):
+                    prev_meta = {}
+                    if "policy_response" in locals() and isinstance(policy_response.meta, dict):  # type: ignore[name-defined]
+                        prev_meta = policy_response.meta
+                    if prev_meta:
+                        _info = dict(_info)
+                        _info["meta"] = prev_meta
+
+                event_metadata = {
+                    "op_index": op_idx,
+                }
+                event_id = await tracing_context.record_environment_event(
+                    env_handle=env_handle,
+                    prev_obs=current_obs,
+                    env_response=env_response,
+                    next_obs=getattr(env_response, "observation", None),
+                    metadata=event_metadata,
+                )
+
+                decision_index += 1
+                next_obs = env_response.observation
+                new_achievement_state = _extract_achievements(next_obs)
+                new_inventory_state = _extract_inventory(next_obs)
+                new_achievement_counts_state = _extract_achievement_counts(next_obs)
+                final_achievement_count = sum(
+                    1 for _, unlocked in new_achievement_state.items() if unlocked
+                )
+                indicator_val = 0
+                reward_stepwise = 0.0
+                decision_rewards_meta: dict[str, Any] | None = None
+                decision_record = None
+                _info = {} if not isinstance(_info, dict) else dict(_info)
+                if step_rewards_active:
+                    decision_actions = _summarize_tool_calls(pending_tool_calls)
+                    stepwise_info, decision_record, stats = compute_stepwise_reward(
+                        prev_achievements or {},
+                        new_achievement_state,
+                        decision_index,
+                        decision_actions,
+                        step_rewards_indicator_lambda,
+                        strategy=step_rewards_strategy,
+                        weights=step_rewards_weights,
+                        k_limits=step_rewards_k_limits,
+                        episode_counts=episode_achievement_counts,
+                        prev_inventory=prev_inventory_state,
+                        new_inventory=new_inventory_state,
+                        prev_counts=prev_achievement_counts_state,
+                        new_counts=new_achievement_counts_state,
+                    )
+                    indicator_val = int(stats.get("indicator", 0.0))
+                    reward_stepwise = float(stats.get("reward", 0.0))
+                    stepwise_indicator_sum += float(stats.get("indicator", 0.0))
+                    stepwise_reward_sum += reward_stepwise
+                    stepwise_new_achievements_total += int(stats.get("new_achievements_count", 0.0))
+                    with contextlib.suppress(Exception):
+                        resource_component = stats.get("resource_reward")
+                        if resource_component is not None:
+                            stepwise_resource_reward_sum += float(resource_component)
+                    _info["stepwise"] = stepwise_info
+                    # Compute decision-level rewards (absolute vs unique) and attach to metadata
+                    with contextlib.suppress(Exception):
+                        turned_true = set(stepwise_info.get("new_achievements") or [])
+                        seen_before = set(episode_seen_achievements)
+                        new_unique = sorted(turned_true - seen_before)
+                        ach_delta = int(len(turned_true))
+                        unique_delta = int(len(new_unique))
+                        # Prepare stable lists for logging/metadata
+                        all_list = sorted(turned_true)
+                        # Ensure nested meta exists
+                        meta_block = (
+                            _info.get("meta") if isinstance(_info.get("meta"), dict) else {}
+                        )
+                        decision_rewards = {
+                            "turn": int(decision_index),
+                            "ach_delta": ach_delta,
+                            "unique_delta": unique_delta,
+                            "all": all_list,
+                            "unique": new_unique,
+                        }
+                    decision_rewards_meta = decision_rewards
+                    meta_block["decision_rewards"] = decision_rewards
+                    _info["meta"] = meta_block
+                    # Update episode-level seen set after attributing uniqueness to this decision
+                    episode_seen_achievements.update(turned_true)
+                if decision_record is not None:
+                    decision_samples.append(decision_record)
+                prev_achievements = new_achievement_state
+                prev_inventory_state = new_inventory_state
+                prev_achievement_counts_state = new_achievement_counts_state
+
+                await tracing_context.record_decision_reward(
+                    event_id=event_id,
+                    decision_meta=decision_rewards_meta,
+                )
+
+                step = RolloutStep(
+                    obs=_summarize_observation_for_storage(env_handle, current_obs),
+                    tool_calls=pending_tool_calls,
+                    reward=env_response.reward,
+                    done=env_response.done,
+                    truncated=env_response.truncated,
+                    info=_info,
+                )
+                # Log summarized env application of tool calls and immediate reward/done
+                with contextlib.suppress(Exception):
+                    _tc = pending_tool_calls or []
+                    _summary = []
+                    for _item in (_tc if isinstance(_tc, list) else []):
+                        try:
+                            if isinstance(_item, dict):
+                                _tool = _item.get("tool")
+                                _args = _item.get("args")
+                                _keys = list(_args.keys()) if isinstance(_args, dict) else []
+                                _summary.append({"tool": _tool, "args_keys": _keys})
+                        except Exception:
+                            continue
+                    _rid = getattr(request, "run_id", None)
+                    logger.info(
+                        "ENV_APPLY: run_id=%s tool_calls=%d reward=%s done=%s summary=%s",
+                        _rid,
+                        len(_tc),
+                        str(env_response.reward),
+                        str(env_response.done),
+                        _summary,
+                    )
+                    print(
+                        f"[rollout] env apply run_id={_rid} tool_calls={len(_tc)} reward={env_response.reward} done={env_response.done} summary={_summary}",
+                        flush=True,
+                    )
+                trajectory_steps.append(step)
+
+                if env_response.reward is not None:
+                    total_reward += env_response.reward
+
+                # Update state
+                current_obs = next_obs
+                pending_tool_calls = None
+                ops_executed += 1
+
+                # Handle episode end
+                if env_response.done:
+                    if request.on_done == "reset":
+                        # Reset environment
+                        from .environment_routes import (
+                            EnvResetRequest,
+                            reset_environment,
+                        )
+
+                        reset_response = await reset_environment(EnvResetRequest(env_id=env_id))
+                        current_obs = reset_response.observation
+                        prev_achievements = _extract_achievements(current_obs)
+                        episode_seen_achievements = {
+                            k for k, v in (prev_achievements or {}).items() if bool(v)
+                        }
+                        episode_achievement_counts.clear()
+                    elif request.on_done == "terminate":
+                        break
+
+                if decision_open:
+                    await tracing_context.end_decision()
+                    decision_open = False
+
+            else:
+                logger.warning(f"Unknown op: {op}")
+
+        if (
+            last_policy_meta is not None
+            and last_agent_response_ts is not None
+            and "timing" in last_policy_meta
+            and isinstance(last_policy_meta["timing"], dict)
+            and "decision_ms" not in last_policy_meta["timing"]
+        ):
+            with contextlib.suppress(Exception):
+                final_now = last_env_step_completed_ts or _time.perf_counter()
+                final_decision_ms = max(0.0, (final_now - float(last_agent_response_ts)) * 1000.0)
+                timing_final = last_policy_meta.setdefault("timing", {})
+                timing_final["decision_ms"] = final_decision_ms
+                if last_env_step_ms is not None:
+                    timing_final.setdefault("env_step_ms", float(last_env_step_ms))
+                    timing_final.setdefault(
+                        "overhead_ms",
+                        max(0.0, final_decision_ms - float(last_env_step_ms)),
+                    )
+                else:
+                    timing_final.setdefault("overhead_ms", 0.0)
+
+        # Build trajectory
+        # Extract inference_url from policy config (REQUIRED for trace correlation)
+        # The trainer sets this in policy config with ?cid=... parameter
+        inference_url = None
+        
+        # Try policy config from request first (most reliable source)
+        try:
+            policy_config_snapshot = (
+                request.policy.config if isinstance(request.policy.config, dict) else {}
+            )
+            inference_url = policy_config_snapshot.get("inference_url")
+            if inference_url:
+                logger.info(
+                    "ROLLOUT_TRAJECTORY: extracted inference_url from request.policy.config run_id=%s url=%s",
+                    request.run_id,
+                    inference_url,
+                )
+        except Exception as exc:
+            logger.warning(
+                "ROLLOUT_TRAJECTORY: failed to get inference_url from request.policy.config run_id=%s: %s",
+                request.run_id,
+                exc,
+            )
+        
+        # Fallback: Try policy handle snapshot (if request.policy.config failed)
+        if not inference_url and policy_handle is not None:
+            try:
+                policy_snapshot = policy_handle.snapshot()
+                inference_url = policy_snapshot.get("config", {}).get("inference_url")
+                if inference_url:
+                    logger.info(
+                        "ROLLOUT_TRAJECTORY: extracted inference_url from policy_handle.snapshot run_id=%s url=%s",
+                        request.run_id,
+                        inference_url,
+                    )
+            except Exception as exc:
+                logger.warning(
+                    "ROLLOUT_TRAJECTORY: failed to snapshot policy for run_id=%s policy_id=%s: %s",
+                    request.run_id,
+                    policy_id,
+                    exc,
+                )
+        
+        # ASSERTION: inference_url MUST be present (required by RolloutTrajectory schema)
+        if not inference_url:
+            raise ValueError(
+                f"FATAL: inference_url is required but not found!\n"
+                f"\n"
+                f"run_id: {request.run_id}\n"
+                f"policy_id: {policy_id}\n"
+                f"policy_config_keys: {list(policy_config_snapshot.keys()) if 'policy_config_snapshot' in locals() else 'N/A'}\n"
+                f"\n"
+                f"The trainer MUST set inference_url in policy config with ?cid=... parameter.\n"
+                f"This is required for trace correlation and hydration.\n"
+            )
+        
+        # policy_config_snapshot already set above in try block (line 1876-1878)
+        # Ensure it exists for logging below
+        if 'policy_config_snapshot' not in locals():
+            policy_config_snapshot = {}
+        
+        # Normalize inference URL for trajectory (and ensure no path in query)
+        try:
+            from .utils import force_normalize_chat_completions_url, ensure_chat_completions_url
+            inference_url = force_normalize_chat_completions_url(inference_url)
+            # apply mode-aware normalization too (keeps cid, appends path if missing)
+            inference_url = ensure_chat_completions_url(inference_url, mode=request.mode)
+        except Exception:
+            pass
+
+        logger.info(
+            "ROLLOUT_TRAJECTORY: run_id=%s policy_id=%s inference_url=%s trace_id=%s",
+            request.run_id,
+            policy_id,
+            inference_url,
+            policy_config_snapshot.get("trace_correlation_id"),
+        )
+        
+        trajectory = RolloutTrajectory(
+            env_id=env_id,
+            policy_id=policy_id,
+            steps=trajectory_steps,
+            final={"observation": _summarize_observation_for_storage(env_handle, current_obs)},
+            length=len(trajectory_steps),
+            inference_url=inference_url,  # NEW: Required for trace correlation
+            decision_samples=decision_samples if step_rewards_active else None,
+        )
+
+        # Build metrics
+        metrics = RolloutMetrics(
+            episode_returns=[total_reward],
+            mean_return=total_reward,
+            num_steps=len(trajectory_steps),
+            num_episodes=1,
+        )
+        if step_rewards_active:
+            stepwise_summary: dict[str, Any] = {
+                "indicator_sum": float(stepwise_indicator_sum),
+                "reward_sum": float(stepwise_reward_sum),
+                "resource_reward": float(stepwise_resource_reward_sum),
+                "new_achievements_total": int(stepwise_new_achievements_total),
+                "mode": step_rewards_mode,
+                "strategy": step_rewards_strategy,
+                "indicator_lambda": float(step_rewards_indicator_lambda),
+            }
+            if step_rewards_beta:
+                stepwise_summary["step_beta"] = float(step_rewards_beta)
+            if step_rewards_strategy == "per_achievement":
+                if step_rewards_weights:
+                    stepwise_summary["weights"] = dict(step_rewards_weights)
+                if step_rewards_k_limits:
+                    stepwise_summary["k_limits"] = dict(step_rewards_k_limits)
+            final_achievements_list = sorted(
+                key for key, val in (prev_achievements or {}).items() if bool(val)
+            )
+            stepwise_summary["unique_achievements_total"] = int(len(episode_seen_achievements))
+            stepwise_summary["unique_achievements"] = sorted(episode_seen_achievements)
+            stepwise_summary["final_achievements"] = final_achievements_list
+            metrics.details["stepwise"] = stepwise_summary
+
+        # Environment-specific: Log summary if available
+        try:
+            # Check if this is a Wordle environment and use Wordle helpers (lazy import)
+            wordle_wrapper_cls = None
+            try:
+                from .envs.wordle.environment import WordleEnvironmentWrapper
+                from .envs.wordle.helpers import (
+                    get_wordle_rollout_summary,
+                    log_wordle_rollout_summary,
+                )
+
+                wordle_wrapper_cls = WordleEnvironmentWrapper
+            except Exception:
+                wordle_wrapper_cls = None  # type: ignore[assignment]
+                get_wordle_rollout_summary = None  # type: ignore
+                log_wordle_rollout_summary = None  # type: ignore
+
+            is_wordle = wordle_wrapper_cls is not None and isinstance(
+                env_handle.env,
+                wordle_wrapper_cls,  # type: ignore[arg-type]
+            )
+            if is_wordle:
+                # Convert trajectory steps to expected format
+                formatted_steps = []
+                for step in trajectory_steps:
+                    formatted_steps.append({"tool_calls": step.tool_calls or []})
+
+                if (
+                    get_wordle_rollout_summary is not None
+                    and log_wordle_rollout_summary is not None
+                ):
+                    summary = get_wordle_rollout_summary(formatted_steps, current_obs, env_handle)
+                    log_wordle_rollout_summary(request.run_id, summary)
+        except ImportError:
+            # Wordle helpers not available, skip Wordle-specific logging
+            pass
+        except Exception as e:
+            logger.warning(f"Failed to generate environment-specific summary: {e}")
+
+        # Mark run as completed
+        aborted = registry.is_run_aborted(request.run_id)
+        if not aborted:
+            registry.complete_run(request.run_id)
+        if decision_open:
+            await tracing_context.end_decision()
+            decision_open = False
+        if not finalized:
+            session_trace = await tracing_context.finalize(
+                total_reward=total_reward,
+                achievement_state=prev_achievements,
+                total_steps=len(trajectory_steps),
+            )
+            finalized = True
+        trace_payload = tracing_context.build_trace_payload(session_trace)
+        
+        # Debug: Check trace payload
+        logger.info(f"[TRACE_DEBUG] trace_payload is None: {trace_payload is None}, return_trace={tracing_context.return_trace}")
+        if trace_payload:
+            logger.info(f"[TRACE_DEBUG] trace_payload keys: {list(trace_payload.keys())}")
+
+        # Hard-fail if no steps executed (avg_turns == 0 scenario)
+        if metrics.num_steps <= 0:
+            raise HTTPException(status_code=500, detail="no_steps_executed: avg_turns == 0")
+
+        # Ensure at least one tool call executed successfully
+        tool_call_executed = any(
+            isinstance(step.tool_calls, list) and len(step.tool_calls) > 0 for step in trajectory_steps
+        )
+        if not tool_call_executed:
+            raise HTTPException(
+                status_code=502,
+                detail="no_tool_calls_executed: model failed to produce actionable tool calls.",
+            )
+
+        response = RolloutResponse(
+            run_id=request.run_id,
+            trajectories=[trajectory],
+            branches={},
+            metrics=metrics,
+            aborted=aborted,
+            ops_executed=ops_executed,
+            trace=trace_payload,
+        )
+        logger.info(
+            "ROLLOUT_RESPONSE: run_id=%s aborted=%s ops_executed=%s metrics_steps=%s trace_present=%s pipeline_metadata=%s",
+            request.run_id,
+            aborted,
+            ops_executed,
+            metrics.num_steps,
+            bool(trace_payload),
+            response.pipeline_metadata,
+        )
+        return response
+
+    except Exception as e:
+        logger.error(f"Rollout failed for run {request.run_id}: {e}")
+        registry.abort_run(request.run_id)
+        if decision_open:
+            with contextlib.suppress(Exception):
+                await tracing_context.end_decision()
+            decision_open = False
+        if not finalized:
+            session_trace = None
+            with contextlib.suppress(Exception):
+                session_trace = await tracing_context.finalize(
+                    total_reward=total_reward,
+                    achievement_state=prev_achievements,
+                    total_steps=len(trajectory_steps),
+                )
+            finalized = True
+        raise HTTPException(status_code=500, detail=str(e)) from e
+    finally:
+        # Ensure any environment created for this rollout is terminated (no reuse across rollouts)
+        try:
+            if created_env_id:
+                from .environment_routes import EnvTerminateRequest, terminate_environment
+
+                await terminate_environment(EnvTerminateRequest(env_id=created_env_id))
+                logger.info(
+                    "ROLL_OUT: terminated environment env_id=%s seed=%s",
+                    str(created_env_id),
+                    str(env_seed_used) if env_seed_used is not None else "unknown",
+                )
+                # Verify removal from registry
+                with contextlib.suppress(Exception):
+                    _post = registry.get_env(created_env_id)
+                    logger.info(
+                        "ROLL_OUT: env_killed=%s (post_lookup=%s)",
+                        str(_post is None),
+                        str(_post),
+                    )
+        except Exception as _te:
+            logger.warning(f"ROLL_OUT: failed to terminate environment {created_env_id}: {_te}")
+
+        # Best-effort policy cleanup if we created one (avoid reuse across rollouts)
+        with contextlib.suppress(Exception):
+            if created_policy_id:
+                from .policy_routes import PolicyTerminateRequest, terminate_policy
+
+                await terminate_policy(PolicyTerminateRequest(policy_id=created_policy_id))
+                logger.info("ROLL_OUT: terminated policy policy_id=%s", str(created_policy_id))
+
+        if not finalized:
+            session_trace = None
+            with contextlib.suppress(Exception):
+                session_trace = await tracing_context.finalize(
+                    total_reward=total_reward,
+                    achievement_state=prev_achievements,
+                    total_steps=len(trajectory_steps),
+                )
+            finalized = True
+
+        with contextlib.suppress(Exception):
+            _clear_seed_side_effects()
+            logger.info("ROLL_OUT: RNG seed terminated/cleared before conclusion")
+
+
+@router.post("/run/abort", response_model=RunAbortResponse)
+async def abort_run(request: RunAbortRequest) -> RunAbortResponse:
+    """Abort a running rollout."""
+    success = registry.abort_run(request.run_id)
+
+    if not success:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Run {request.run_id} not found",
+        )
+
+    return RunAbortResponse(
+        ok=True,
+        run_id=request.run_id,
+    )
+
+
+@router.get("/run/status/{run_id}", response_model=RunStatusResponse)
+async def get_run_status(run_id: str) -> RunStatusResponse:
+    """Get the status of a run."""
+    run_handle = registry.get_run(run_id)
+
+    if not run_handle:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Run {run_id} not found",
+        )
+
+    return RunStatusResponse(
+        run_id=run_id,
+        status=run_handle.status,
+        started_at=run_handle.started_at,
+        finished_at=run_handle.finished_at,
+    )