shop manage eng phase 2 first

.gitignore

@@ -1,6 +1,9 @@
 .venv/
 __pycache__/
 *.egg-info/
-uv.lock
 .env
 *.pyc
+*.log
+data/
+
+uv.lock

.hfignore

@@ -0,0 +1,31 @@
+# Extra files to keep OUT of the Hugging Face Space upload.
+# Used by: openenv push --exclude .hfignore
+# (in addition to .gitignore)
+
+# Local-only env-utility scripts. Useful on dev machine, not part of the Space service.
+rollout_baseline.py
+test_env_smoke.py
+
+# Course material / docs we don't want to ship inside the Space.
+*.pdf
+*.odt
+
+# Editor / IDE noise.
+.idea/
+.vscode/
+.DS_Store
+
+# Inner GitHub repo metadata — Space gets its own git history.
+.git/
+
+# Local virtualenv & secrets (also covered by .gitignore but listed here for safety).
+.venv/
+.env
+
+# Build / runtime artifacts that auto-regenerate.
+__pycache__/
+*.egg-info/
+*.pyc
+*.log
+data/
+trl_jewelry_out/

__init__.py

@@ -2,6 +2,7 @@
 
 from .client import JewelryShopEnv
 from .models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
+from .constants import GRAMS_PER_TROY_OZ, troy_oz_to_grams, grams_to_troy_oz
 
 __all__ = [
     "JewelryAction",
@@ -9,4 +10,7 @@ __all__ = [
     "JewelryState",
     "JewelryShopEnv",
     "PRODUCT_CATALOG",
+    "GRAMS_PER_TROY_OZ",
+    "troy_oz_to_grams",
+    "grams_to_troy_oz",
 ]

client.py

@@ -1,6 +1,10 @@
 from openenv.core.env_client import EnvClient
 from openenv.core.client_types import StepResult
-from .models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
+
+try:
+    from .models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
+except ImportError:
+    from models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
 
 
 class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState]):
@@ -40,6 +44,19 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
         if action.message is not None:
             payload["message"] = action.message
 
+        if action.target_price_usd is not None:
+            payload["target_price_usd"] = action.target_price_usd
+        if action.ai_confidence_pct is not None:
+            payload["ai_confidence_pct"] = action.ai_confidence_pct
+        if action.ai_reasoning is not None:
+            payload["ai_reasoning"] = action.ai_reasoning
+        if action.inventory_urgent is not None:
+            payload["inventory_urgent"] = action.inventory_urgent
+        if action.need_gold_grams is not None:
+            payload["need_gold_grams"] = action.need_gold_grams
+        if action.buy_deadline_iso is not None:
+            payload["buy_deadline_iso"] = action.buy_deadline_iso
+
         return payload
 
     # ── 2. UNPACK dict → typed observation (received FROM server) ───────────
@@ -47,10 +64,21 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
     def _parse_result(self, payload: dict) -> StepResult:
         obs_data = payload.get("observation", {})
 
+        # Force reward and cumulative_reward to Python floats. JSON over the wire
+        # can deliver int (e.g. 0) which would later break formatters / training.
+        try:
+            _reward = float(payload.get("reward")) if payload.get("reward") is not None else 0.0
+        except (TypeError, ValueError):
+            _reward = 0.0
+        try:
+            _cum = float(obs_data.get("cumulative_reward", 0.0))
+        except (TypeError, ValueError):
+            _cum = 0.0
+
         observation = JewelryObservation(
             # Base fields
             done=payload.get("done", False),
-            reward=payload.get("reward", None),
+            reward=_reward,
 
             # Phase info
             phase=obs_data.get("phase", "market"),
@@ -58,15 +86,25 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
             # Finances & inventory
             cash=obs_data.get("cash", 1000.0),
             gold_oz=obs_data.get("gold_oz", 0.0),
+            gold_grams=obs_data.get("gold_grams", 0.0),
 
             # Market
             gold_price=obs_data.get("gold_price", 0.0),
             gold_price_history=obs_data.get("gold_price_history", []),
             market_round=obs_data.get("market_round", 0),
-            max_market_rounds=obs_data.get("max_market_rounds", 3),
+            max_market_rounds=obs_data.get("max_market_rounds", 0),
+            market_mode=obs_data.get("market_mode", "real"),
+            gold_price_source=obs_data.get("gold_price_source", ""),
+            inventory_urgent=obs_data.get("inventory_urgent", False),
+            need_gold_grams=obs_data.get("need_gold_grams", None),
+            buy_deadline_iso=obs_data.get("buy_deadline_iso", None),
+            cannot_wait=obs_data.get("cannot_wait", False),
+            market_reentries=obs_data.get("market_reentries", 0),
+            max_market_reentries=obs_data.get("max_market_reentries", 2),
 
             # Warehouse
             demand=obs_data.get("demand", {}),
+            demand_forecast=obs_data.get("demand_forecast", {}),
             product_catalog=obs_data.get("product_catalog", PRODUCT_CATALOG),
             inventory=obs_data.get("inventory", {}),
 
@@ -76,13 +114,18 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
             current_offer=obs_data.get("current_offer", None),
             negotiation_round=obs_data.get("negotiation_round", 0),
 
+            # Per-task grading
+            task_id=obs_data.get("task_id", "profit_negotiator"),
+            weights=obs_data.get("weights", []),
+            cumulative_reward=_cum,
+
             # Feedback
             message=obs_data.get("message", ""),
         )
 
         return StepResult(
             observation=observation,
-            reward=payload.get("reward", None),
+            reward=_reward,
             done=payload.get("done", False),
         )
 
@@ -98,8 +141,13 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
             gold_price=payload.get("gold_price", 0.0),
             gold_price_history=payload.get("gold_price_history", []),
             market_round=payload.get("market_round", 0),
+            max_market_rounds=payload.get("max_market_rounds", 0),
+            use_fifo_lots=payload.get("use_fifo_lots", False),
+            market_mode=payload.get("market_mode", "real"),
+            gold_price_source=payload.get("gold_price_source", ""),
 
             demand=payload.get("demand", {}),
+            demand_forecast=payload.get("demand_forecast", {}),
             inventory=payload.get("inventory", {}),
 
             phase=payload.get("phase", "market"),
@@ -109,4 +157,13 @@ class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState])
             current_offer=payload.get("current_offer", 0.0),
             base_offer=payload.get("base_offer", 0.0),
             lowest_price_seen=payload.get("lowest_price_seen", 0.0),
+            inventory_urgent=payload.get("inventory_urgent", False),
+            need_gold_grams=payload.get("need_gold_grams", None),
+            buy_deadline_iso=payload.get("buy_deadline_iso", None),
+            market_reentries=payload.get("market_reentries", 0),
+            max_market_reentries=payload.get("max_market_reentries", 2),
+            task_id=payload.get("task_id", "profit_negotiator"),
+            weights=payload.get("weights", []),
+            cumulative_reward=payload.get("cumulative_reward", 0.0),
+            last_phase_emitted_reward=payload.get("last_phase_emitted_reward", 0.0),
         )

constants.py

@@ -0,0 +1,34 @@
+"""
+Shared physical and market constants (troy oz ↔ grams, config keys).
+"""
+import os
+from typing import Final
+
+# Troy ounce (XAU convention in this project) to grams, per user / pricing spec
+GRAMS_PER_TROY_OZ: Final[float] = 31.1035
+
+
+def troy_oz_to_grams(oz: float) -> float:
+    return round(oz * GRAMS_PER_TROY_OZ, 6)
+
+
+def grams_to_troy_oz(grams: float) -> float:
+    if GRAMS_PER_TROY_OZ <= 0:
+        return 0.0
+    return round(grams / GRAMS_PER_TROY_OZ, 8)
+
+
+def get_market_mode() -> str:
+    """'real' uses live GC=F + DB; 'synthetic' uses legacy random market (for offline tests)."""
+    return (os.environ.get("SHOPMANAGER_MARKET_MODE", "real") or "real").lower().strip()
+
+
+def get_sqlite_path() -> str:
+    return os.environ.get("SHOPMANAGER_SQLITE_PATH", "").strip() or ""
+
+
+def default_sqlite_path() -> str:
+    from pathlib import Path
+
+    here = Path(__file__).resolve().parent
+    return str(here / "data" / "shop_manager.db")

inference.py

@@ -16,12 +16,19 @@ from ShopManagerEng.models import JewelryAction
 
 load_dotenv()
 
-IMAGE_NAME = os.getenv("IMAGE_NAME")
 API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
 
-API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
-# MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-MODEL_NAME = os.getenv("MODEL_NAME", "meta-llama/Llama-3.3-70B-Instruct")
+# ── LLM API ─────────────────────────────────────────────────────────────────
+# HuggingFace Inference Router (needs HF_TOKEN in .env)
+API_BASE_URL = "https://router.huggingface.co/v1"
+
+# ── MODEL ───────────────────────────────────────────────────────────────────
+# Pick one — comment out the other
+MODEL_NAME = "meta-llama/Llama-3.3-70B-Instruct"
+# MODEL_NAME = "Qwen/Qwen2.5-72B-Instruct"
+# MODEL_NAME = "meta-llama/Llama-3.2-3B-Instruct"
+# MODEL_NAME = "Qwen/Qwen2.5-3B-Instruct"
+# ─────────────────────────────────────────────────────────────────────────────
 TASK_NAME = os.getenv("JEWELRY_ENV_TASK", "jewelry-shop")
 BENCHMARK = os.getenv("JEWELRY_ENV_BENCHMARK", "jewelry_shop_benchmark")
 MAX_STEPS = 15
@@ -32,28 +39,42 @@ SUCCESS_SCORE_THRESHOLD = 0.01
 
 SYSTEM_PROMPT = textwrap.dedent(
     """
-    You are an expert agent running a jewelry shop. Maximize profit across 3 phases.
-
-    ## Phase 1: MARKET (buy/wait)
-    Gold prices fluctuate ±10% each round (up to 3 rounds).
-    - Analyze the price trend from the history.
-    - If the price DROPPED from the previous round, it might drop further → consider waiting.
-    - If the price ROSE or you're on the last round → buy now.
-    - Reserve enough cash for labor ($100-$300 depending on product).
-    - Respond: "buy X.XX" (to buy X.XX oz of gold) or "wait" (to see next price).
+    You are an expert agent running a jewelry shop. The episode runs in 3 phases
+    and may loop back to MARKET if the warehouse runs out of gold. The episode
+    reward is the SUM of per-step partial rewards across the whole episode and
+    is bounded in [0, 1]. Each task weights the phases differently:
+      - market_timing     -> phase 1 = 0.6, phase 2 = 0.2, phase 3 = 0.2
+      - demand_crafter    -> phase 1 = 0.2, phase 2 = 0.6, phase 3 = 0.2
+      - profit_negotiator -> phase 1 = 0.2, phase 2 = 0.2, phase 3 = 0.6
+
+    ## Phase 1: MARKET (buy / wait)
+    Two modes:
+      - synthetic mode: gold price moves randomly each WAIT step within a round cap.
+      - real mode:      gold price comes from a live source (yfinance: GC=F),
+                        no round cap; WAIT just refreshes the live quote.
+    Coordination from the warehouse:
+      - inventory_urgent=True / cannot_wait=True means you MUST buy now;
+        WAIT will be blocked. Submit "buy X.XX" with an affordable troy-oz qty.
+    Behavior:
+      - If you can wait, observe the price trend in gold_price_history before buying.
+      - Reserve cash for labor (ring=$200, necklace=$300, bracelet=$100).
+      - Respond: "buy X.XX" (troy oz of gold) or "wait".
 
     ## Phase 2: WAREHOUSE (choose product)
-    You see demand levels for each product. Pick the HIGHEST demand product
-    that you can afford to craft (enough gold + cash for labor).
+    You see two demand fields:
+      - demand          : the TRUE per-product demand for THIS episode (ground truth).
+      - demand_forecast : a NOISY signal you can also lean on for planning.
     Products: ring (1oz + $200), necklace (2oz + $300), bracelet (0.5oz + $100).
-    - Respond: "ring", "necklace", or "bracelet"
+    If you don't have enough gold to craft your choice, the env may BOUNCE you back
+    to MARKET to buy more (up to max_market_reentries times). After max bounces or
+    when truly broke, the customer leaves and the episode ends.
+    Respond: "ring", "necklace", or "bracelet".
 
     ## Phase 3: SHOWROOM (negotiate)
-    A customer offers a price. Your goal is to sell at maximum profit.
-    - Counter-offer to drive the price up (customer raises 5% each round, max 5 rounds).
-    - Accept when the offer is good (round >= 3 or offer > 1.3× cost).
-    - NEVER reject.
-    - Respond: "I accept" or a counter like "How about $X?"
+    The customer makes an offer; if you counter, they raise it ~5% per round,
+    up to 5 rounds. After 5 rounds with no acceptance, the customer leaves
+    (no phase-3 reward). Reject also gives 0 phase-3 reward.
+    Respond: "I accept" or a counter like "How about $X?". NEVER explicitly reject.
 
     CRITICAL: Respond with ONLY the action value. No explanations.
     """
@@ -94,7 +115,10 @@ def build_user_prompt(step: int, obs, last_reward: float, history: List[str]) ->
             else:
                 trend = "RISING ↑ (buy now before it gets more expensive)"
 
-        rounds_left = obs.max_market_rounds - obs.market_round
+        if getattr(obs, "cannot_wait", False):
+            trend = "URGENT: inventory needs gold now — you cannot wait; buy at the current live quote with an affordable gold_qty (troy oz)."
+
+        rounds_left = (obs.max_market_rounds - obs.market_round) if obs.max_market_rounds else None
         # Suggest buy quantity that reserves $300 for labor (max labor cost)
         reserve = 300.0
         if obs.gold_price > 0:
@@ -104,20 +128,27 @@ def build_user_prompt(step: int, obs, last_reward: float, history: List[str]) ->
         else:
             suggested_qty = 1.0
 
+        _rl = "unlimited" if rounds_left is None else str(rounds_left)
         phase_hint = (
+            f"Price: ${getattr(obs, 'gold_price', 0)}/oz ({getattr(obs, 'gold_price_source', '') or 'n/a'}). "
             f"Price history: {prices}. Trend: {trend}. "
-            f"Rounds left: {rounds_left}. "
+            f"Rounds / waits so far: {getattr(obs, 'market_round', 0)}; cap: {_rl}. "
+            f"Gold on hand: {getattr(obs, 'gold_oz', 0)} troy oz (~{getattr(obs, 'gold_grams', 0):.2f} g). "
             f"If buying, suggested qty: {suggested_qty} oz (reserves $300 for labor). "
             f"Respond: 'buy {suggested_qty}' or 'wait'"
         )
 
     elif obs.phase == "warehouse":
         demand = obs.demand
+        forecast = getattr(obs, "demand_forecast", {}) or {}
         best_product = max(demand, key=demand.get) if demand else "ring"
         phase_hint = (
-            f"Demand: ring={demand.get('ring', 0):.0%}, "
+            f"Demand (episode): ring={demand.get('ring', 0):.0%}, "
             f"necklace={demand.get('necklace', 0):.0%}, "
             f"bracelet={demand.get('bracelet', 0):.0%}. "
+            f"Forecast (noisy): ring={forecast.get('ring', 0):.0%}, "
+            f"necklace={forecast.get('necklace', 0):.0%}, "
+            f"bracelet={forecast.get('bracelet', 0):.0%}. "
             f"Highest demand: {best_product}. "
             f"You have {obs.gold_oz}oz gold and ${obs.cash} cash. "
             f"Respond with EXACTLY: {best_product}"
@@ -253,7 +284,8 @@ async def run_episode(client: OpenAI, task_name: str, env_name: str, base_url: s
     try:
         env = JewelryShopEnv(base_url=base_url)
 
-        result = await env.reset()
+        # Pass task_id so the env applies that task's per-phase weights.
+        result = await env.reset(task_id=task_name)
         obs = result.observation
         last_reward = 0.0
 
@@ -281,11 +313,9 @@ async def run_episode(client: OpenAI, task_name: str, env_name: str, base_url: s
             if done:
                 break
 
-        if rewards:
-            score = rewards[-1]
-        else:
-            score = 0.0
-
+        # Trajectory return = env's authoritative cumulative reward (sum of per-step
+        # partials, in [0, 1]). Falls back to summing locally if the field is missing.
+        score = float(getattr(obs, "cumulative_reward", sum(rewards) if rewards else 0.0))
         score = min(max(score, 0.0), 1.0)
         success = score >= SUCCESS_SCORE_THRESHOLD
 
@@ -310,13 +340,15 @@ TASKS = [
 
 async def main() -> None:
     client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-    # Resolve server URL: evaluator env var → IMAGE_NAME → HF Space → localhost
-    base_url = os.getenv("ENV_BASE_URL")
-    if not base_url and IMAGE_NAME:
-        base_url = f"https://{IMAGE_NAME.replace('/', '-').replace('_', '-')}.hf.space"
-    if not base_url:
-        base_url = os.getenv("SPACE_URL", "https://hard007ik-shopmanagereng.hf.space")
-    # print(f"[CONFIG] base_url={base_url}", flush=True)
+
+    # ── ENV SERVER URL ──────────────────────────────────────────────────────
+    # LOCAL:  start server with `uv run --project . server`, then use localhost
+    # REMOTE: comment the localhost line and uncomment the HF Space line
+    # base_url = "http://localhost:8000"
+    base_url = "https://hard007ik-shopmanagereng.hf.space"
+    # ───────────────────────────────────────────────────────────────────────
+
+    # print(f"[CONFIG] base_url={base_url}  model={MODEL_NAME}", flush=True)
 
     for task in TASKS:
         await run_episode(client, task["id"], task["env"], base_url)

models.py

@@ -23,12 +23,23 @@ class JewelryAction(Action):
     Phase 1 (market)    → market_action ("buy"/"wait") + gold_qty (oz to buy)
     Phase 2 (warehouse) → product_choice ("ring"/"necklace"/"bracelet")
     Phase 3 (showroom)  → message (accept / counter / reject)
+
+    Market (optional): when logging a BUY to SQLite / invoice, the agent may send
+    LLM target + reasoning; when coordinating with the inventory side, it may
+    update urgency / need-by fields that were also set on reset.
     """
     market_action:  Optional[str]   = None   # "buy" or "wait"
     gold_qty:       Optional[float] = None   # How many oz to buy (market phase)
     product_choice: Optional[str]   = None   # "ring" / "necklace" / "bracelet"
     message:        Optional[str]   = None   # Showroom negotiation text
 
+    target_price_usd:   Optional[float] = None
+    ai_confidence_pct:  Optional[float] = None
+    ai_reasoning:       Optional[str]   = None
+    inventory_urgent:   Optional[bool]  = None
+    need_gold_grams:    Optional[float] = None
+    buy_deadline_iso:   Optional[str]   = None
+
 
 # ─────────────────────────────────────────────
 #  OBSERVATION
@@ -44,12 +55,26 @@ class JewelryObservation(Observation):
 
     # Market phase
     gold_price:         float                  # Current gold price ($/oz)
+    gold_grams:         float = 0.0            # Raw gold in inventory (grams) — troy-oz * GRAMS_PER_TROY_OZ
     gold_price_history: List[float] = []       # Last N prices for trend analysis
-    market_round:       int = 0                # Current round in market (0-indexed)
-    max_market_rounds:  int = 3                # Max rounds before forced decision
+    market_round:       int = 0                # "Wait" count in this episode (for analytics; no cap in real mode)
+    max_market_rounds:  int = 0                # 0 = no forced round limit (real market); >0 = synthetic only
+    market_mode:        str = "real"           # "real" | "synthetic"
+    gold_price_source:  str = ""               # e.g. yfinance:GC=F
+
+    # Inventory <-> market coordination (from reset / optional step updates)
+    inventory_urgent:     bool = False
+    need_gold_grams:   Optional[float] = None
+    buy_deadline_iso:  Optional[str] = None
+    cannot_wait:       bool = False            # If urgent, "wait" action is rejected
+
+    # Inventory -> Market bounce-back (when warehouse cannot craft due to low gold)
+    market_reentries:     int = 0              # How many times warehouse has sent us back to market
+    max_market_reentries: int = 2              # Cap on bounce-backs to avoid infinite loops
 
     # Warehouse phase
-    demand:             Dict[str, float] = {}  # Demand level per product (0-1)
+    demand:             Dict[str, float] = {}  # "True" per-product demand this episode (0-1)
+    demand_forecast:   Dict[str, float] = {}  # Noisy / model-facing signal (inventory "prediction" slot)
     product_catalog:    Dict[str, dict] = {}   # Gold/labor costs per product
     inventory:          Dict[str, int] = {}    # Crafted products in stock
 
@@ -59,6 +84,11 @@ class JewelryObservation(Observation):
     current_offer:      Optional[float] = None # Customer's live offer
     negotiation_round:  int = 0                # Counter-offer rounds so far
 
+    # Per-task grading (chosen at reset() from openenv.yaml task_id)
+    task_id:            str = "profit_negotiator"
+    weights:            List[float] = []       # [w_market, w_warehouse, w_showroom], sums to 1.0
+    cumulative_reward:  float = 0.0            # Running sum of per-step rewards in this episode
+
     message:            str = ""               # Human-readable feedback
 
 
@@ -75,8 +105,10 @@ class JewelryState(State):
     gold_price:         float = 0.0
     gold_price_history: List[float] = []
     market_round:       int = 0
+    max_market_rounds:  int = 0  # 0 = no cap (real); >0 only in synthetic mode
 
     demand:             Dict[str, float] = {}
+    demand_forecast:   Dict[str, float] = {}
     inventory:          Dict[str, int] = {}
 
     phase:              str = "market"
@@ -85,4 +117,21 @@ class JewelryState(State):
     negotiation_round:  int = 0
     current_offer:      float = 0.0
     base_offer:         float = 0.0            # Hidden from agent
-    lowest_price_seen:  float = 0.0            # For r1 scoring
+    lowest_price_seen:  float = 0.0            # For r1 scoring
+
+    inventory_urgent:   bool = False
+    need_gold_grams:   Optional[float] = None
+    buy_deadline_iso:  Optional[str] = None
+    use_fifo_lots:      bool = False            # If True, warehouse cost uses per-gram lots in SQLite
+    gold_price_source:  str = ""
+    market_mode:        str = "real"
+
+    # Inventory -> Market bounce-back loop
+    market_reentries:     int = 0
+    max_market_reentries: int = 2
+
+    # Per-task grading (selected at reset)
+    task_id:            str = "profit_negotiator"
+    weights:            List[float] = []        # [w_market, w_warehouse, w_showroom]
+    cumulative_reward:  float = 0.0
+    last_phase_emitted_reward: float = 0.0      # Reward emitted at the most recent step (debug)

openenv.yaml

@@ -9,19 +9,20 @@ tasks:
   - id: market_timing
     name: "Market Price Analyst"
     description: >
-      Analyze gold price fluctuations across up to 3 market rounds.
-      Decide whether to buy immediately or wait for a price drop.
-      Reserve enough cash for crafting labor ($100-$300).
+      Long-horizon Phase 1: get gold (troy oz) at a reasonable cost using live or synthetic
+      market quotes, coordinate with optional inventory-urgent signals, then proceed to
+      craft and sell. May require multiple market steps in real mode (no hard round cap);
+      synthetic mode supports classic round-budget runs.
     grader:
       type: reward_threshold
       threshold: 0.3
 
   - id: demand_crafter
-    name: "Demand-Based Crafter"
+    name: "Demand-Based Crafter (Inventory)"
     description: >
-      Check warehouse demand levels for ring, necklace, and bracelet.
-      Choose the highest-demand product you can afford to craft.
-      Products: ring (1oz + $200), necklace (2oz + $300), bracelet (0.5oz + $100).
+      Phase 2: use demand and demand_forecast, gold stock, and costs to pick which product
+      to craft. Products: ring (1oz + $200), necklace (2oz + $300), bracelet (0.5oz + $100).
+      FIFO (SQLite) pricing applies in real + DB mode for true metal cost.
     grader:
       type: reward_threshold
       threshold: 0.2

pyproject.toml

@@ -18,14 +18,9 @@ dependencies = [
     # install from github
     # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
     "openenv-core[core]>=0.2.2",
-    # Environment-specific dependencies
-    # Add all dependencies needed for your environment here
-    # Examples:
-    # "numpy>=1.19.0",
-    # "torch>=2.0.0",
-    # "gymnasium>=0.29.0",
-    # "openspiel>=1.0.0",
-    # "smolagents>=1.22.0,<2",
+    "yfinance>=0.2.40",
+    "python-dotenv>=1.0.0",
+    "requests>=2.28.0",
 ]
 
 [project.optional-dependencies]

rollout_baseline.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+No-TRL baseline: run random vs simple heuristic policies; log mean return.
+Run local server first:  uv run server
+Then:  SHOPMANAGER_MARKET_MODE=synthetic SHOPMANAGER_TRAIN_BASE_URL=http://127.0.0.1:8000 python rollout_baseline.py
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import random
+import sys
+from pathlib import Path
+from statistics import fmean, pstdev
+from typing import List, Optional
+
+ROOT = Path(__file__).resolve().parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from client import JewelryShopEnv
+from models import JewelryAction, PRODUCT_CATALOG
+
+
+def _heuristic_action(obs) -> JewelryAction:
+    ph = obs.phase
+    if ph == "market":
+        g = float(obs.gold_price or 0.0) or 1.0
+        need = 1.0
+        if obs.cash >= need * g + 10:
+            return JewelryAction(
+                market_action="buy", gold_qty=need, target_price_usd=obs.gold_price
+            )
+        return JewelryAction(market_action="wait")
+    if ph == "warehouse":
+        dem = obs.demand or {"ring": 0.5, "necklace": 0.3, "bracelet": 0.2}
+        for name in sorted(dem, key=lambda k: dem.get(k, 0), reverse=True):
+            gneed = float(PRODUCT_CATALOG[name]["gold_oz"])
+            lab = float(PRODUCT_CATALOG[name]["labor"])
+            if obs.gold_oz + 1e-9 >= gneed and obs.cash + 1e-9 >= lab:
+                return JewelryAction(product_choice=name)
+        return JewelryAction(product_choice="ring")
+    if ph == "showroom":
+        if (
+            obs.current_offer
+            and obs.cost_basis > 0
+            and (float(obs.current_offer) / float(obs.cost_basis)) >= 1.15
+        ) or (getattr(obs, "negotiation_round", 0) and int(obs.negotiation_round) >= 3):
+            return JewelryAction(message="I accept")
+        off = float(obs.current_offer or 0.0)
+        return JewelryAction(
+            message=f"How about ${off * 1.08:.2f}?" if off else "I need a better offer"
+        )
+    return JewelryAction()
+
+
+def _random_action(obs) -> JewelryAction:
+    if obs.phase == "market":
+        if random.random() < 0.35:
+            return JewelryAction(
+                market_action="buy", gold_qty=round(random.uniform(0.1, 1.2), 2)
+            )
+        return JewelryAction(market_action="wait")
+    if obs.phase == "warehouse":
+        return JewelryAction(product_choice=random.choice(["ring", "necklace", "bracelet"]))
+    return JewelryAction(
+        message=random.choice(
+            [
+                "I accept",
+                f"How about ${float(obs.current_offer or 0) * 1.1:.0f}?",
+            ]
+        )
+    )
+
+
+async def one_episode(base: str, policy: str, seed: Optional[int], max_steps: int) -> float:
+    """
+    Run one episode under the given policy and return the trajectory return,
+    which is the env's cumulative reward (sum of per-step partials, in [0, 1]).
+    """
+    if seed is not None:
+        random.seed(seed)
+    env = JewelryShopEnv(base_url=base)
+    r = await env.reset(seed=seed, episode_id=None)
+    o = r.observation
+    for _ in range(max_steps):
+        if r.done:
+            break
+        if policy == "heuristic":
+            a = _heuristic_action(o)
+        else:
+            a = _random_action(o)
+        r = await env.step(a)
+        o = r.observation
+    try:
+        await env.close()
+    except Exception:  # noqa: BLE001
+        pass
+    # Authoritative trajectory return from the server (in [0, 1]).
+    return float(getattr(o, "cumulative_reward", 0.0))
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--episodes", type=int, default=20)
+    p.add_argument("--max-steps", type=int, default=25)
+    p.add_argument(
+        "--base-url",
+        default=os.environ.get("SHOPMANAGER_TRAIN_BASE_URL", "http://127.0.0.1:8000"),
+    )
+    p.add_argument("--policies", nargs="+", default=["heuristic", "random"])
+    p.add_argument("--out", type=Path, default=Path("rollout_metrics.txt"))
+    args = p.parse_args()
+    base = str(args.base_url)
+    all_lines: List[str] = [f"base_url={base}", f"episodes={args.episodes} max_steps={args.max_steps}", ""]
+
+    for name in args.policies:
+        scores: List[float] = []
+        for epi in range(args.episodes):
+            sc = asyncio.run(
+                one_episode(base, name, seed=epi, max_steps=int(args.max_steps))  # type: ignore[misc]  # noqa: E501
+            )
+            scores.append(sc)
+        m = fmean(scores) if scores else 0.0
+        sd = pstdev(scores) if len(scores) > 1 else 0.0
+        line = f"{name}: mean={m:.4f} std={sd:.4f} scores={scores!s}"
+        all_lines.append(line)
+        print(line)
+    text = "\n".join(all_lines) + "\n"
+    try:
+        args.out.write_text(text, encoding="utf-8")
+        print(f"Wrote {args.out}", flush=True)
+    except OSError as err:
+        print("Could not write out file:", err, flush=True)
+
+
+if __name__ == "__main__":
+    main()

server/ShopManagerEng_environment.py

@@ -1,37 +1,40 @@
 import random
 import uuid
+from typing import Optional
+
 from openenv.core.env_server import Environment
 
 try:
+    from ..constants import get_market_mode, troy_oz_to_grams
     from ..models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
+    from .market_data import last_quote_or_fallback, fetch_gold_spot_usd_per_oz
+    from . import sqlite_store
 except ImportError:
+    # Installed: ShopManagerEng.* — otherwise dev layout: CWD=ShopManagerEng, `import server` (siblings: models, constants)
+    from constants import get_market_mode, troy_oz_to_grams
     from models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
+    from server.market_data import last_quote_or_fallback, fetch_gold_spot_usd_per_oz
+    from server import sqlite_store
 
 
-# ─────────────────────────────────────────────
-#  CONSTANTS
-# ─────────────────────────────────────────────
-
-STARTING_CASH      = 1000.0
-GOLD_PRICE_MIN     = 250.0
-GOLD_PRICE_MAX     = 450.0
-PRICE_FLUCTUATION  = 0.10       # ±10% per market round
-MAX_MARKET_ROUNDS  = 3          # Rounds the agent can wait in market
-MAX_NEGOTIATION    = 5          # Showroom counter-offer limit
-COUNTER_BUMP       = 1.05       # Customer raises offer by 5% each round
-OFFER_MIN_RATIO    = 0.80       # Customer opens at 80-130% of cost basis
-OFFER_MAX_RATIO    = 1.30
-DEMAND_OFFER_BONUS = 0.20       # High demand adds up to 20% to offer
-MAX_PROFIT_MULT    = 2.0        # Normalization ceiling for r3
-
+# Legacy synthetic market (used when SHOPMANAGER_MARKET_MODE=synthetic)
+STARTING_CASH = 10000.0
+GOLD_PRICE_MIN = 250.0
+GOLD_PRICE_MAX = 450.0
+PRICE_FLUCTUATION = 0.10
+MAX_MARKET_ROUNDS = 3
 
-# ─────────────────────────────────────────────
-#  KEYWORD DETECTION  (Phase 3 — Showroom)
-# ─────────────────────────────────────────────
+MAX_NEGOTIATION = 5
+COUNTER_BUMP = 1.05
+OFFER_MIN_RATIO = 0.80
+OFFER_MAX_RATIO = 1.30
+DEMAND_OFFER_BONUS = 0.20
+MAX_PROFIT_MULT = 2.0
 
 ACCEPT_KEYWORDS = ["accept", "deal", "sold", "agreed", "yes", "take it", "i'll take"]
 REJECT_KEYWORDS = ["reject", "no deal", "refuse", "walk away", "not interested", "no thanks"]
 
+
 def detect_intent(message: str) -> str:
     msg = message.lower()
     for kw in ACCEPT_KEYWORDS:
@@ -44,37 +47,48 @@ def detect_intent(message: str) -> str:
 
 
 # ─────────────────────────────────────────────
-#  REWARD HELPERS
+#  REWARD MODEL
+#  All r1/r2/r3 are normalized to [0, 1].
+#  Each step emits a WEIGHTED PARTIAL reward.
+#  Sum of every step's reward over an episode is in [0, 1].
 # ─────────────────────────────────────────────
 
+# Per-task phase weights (w_market, w_warehouse, w_showroom). Each row sums to 1.0.
+TASK_WEIGHTS = {
+    "market_timing":     (0.6, 0.2, 0.2),  # Phase 1 dominates
+    "demand_crafter":    (0.2, 0.6, 0.2),  # Phase 2 dominates
+    "profit_negotiator": (0.2, 0.2, 0.6),  # Phase 3 dominates; phases 1 & 2 weighted equally
+}
+DEFAULT_TASK_ID = "profit_negotiator"
+
+
+def resolve_weights(task_id: Optional[str]) -> tuple:
+    tid = (task_id or DEFAULT_TASK_ID).lower().strip()
+    if tid not in TASK_WEIGHTS:
+        tid = DEFAULT_TASK_ID
+    return TASK_WEIGHTS[tid]
+
+
 def compute_r1(buy_price: float, lowest_price: float) -> float:
-    """
-    Phase 1 reward: did the agent buy near the lowest price seen?
-    1.0 if bought at the lowest, decreasing as buy price increases.
-    """
+    """Phase 1 score in [0, 1]. 1.0 == bought at lowest seen price."""
     if lowest_price <= 0 or buy_price <= 0:
         return 0.0
-    ratio = lowest_price / buy_price  # 1.0 = perfect, <1.0 = overpaid
-    return round(min(ratio, 1.0) * 0.5, 4)
+    ratio = lowest_price / buy_price
+    return round(min(ratio, 1.0), 4)
 
 
 def compute_r2(product_choice: str, demand: dict) -> float:
-    """
-    Phase 2 reward: did the agent pick the highest-demand product?
-    0.5 if picked the best, proportionally less for worse choices.
-    """
+    """Phase 2 score in [0, 1]. 1.0 == picked the most-demanded product."""
     if not demand or product_choice not in demand:
         return 0.0
     max_demand = max(demand.values())
     if max_demand <= 0:
         return 0.0
-    return round((demand[product_choice] / max_demand) * 0.5, 4)
+    return round(demand[product_choice] / max_demand, 4)
 
 
 def compute_r3(accepted_price: float, cost_basis: float) -> float:
-    """
-    Phase 3 reward: normalized profit margin on sale.
-    """
+    """Phase 3 score in [0, 1]. 1.0 == hit the max profit multiple."""
     if cost_basis <= 0:
         return 0.0
     profit = accepted_price - cost_basis
@@ -84,47 +98,235 @@ def compute_r3(accepted_price: float, cost_basis: float) -> float:
     return round(min(profit / max_profit, 1.0), 4)
 
 
-def combined_reward(r1: float, r2: float, r3: float) -> float:
-    """Weighted combination: showroom dominates."""
-    return round((0.2 * r1) + (0.2 * r2) + (0.6 * r3), 4)
+def step_reward(weights: tuple, phase_emitted: str, r_value: float) -> float:
+    """
+    Convert a normalized phase score (in [0, 1]) into the WEIGHTED partial
+    reward emitted at that step. Summing these across an episode is in [0, 1].
+    Guaranteed to return a Python float (never int / never None).
+    """
+    if phase_emitted == "market":
+        return float(round(float(weights[0]) * float(r_value), 4))
+    if phase_emitted == "warehouse":
+        return float(round(float(weights[1]) * float(r_value), 4))
+    if phase_emitted == "showroom":
+        return float(round(float(weights[2]) * float(r_value), 4))
+    return 0.0
 
 
-# ─────────────────────────────────────────────
-#  ENVIRONMENT
-# ─────────────────────────────────────────────
+def _demand_forecast_from(demand: dict) -> dict:
+    """
+    Noisy "forecast" for the inventory agent to plan against (same scale as demand).
+    Deterministic w.r.t. the RNG in reset(seed=...) on the current episode.
+    """
+    out: dict = {}
+    for k, v in demand.items():
+        wiggle = random.uniform(-0.12, 0.12)
+        out[k] = round(max(0.0, min(1.0, float(v) + wiggle)), 2)
+    return out
+
 
 class JewelryShopEnvironment(Environment):
     SUPPORTS_CONCURRENT_SESSIONS = True
 
     def __init__(self):
         self._state = JewelryState()
+        # Normalized per-phase scores in [0, 1] (raw, before weighting)
         self._r1 = 0.0
         self._r2 = 0.0
+        self._r3 = 0.0
+
+    def _emit(self, phase_emitted: str, r_value: float) -> float:
+        """
+        Convert a normalized phase score into the per-step weighted reward,
+        update cumulative bookkeeping, and return the value to attach to obs.
+        Guaranteed: returned value AND s.cumulative_reward are Python floats.
+        """
+        s = self._state
+        weights = tuple(s.weights) if s.weights else resolve_weights(s.task_id)
+        partial = float(step_reward(weights, phase_emitted, r_value))
+        s.cumulative_reward = float(round(float(s.cumulative_reward) + partial, 4))
+        s.last_phase_emitted_reward = partial
+        return partial
+
+    def _apply_action_inventory_fields(self, action: JewelryAction) -> None:
+        s = self._state
+        if action.inventory_urgent is not None:
+            s.inventory_urgent = bool(action.inventory_urgent)
+        if action.need_gold_grams is not None:
+            s.need_gold_grams = action.need_gold_grams
+        if action.buy_deadline_iso is not None:
+            s.buy_deadline_iso = action.buy_deadline_iso
+
+    def _mm_line(self) -> str:
+        s = self._state
+        if s.market_mode == "synthetic" and s.max_market_rounds and s.max_market_rounds > 0:
+            return f"Market simulation rounds in this phase: {s.max_market_rounds - s.market_round} (of {s.max_market_rounds})."
+        if s.max_market_rounds == 0 or s.max_market_rounds is None:
+            return "No round limit: wait to refresh the quote; buy when ready."
+        return f"Rounds left: {max(0, s.max_market_rounds - s.market_round)}."
+
+    def _co_market(
+        self,
+        *,
+        done: bool = False,
+        reward: float = 0.0,
+        msg: str = "",
+        keep_phase: Optional[str] = None,
+    ) -> dict:
+        s = self._state
+        ph = keep_phase or s.phase
+        max_r = s.max_market_rounds
+        g_oz = s.gold_oz
+        # Always emit reward as a Python float so it survives JSON serialization
+        # as a JSON number with a decimal point (e.g. 0.0, not 0).
+        try:
+            reward_f = float(reward) if reward is not None else 0.0
+        except (TypeError, ValueError):
+            reward_f = 0.0
+        return dict(
+            done=done,
+            reward=reward_f,
+            phase=ph,
+            cash=s.cash,
+            gold_oz=g_oz,
+            gold_grams=round(troy_oz_to_grams(g_oz), 4),
+            gold_price=s.gold_price,
+            gold_price_history=list(s.gold_price_history),
+            market_round=s.market_round,
+            max_market_rounds=max_r,
+            market_mode=s.market_mode,
+            gold_price_source=s.gold_price_source,
+            inventory_urgent=s.inventory_urgent,
+            need_gold_grams=s.need_gold_grams,
+            buy_deadline_iso=s.buy_deadline_iso,
+            cannot_wait=s.inventory_urgent and ph == "market",
+            market_reentries=s.market_reentries,
+            max_market_reentries=s.max_market_reentries,
+            demand=s.demand,
+            demand_forecast=getattr(s, "demand_forecast", {}) or {},
+            product_catalog=PRODUCT_CATALOG,
+            inventory=s.inventory,
+            product_for_sale=None if ph == "market" else s.product_for_sale,
+            cost_basis=s.cost_basis if ph != "market" else 0.0,
+            current_offer=None if ph == "market" else s.current_offer,
+            negotiation_round=s.negotiation_round,
+            task_id=s.task_id,
+            weights=list(s.weights) if s.weights else list(resolve_weights(s.task_id)),
+            cumulative_reward=float(s.cumulative_reward),
+            message=msg,
+        )
 
-    # ── RESET ──────────────────────────────────
+    def _obs_from(self, o: dict) -> JewelryObservation:
+        try:
+            _r = float(o.get("reward", 0.0)) if o.get("reward", 0.0) is not None else 0.0
+        except (TypeError, ValueError):
+            _r = 0.0
+        try:
+            _cr = float(o.get("cumulative_reward", 0.0))
+        except (TypeError, ValueError):
+            _cr = 0.0
+        return JewelryObservation(
+            done=o.get("done", False),
+            reward=_r,
+            phase=o.get("phase", "market"),
+            cash=o.get("cash", 1000.0),
+            gold_oz=o.get("gold_oz", 0.0),
+            gold_grams=o.get("gold_grams", 0.0),
+            gold_price=o.get("gold_price", 0.0),
+            gold_price_history=o.get("gold_price_history", []),
+            market_round=o.get("market_round", 0),
+            max_market_rounds=o.get("max_market_rounds", 0),
+            market_mode=o.get("market_mode", "real"),
+            gold_price_source=o.get("gold_price_source", ""),
+            inventory_urgent=o.get("inventory_urgent", False),
+            need_gold_grams=o.get("need_gold_grams", None),
+            buy_deadline_iso=o.get("buy_deadline_iso", None),
+            cannot_wait=o.get("cannot_wait", False),
+            market_reentries=o.get("market_reentries", 0),
+            max_market_reentries=o.get("max_market_reentries", 2),
+            demand=o.get("demand", {}),
+            demand_forecast=o.get("demand_forecast", {}),
+            product_catalog=o.get("product_catalog", PRODUCT_CATALOG),
+            inventory=o.get("inventory", {}),
+            product_for_sale=o.get("product_for_sale", None),
+            cost_basis=o.get("cost_basis", 0.0),
+            current_offer=o.get("current_offer", None),
+            negotiation_round=o.get("negotiation_round", 0),
+            task_id=o.get("task_id", DEFAULT_TASK_ID),
+            weights=o.get("weights", list(resolve_weights(DEFAULT_TASK_ID))),
+            cumulative_reward=_cr,
+            message=o.get("message", ""),
+        )
 
     def reset(self, seed=None, episode_id=None, **kwargs) -> JewelryObservation:
         if seed is not None:
             random.seed(seed)
-
-        gold_price = round(random.uniform(GOLD_PRICE_MIN, GOLD_PRICE_MAX), 2)
-
-        # Randomize demand levels for this episode
-        demand = {
-            "ring":     round(random.uniform(0.4, 1.0), 2),
+        eid = episode_id or str(uuid.uuid4())
+        try:
+            starting_cash = float(kwargs.get("starting_cash", STARTING_CASH))
+        except (TypeError, ValueError):
+            starting_cash = STARTING_CASH
+
+        inv_urgent = bool(kwargs.get("inventory_urgent", False))
+        need_g = kwargs.get("need_gold_grams", None)
+        if need_g is not None:
+            try:
+                need_g = float(need_g)
+            except (TypeError, ValueError):
+                need_g = None
+        deadline = kwargs.get("buy_deadline_iso", None)
+        if deadline is not None and not isinstance(deadline, str):
+            deadline = str(deadline) if deadline is not None else None
+
+        dem = {
+            "ring": round(random.uniform(0.4, 1.0), 2),
             "necklace": round(random.uniform(0.2, 0.8), 2),
             "bracelet": round(random.uniform(0.1, 0.6), 2),
         }
-
-        self._state = JewelryState(
-            episode_id=episode_id or str(uuid.uuid4()),
+        dem_fc = _demand_forecast_from(dem)
+        mode = (kwargs.get("market_mode") or get_market_mode()).lower().strip()
+
+        if mode == "synthetic":
+            gp = round(random.uniform(GOLD_PRICE_MIN, GOLD_PRICE_MAX), 2)
+            hist = [gp]
+            mmode = "synthetic"
+            src = "synthetic:random_range"
+            maxr = int(kwargs.get("max_market_rounds", MAX_MARKET_ROUNDS))
+            use_lots = False
+        else:
+            mmode = "real"
+            maxr = 0
+            use_lots = True
+            sqlite_store.init_schema()
+            try:
+                q = fetch_gold_spot_usd_per_oz()
+                gp = round(q.usd_per_oz, 2)
+                src = q.source
+            except Exception:
+                gp = 2000.0
+                src = "yfinance:error_fallback(2000)"
+            hist = [gp]
+
+        max_r0 = int(maxr) if mode == "synthetic" else 0
+        task_id = (kwargs.get("task_id") or DEFAULT_TASK_ID).strip().lower()
+        weights = resolve_weights(task_id)
+        try:
+            max_reentries = int(kwargs.get("max_market_reentries", 2))
+            if max_reentries < 0:
+                max_reentries = 0
+        except (TypeError, ValueError):
+            max_reentries = 2
+        s = self._state = JewelryState(
+            episode_id=eid,
             step_count=0,
-            cash=STARTING_CASH,
+            cash=starting_cash,
             gold_oz=0.0,
-            gold_price=gold_price,
-            gold_price_history=[gold_price],
+            gold_price=gp,
+            gold_price_history=hist,
             market_round=0,
-            demand=demand,
+            max_market_rounds=max_r0,
+            demand=dem,
+            demand_forecast=dem_fc,
             inventory={"ring": 0, "necklace": 0, "bracelet": 0},
             phase="market",
             product_for_sale=None,
@@ -132,379 +334,371 @@ class JewelryShopEnvironment(Environment):
             negotiation_round=0,
             current_offer=0.0,
             base_offer=0.0,
-            lowest_price_seen=gold_price,
+            lowest_price_seen=gp,
+            inventory_urgent=inv_urgent,
+            need_gold_grams=need_g,
+            buy_deadline_iso=deadline,
+            use_fifo_lots=use_lots,
+            gold_price_source=src,
+            market_mode=mmode,
+            task_id=task_id,
+            weights=list(weights),
+            cumulative_reward=0.0,
+            last_phase_emitted_reward=0.0,
+            market_reentries=0,
+            max_market_reentries=max_reentries,
         )
         self._r1 = 0.0
         self._r2 = 0.0
-
-        return JewelryObservation(
-            done=False,
-            reward=None,
-            phase="market",
-            cash=STARTING_CASH,
-            gold_oz=0.0,
-            gold_price=gold_price,
-            gold_price_history=[gold_price],
-            market_round=0,
-            max_market_rounds=MAX_MARKET_ROUNDS,
-            demand=demand,
-            product_catalog=PRODUCT_CATALOG,
-            inventory={"ring": 0, "necklace": 0, "bracelet": 0},
-            product_for_sale=None,
-            cost_basis=0.0,
-            current_offer=None,
-            negotiation_round=0,
-            message=(
-                f"Welcome to the Jewelry Shop! Today's gold price is ${gold_price}/oz. "
-                f"You have ${STARTING_CASH}. You can 'buy' gold or 'wait' for a better price. "
-                f"Market rounds remaining: {MAX_MARKET_ROUNDS}."
+        self._r3 = 0.0
+        sstep = s.max_market_rounds if s.max_market_rounds else 0
+        o = self._co_market(
+            msg=(
+                f"Welcome. Task='{task_id}' weights(market,warehouse,showroom)={weights}. "
+                f"Gold: ${gp}/oz ({s.gold_price_source}). Cash: ${s.cash:.2f}. "
+                f"Inventory need-urgent={inv_urgent}."
+                f" {self._mm_line()}"
             ),
         )
-
-    # ── STEP ───────────────────────────────────
+        o["max_market_rounds"] = sstep
+        return self._obs_from(o)
 
     def step(self, action: JewelryAction, timeout_s=None, **kwargs) -> JewelryObservation:
         self._state.step_count += 1
-        phase = self._state.phase
-
-        if phase == "market":
+        if self._state.phase == "market":
+            self._apply_action_inventory_fields(action)
+        if self._state.phase == "market":
             return self._step_market(action)
-        elif phase == "warehouse":
+        if self._state.phase == "warehouse":
             return self._step_warehouse(action)
-        elif phase == "showroom":
+        if self._state.phase == "showroom":
             return self._step_showroom(action)
-        else:
-            raise ValueError(f"Unknown phase: {phase}")
+        raise ValueError(f"Unknown phase: {self._state.phase}")
 
-    # ── PHASE 1: MARKET ────────────────────────
+    def _refresh_real_quote(self) -> None:
+        s = self._state
+        if s.market_mode != "real":
+            return
+        try:
+            q = fetch_gold_spot_usd_per_oz()
+            s.gold_price = round(q.usd_per_oz, 2)
+            s.gold_price_source = q.source
+        except Exception as exc:  # noqa: BLE001
+            fb = s.gold_price if s.gold_price > 0 else 2000.0
+            q2 = last_quote_or_fallback(fb)
+            s.gold_price = round(q2.usd_per_oz, 2)
+            s.gold_price_source = f"{q2.source}(err:{type(exc).__name__})"
+        s.gold_price_history.append(s.gold_price)
+        s.lowest_price_seen = min(s.lowest_price_seen, s.gold_price) if s.lowest_price_seen else s.gold_price
 
     def _step_market(self, action: JewelryAction) -> JewelryObservation:
         s = self._state
         market_action = (action.market_action or "wait").lower().strip()
 
-        if market_action == "buy":
-            gold_qty = action.gold_qty or 0.0
-            total_cost = gold_qty * s.gold_price
-
-            if gold_qty <= 0 or total_cost > s.cash:
-                # Failed transaction — stay in market
-                return JewelryObservation(
-                    done=False,
-                    reward=0.0,
-                    phase="market",
-                    cash=s.cash,
-                    gold_oz=s.gold_oz,
-                    gold_price=s.gold_price,
-                    gold_price_history=list(s.gold_price_history),
-                    market_round=s.market_round,
-                    max_market_rounds=MAX_MARKET_ROUNDS,
-                    demand=s.demand,
-                    product_catalog=PRODUCT_CATALOG,
-                    inventory=s.inventory,
-                    message=(
-                        f"Transaction failed. Tried to buy {gold_qty}oz "
-                        f"(${total_cost:.2f}) but you have ${s.cash:.2f}. "
-                        f"Try a smaller quantity or wait."
-                    ),
-                )
-
-            # Successful buy
-            s.cash -= total_cost
-            s.gold_oz += gold_qty
-            self._r1 = compute_r1(s.gold_price, s.lowest_price_seen)
+        if s.market_mode == "synthetic":
+            return self._step_market_synthetic(action, market_action)
+        return self._step_market_real(action, market_action)
 
-            # Advance to warehouse
+    def _step_market_synthetic(self, action: JewelryAction, market_action: str) -> JewelryObservation:
+        s = self._state
+        if market_action == "buy":
+            return self._exec_buy_synthetic_common(action, market_action)
+        s.market_round += 1
+        if s.market_round >= (s.max_market_rounds or MAX_MARKET_ROUNDS) and s.max_market_rounds is not None and s.max_market_rounds > 0:
             s.phase = "warehouse"
+            self._r1 = 0.0
+            o = self._co_market(keep_phase="warehouse", msg="(Synthetic) Market round limit — entering warehouse with no new purchase.")
+            return self._obs_from(o)
+        ch = random.uniform(-PRICE_FLUCTUATION, PRICE_FLUCTUATION)
+        np = round(s.gold_price * (1 + ch), 2)
+        s.gold_price = max(np, 50.0)
+        s.gold_price_history.append(s.gold_price)
+        s.lowest_price_seen = min(s.lowest_price_seen, s.gold_price) if s.lowest_price_seen else s.gold_price
+        o = self._co_market(
+            msg=f"(Synthetic) New quote ${s.gold_price}/oz. History (last 5): {s.gold_price_history[-5:]!s}. {self._mm_line()}",
+        )
+        return self._obs_from(o)
 
-            return JewelryObservation(
-                done=False,
-                reward=self._r1,
-                phase="warehouse",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                gold_price_history=list(s.gold_price_history),
-                market_round=s.market_round,
-                max_market_rounds=MAX_MARKET_ROUNDS,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                message=(
-                    f"Bought {gold_qty}oz of gold at ${s.gold_price}/oz "
-                    f"for ${total_cost:.2f}. Cash remaining: ${s.cash:.2f}. "
-                    f"Now check your warehouse. Which product to craft? "
-                    f"Options: ring (1oz gold + $200), necklace (2oz + $300), bracelet (0.5oz + $100)."
-                ),
-            )
-
-        else:
-            # Agent chose to WAIT — advance market round
-            s.market_round += 1
+    def _exec_buy_synthetic_common(self, action: JewelryAction, market_action: str) -> JewelryObservation:
+        return self._step_market_buy_and_advance(
+            action,
+            persist_db=False,
+        )
 
-            if s.market_round >= MAX_MARKET_ROUNDS:
-                # Forced to buy at current price or skip to warehouse with no gold
-                s.phase = "warehouse"
-                self._r1 = 0.0
-                return JewelryObservation(
-                    done=False,
-                    reward=0.0,
-                    phase="warehouse",
-                    cash=s.cash,
-                    gold_oz=s.gold_oz,
-                    gold_price=s.gold_price,
-                    gold_price_history=list(s.gold_price_history),
-                    market_round=s.market_round,
-                    max_market_rounds=MAX_MARKET_ROUNDS,
-                    demand=s.demand,
-                    product_catalog=PRODUCT_CATALOG,
-                    inventory=s.inventory,
-                    message=(
-                        f"Market closed! You waited too long and didn't buy any gold. "
-                        f"Entering warehouse with {s.gold_oz}oz gold and ${s.cash} cash."
-                    ),
+    def _step_market_real(self, action: JewelryAction, market_action: str) -> JewelryObservation:
+        s = self._state
+        self._refresh_real_quote()
+        if market_action != "buy":
+            if s.inventory_urgent:
+                o = self._co_market(
+                    msg="Urgent (inventory): you must not wait. Submit market_action=buy with a gold_qty you can afford at the current live quote, or 0.01 if testing.",
                 )
-
-            # Price fluctuates ±10%
-            change = random.uniform(-PRICE_FLUCTUATION, PRICE_FLUCTUATION)
-            new_price = round(s.gold_price * (1 + change), 2)
-            new_price = max(new_price, 50.0)  # Floor price
-            s.gold_price = new_price
-            s.gold_price_history.append(new_price)
-            s.lowest_price_seen = min(s.lowest_price_seen, new_price)
-
-            trend = "↑" if change > 0 else "↓"
-            return JewelryObservation(
-                done=False,
-                reward=0.0,
-                phase="market",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=new_price,
-                gold_price_history=list(s.gold_price_history),
-                market_round=s.market_round,
-                max_market_rounds=MAX_MARKET_ROUNDS,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                message=(
-                    f"You waited. Gold price moved {trend} to ${new_price}/oz. "
-                    f"Price history: {s.gold_price_history}. "
-                    f"Rounds left: {MAX_MARKET_ROUNDS - s.market_round}. "
-                    f"Buy now or wait?"
-                ),
+                return self._obs_from(o)
+            s.market_round += 1
+            o = self._co_market(
+                msg=f"Quote refreshed. Gold ${s.gold_price}/oz from {s.gold_price_source}. {self._mm_line()} Rounds so far: {s.market_round}.",
             )
+            return self._obs_from(o)
+        return self._step_market_buy_and_advance(action, persist_db=True)
 
-    # ── PHASE 2: WAREHOUSE ─────────────────────
+    def _step_market_buy_and_advance(self, action: JewelryAction, *, persist_db: bool) -> JewelryObservation:
+        s = self._state
+        market_action = "buy"
+        gold_qty = action.gold_qty
+        if gold_qty is None or float(gold_qty) <= 0:
+            o = self._co_market(
+                msg="Buy failed: set gold_qty to a positive number of troy oz.",
+            )
+            return self._obs_from(o)
+        gold_qty = float(gold_qty)
+        price = s.gold_price
+        total_cost = gold_qty * price
+        if total_cost > s.cash:
+            o = self._co_market(
+                msg=f"Not enough cash: need ${total_cost:.2f} for {gold_qty}oz @ ${price}, have ${s.cash:.2f}.",
+            )
+            return self._obs_from(o)
+        fund_before = s.cash
+        s.cash -= total_cost
+        s.gold_oz += gold_qty
+        s.phase = "warehouse"
+        # The bounce signal was satisfied by this purchase; clear it so the next
+        # warehouse failure (if any) can emit a fresh urgency.
+        s.inventory_urgent = False
+        s.need_gold_grams = None
+        # Only score r1 on the FIRST market visit; bounce-back buys are loop-recovery,
+        # not "good price hunting", so they shouldn't pay phase-1 reward again.
+        if s.market_reentries == 0:
+            self._r1 = compute_r1(s.gold_price, s.lowest_price_seen) if s.lowest_price_seen else 0.0
+            market_partial = self._emit("market", self._r1)
+        else:
+            self._r1 = 0.0
+            market_partial = self._emit("market", 0.0)
+        eid = getattr(s, "episode_id", None) or "unknown"
+        if persist_db and s.use_fifo_lots and eid != "unknown":
+            try:
+                sqlite_store.record_gold_purchase(
+                    eid,
+                    "GOLD",
+                    price,
+                    gold_qty,
+                    round(total_cost, 2),
+                    "BUY",
+                    action.ai_confidence_pct,
+                    action.ai_reasoning,
+                    action.target_price_usd,
+                    fund_before,
+                    s.cash,
+                )
+            except Exception as exc:  # noqa: BLE001
+                s.gold_price_source = f"{s.gold_price_source} | db_log_failed:{type(exc).__name__}"
+        o = self._co_market(
+            reward=market_partial,
+            keep_phase="warehouse",
+            msg=(
+                f"Bought {gold_qty} troy oz at ${price}/oz ($ {total_cost:.2f}). "
+                f"Cash ${s.cash:.2f}. {self._mm_line()} "
+                f"Phase reward(r1={self._r1:.4f} * w_market={s.weights[0]})={market_partial:.4f}. "
+                f"Cumulative={s.cumulative_reward:.4f}. Choose a product in the warehouse."
+            ),
+        )
+        return self._obs_from(o)
+
+    def _can_afford_smallest_buy(self) -> bool:
+        """
+        Loop guard: are we even theoretically able to buy *some* useful gold?
+        We require cash >= price * smallest product's gold need (i.e. enough
+        for at least one bracelet's worth of gold). If not, bouncing back to
+        market is wasteful and we should stop the loop.
+        """
+        s = self._state
+        if s.gold_price <= 0:
+            return False
+        cheapest_gold_oz = min(spec["gold_oz"] for spec in PRODUCT_CATALOG.values())
+        return s.cash >= s.gold_price * cheapest_gold_oz
+
+    def _bounce_to_market(self, choice: str, grams_needed: float, reason: str) -> JewelryObservation:
+        """
+        Inventory -> Market loop: send the agent back to the market phase to
+        buy more gold, with urgency flags so the market step won't allow waits.
+        Emits 0.0 reward; final episode score still bounded in [0, 1].
+        """
+        s = self._state
+        s.market_reentries += 1
+        s.phase = "market"
+        s.market_round = 0  # fresh patience counter for this re-entry
+        s.inventory_urgent = True
+        s.need_gold_grams = round(grams_needed, 4)
+        bounce_partial = self._emit("warehouse", 0.0)
+        o = self._co_market(reward=bounce_partial, keep_phase="market")
+        o["message"] = (
+            f"Inventory needs more gold to craft {choice} ({reason}). "
+            f"Bouncing back to MARKET (re-entry {s.market_reentries}/{s.max_market_reentries}). "
+            f"Need ~{grams_needed:.2f} g. inventory_urgent=True; market_action='wait' will be blocked. "
+            f"Cumulative={s.cumulative_reward:.4f}."
+        )
+        o["product_for_sale"] = None
+        o["current_offer"] = None
+        o["cost_basis"] = 0.0
+        return self._obs_from(o)
 
     def _step_warehouse(self, action: JewelryAction) -> JewelryObservation:
         s = self._state
         choice = (action.product_choice or "ring").lower().strip()
-
         if choice not in PRODUCT_CATALOG:
-            choice = "ring"  # Default fallback
-
+            choice = "ring"
         spec = PRODUCT_CATALOG[choice]
-        gold_needed = spec["gold_oz"]
+        gold_needed_oz = spec["gold_oz"]
         labor_cost = spec["labor"]
-
-        has_gold = s.gold_oz >= gold_needed
-        has_cash = s.cash >= labor_cost
-
-        if not has_gold or not has_cash:
-            # Cannot craft — skip to showroom with nothing
+        grams_needed = troy_oz_to_grams(gold_needed_oz)
+
+        has_gold_oz = s.gold_oz + 1e-8 >= gold_needed_oz
+        if not has_gold_oz:
+            # Inventory -> market loop: try to buy more gold if budget + bounces remain.
+            if (
+                s.market_reentries < s.max_market_reentries
+                and self._can_afford_smallest_buy()
+            ):
+                return self._bounce_to_market(
+                    choice,
+                    grams_needed,
+                    reason=f"have {s.gold_oz:.4f} oz, need {gold_needed_oz:.4f} oz",
+                )
+            # Out of bounces or no money: customer leaves, episode ends with no sale.
             self._r2 = 0.0
             s.phase = "showroom"
-            reason = (
-                f"not enough gold (need {gold_needed}oz, have {s.gold_oz}oz)"
-                if not has_gold else
-                f"not enough cash for labor (need ${labor_cost}, have ${s.cash:.2f})"
+            o = {**self._co_market(keep_phase="showroom", reward=0.0, msg="")}
+            why = "no bounce-backs left" if s.market_reentries >= s.max_market_reentries else "not enough cash to buy any gold"
+            o["message"] = (
+                f"Cannot craft {choice}: insufficient gold and {why}. "
+                f"Customer walks away. Cumulative={s.cumulative_reward:.4f}."
             )
-            return JewelryObservation(
-                done=False,
-                reward=0.0,
-                phase="showroom",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                gold_price_history=list(s.gold_price_history),
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                product_for_sale=None,
-                cost_basis=0.0,
-                message=f"Cannot craft {choice}: {reason}. Entering showroom with nothing.",
+            o["product_for_sale"] = None
+            o["current_offer"] = None
+            o["cost_basis"] = 0.0
+            return self._obs_from(o)
+        if s.cash < labor_cost:
+            self._r2 = 0.0
+            s.phase = "showroom"
+            o = {**self._co_market(keep_phase="showroom", reward=0.0, msg="")}
+            o["message"] = (
+                f"Cannot craft {choice}: have gold but no cash for labor (${labor_cost:.2f}). "
+                f"Cumulative={s.cumulative_reward:.4f}."
             )
+            o["product_for_sale"] = None
+            o["current_offer"] = None
+            o["cost_basis"] = 0.0
+            return self._obs_from(o)
 
-        # Successful craft
         s.cash -= labor_cost
-        s.gold_oz -= gold_needed
-        s.inventory[choice] = s.inventory.get(choice, 0) + 1
-        s.cost_basis = s.gold_price * gold_needed + labor_cost
-        s.product_for_sale = choice
-
+        eid = getattr(s, "episode_id", None) or "unknown"
+        if s.use_fifo_lots and s.market_mode == "real" and eid != "unknown":
+            ok, gold_cost, _d = sqlite_store.fifo_consume_grams(eid, grams_needed)
+            if not ok:
+                s.cash += labor_cost
+                self._r2 = 0.0
+                s.phase = "showroom"
+                o_ = {**self._co_market(keep_phase="showroom", reward=0.0, msg="")}
+                o_["message"] = "FIFO: not enough gold lots in the database for this episode (or oz/gram mismatch)."
+                o_["product_for_sale"] = None
+                o_["current_offer"] = None
+                o_["cost_basis"] = 0.0
+                return self._obs_from(o_)
+            s.gold_oz -= gold_needed_oz
+            s.inventory[choice] = s.inventory.get(choice, 0) + 1
+            s.product_for_sale = choice
+            s.cost_basis = float(gold_cost) + float(labor_cost)
+        else:
+            s.gold_oz -= gold_needed_oz
+            s.inventory[choice] = s.inventory.get(choice, 0) + 1
+            s.product_for_sale = choice
+            s.cost_basis = s.gold_price * gold_needed_oz + labor_cost
         self._r2 = compute_r2(choice, s.demand)
-
-        # Generate customer offer based on demand and cost basis
-        demand_factor = s.demand.get(choice, 0.5)
-        offer_ratio = random.uniform(OFFER_MIN_RATIO, OFFER_MAX_RATIO) + (demand_factor * DEMAND_OFFER_BONUS)
-        base_offer = round(s.cost_basis * offer_ratio, 2)
-        s.base_offer = base_offer
-        s.current_offer = base_offer
+        warehouse_partial = self._emit("warehouse", self._r2)
+        dmf = s.demand.get(choice, 0.5)
+        offer_ratio = random.uniform(OFFER_MIN_RATIO, OFFER_MAX_RATIO) + (dmf * DEMAND_OFFER_BONUS)
+        s.base_offer = round(s.cost_basis * offer_ratio, 2)
+        s.current_offer = s.base_offer
         s.phase = "showroom"
         s.negotiation_round = 0
-
-        return JewelryObservation(
-            done=False,
-            reward=self._r2,
-            phase="showroom",
-            cash=s.cash,
-            gold_oz=s.gold_oz,
-            gold_price=s.gold_price,
-            gold_price_history=list(s.gold_price_history),
-            demand=s.demand,
-            product_catalog=PRODUCT_CATALOG,
-            inventory=s.inventory,
-            product_for_sale=choice,
-            cost_basis=s.cost_basis,
-            current_offer=s.current_offer,
-            negotiation_round=0,
-            message=(
-                f"Crafted a {choice}! Cost basis: ${s.cost_basis:.2f} "
-                f"(gold ${s.gold_price * gold_needed:.2f} + labor ${labor_cost}). "
-                f"Demand for {choice}: {demand_factor:.0%}. "
-                f"A customer offers ${s.current_offer:.2f}. Accept, counter, or reject?"
-            ),
+        o2 = {**self._co_market(keep_phase="showroom")}
+        o2["reward"] = warehouse_partial
+        o2["product_for_sale"] = choice
+        o2["cost_basis"] = s.cost_basis
+        o2["current_offer"] = s.current_offer
+        _cost_label = (
+            "FIFO (SQLite lots) gold + labor"
+            if s.use_fifo_lots and s.market_mode == "real" and eid != "unknown"
+            else "market gold + labor"
         )
-
-    # ── PHASE 3: SHOWROOM ──────────────────────
+        o2["message"] = (
+            f"Crafted {choice}. Cost ({_cost_label}): ${s.cost_basis:.2f}. "
+            f"Phase reward(r2={self._r2:.4f} * w_warehouse={s.weights[1]})={warehouse_partial:.4f}. "
+            f"Cumulative={s.cumulative_reward:.4f}. Customer offers ${s.current_offer:.2f}."
+        )
+        return self._obs_from(o2)
 
     def _step_showroom(self, action: JewelryAction) -> JewelryObservation:
         s = self._state
-
-        # No product → episode ends immediately
         if s.product_for_sale is None:
-            return JewelryObservation(
-                done=True,
-                reward=combined_reward(self._r1, self._r2, 0.0),
-                phase="showroom",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                product_for_sale=None,
-                cost_basis=0.0,
-                message="No products to sell. Episode over.",
+            self._r3 = 0.0
+            showroom_partial = self._emit("showroom", 0.0)
+            o3 = {**self._co_market(done=True, reward=showroom_partial, keep_phase="showroom")}
+            o3["message"] = (
+                "No products to sell. Episode over. "
+                f"Phase reward(r3=0 * w_showroom={s.weights[2]})=0.0000. "
+                f"Cumulative={s.cumulative_reward:.4f}."
             )
-
+            o3["product_for_sale"] = None
+            o3["current_offer"] = s.current_offer
+            return self._obs_from(o3)
         message = action.message or ""
         intent = detect_intent(message)
-
-        # ── ACCEPT ──
         if intent == "accept":
-            r3 = compute_r3(s.current_offer, s.cost_basis)
-            final_reward = combined_reward(self._r1, self._r2, r3)
+            self._r3 = compute_r3(s.current_offer, s.cost_basis)
+            showroom_partial = self._emit("showroom", self._r3)
             s.cash += s.current_offer
             s.inventory[s.product_for_sale] -= 1
-            product_sold = s.product_for_sale
+            _ps = s.product_for_sale
             s.product_for_sale = None
-
-            return JewelryObservation(
-                done=True,
-                reward=final_reward,
-                phase="showroom",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                product_for_sale=None,
-                cost_basis=s.cost_basis,
-                current_offer=s.current_offer,
-                negotiation_round=s.negotiation_round,
-                message=(
-                    f"Deal! Sold {product_sold} for ${s.current_offer:.2f}. "
-                    f"Profit: ${s.current_offer - s.cost_basis:.2f}. "
-                    f"Final reward: {final_reward}."
-                ),
+            o4 = {**self._co_market(done=True, reward=showroom_partial, keep_phase="showroom")}
+            o4["message"] = (
+                f"Sold {_ps} for ${s.current_offer:.2f}. "
+                f"Phase reward(r3={self._r3:.4f} * w_showroom={s.weights[2]})={showroom_partial:.4f}. "
+                f"Cumulative(final)={s.cumulative_reward:.4f}."
             )
-
-        # ── REJECT ──
+            o4["product_for_sale"] = None
+            o4["current_offer"] = s.current_offer
+            return self._obs_from(o4)
         if intent == "reject":
-            final_reward = combined_reward(self._r1, self._r2, 0.0)
-            return JewelryObservation(
-                done=True,
-                reward=final_reward,
-                phase="showroom",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                product_for_sale=s.product_for_sale,
-                cost_basis=s.cost_basis,
-                current_offer=s.current_offer,
-                negotiation_round=s.negotiation_round,
-                message=(
-                    f"You rejected the offer. Customer left. "
-                    f"Final reward: {final_reward}."
-                ),
+            self._r3 = 0.0
+            showroom_partial = self._emit("showroom", 0.0)
+            o5 = {**self._co_market(done=True, reward=showroom_partial, keep_phase="showroom")}
+            o5["message"] = (
+                f"Rejected. Phase reward(r3=0 * w_showroom={s.weights[2]})=0.0000. "
+                f"Cumulative(final)={s.cumulative_reward:.4f}."
             )
-
-        # ── COUNTER ──
+            o5["product_for_sale"] = s.product_for_sale
+            o5["current_offer"] = s.current_offer
+            return self._obs_from(o5)
         s.negotiation_round += 1
-
         if s.negotiation_round >= MAX_NEGOTIATION:
-            final_reward = combined_reward(self._r1, self._r2, 0.0)
-            return JewelryObservation(
-                done=True,
-                reward=final_reward,
-                phase="showroom",
-                cash=s.cash,
-                gold_oz=s.gold_oz,
-                gold_price=s.gold_price,
-                demand=s.demand,
-                product_catalog=PRODUCT_CATALOG,
-                inventory=s.inventory,
-                product_for_sale=s.product_for_sale,
-                cost_basis=s.cost_basis,
-                current_offer=s.current_offer,
-                negotiation_round=s.negotiation_round,
-                message=(
-                    f"Customer left after {MAX_NEGOTIATION} rounds. "
-                    f"Final reward: {final_reward}."
-                ),
+            self._r3 = 0.0
+            showroom_partial = self._emit("showroom", 0.0)
+            o6 = {**self._co_market(done=True, reward=showroom_partial, keep_phase="showroom")}
+            o6["message"] = (
+                f"Max negotiation rounds reached. "
+                f"Phase reward(r3=0 * w_showroom={s.weights[2]})=0.0000. "
+                f"Cumulative(final)={s.cumulative_reward:.4f}."
             )
-
-        # Customer raises offer by 5%
+            return self._obs_from(o6)
         s.current_offer = round(s.current_offer * COUNTER_BUMP, 2)
-
-        return JewelryObservation(
-            done=False,
-            reward=0.0,
-            phase="showroom",
-            cash=s.cash,
-            gold_oz=s.gold_oz,
-            gold_price=s.gold_price,
-            demand=s.demand,
-            product_catalog=PRODUCT_CATALOG,
-            inventory=s.inventory,
-            product_for_sale=s.product_for_sale,
-            cost_basis=s.cost_basis,
-            current_offer=s.current_offer,
-            negotiation_round=s.negotiation_round,
-            message=(
-                f"Customer raises to ${s.current_offer:.2f} "
-                f"(round {s.negotiation_round}/{MAX_NEGOTIATION}). "
-                f"Accept, counter, or reject?"
-            ),
-        )
-
-    # ── STATE PROPERTY ─────────────────────────
+        o7 = {**self._co_market(keep_phase="showroom", reward=0.0, msg="")}
+        o7["message"] = f"Customer at ${s.current_offer:.2f} (round {s.negotiation_round})."
+        o7["current_offer"] = s.current_offer
+        o7["product_for_sale"] = s.product_for_sale
+        return self._obs_from(o7)
 
     @property
     def state(self) -> JewelryState:
-        return self._state
+        return self._state

server/app.py

@@ -1,5 +1,15 @@
+import os
+from pathlib import Path
+
 from openenv.core.env_server import create_fastapi_app
 
+try:
+    from dotenv import load_dotenv as _load_dotenv
+except ImportError:
+    def _load_dotenv(_path: str) -> bool:  # type: ignore[misc]
+        return False
+
+
 try:
     from .ShopManagerEng_environment import JewelryShopEnvironment
     from ..models import JewelryAction, JewelryObservation
@@ -9,7 +19,23 @@ except ImportError:
 
 import uvicorn
 
-app = create_fastapi_app(JewelryShopEnvironment, JewelryAction, JewelryObservation)
+# Load .env from this package (ShopManagerEng/.env) for FRED/keys when running the server
+_env = Path(__file__).resolve().parent.parent / ".env"
+if _env.is_file():
+    _load_dotenv(_env)
+
+# RL trainers (TRL GRPO, etc.) open one WebSocket per parallel rollout. With
+# num_generations=8 + per_device_train_batch_size>=8 you can easily need 8-16
+# concurrent envs. Default max is 1, so we bump it. Override via env var
+# SHOPMANAGER_MAX_CONCURRENT_ENVS for hosted Spaces with tighter budgets.
+_MAX_CONCURRENT_ENVS = int(os.environ.get("SHOPMANAGER_MAX_CONCURRENT_ENVS", "16"))
+
+app = create_fastapi_app(
+    JewelryShopEnvironment,
+    JewelryAction,
+    JewelryObservation,
+    max_concurrent_envs=_MAX_CONCURRENT_ENVS,
+)
 
 def main():
     uvicorn.run(app, host="0.0.0.0", port=8000)

server/market_data.py

@@ -0,0 +1,57 @@
+"""
+Live gold (USD / troy oz) via yfinance, aligned with api_key_test.py (GC=F).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+
+@dataclass
+class GoldPriceQuote:
+    usd_per_oz: float
+    source: str
+
+
+def os_gold_symbol() -> str:
+    import os
+
+    return (os.environ.get("SHOPMANAGER_GOLD_SYMBOL", "GC=F") or "GC=F").strip()
+
+
+def _fetch_yfinance_gold() -> Tuple[float, str, List[float]]:
+    import yfinance as yf
+
+    sym = (os_gold_symbol() or "GC=F").strip() or "GC=F"
+    ticker = yf.Ticker(sym)
+    hist = ticker.history(period="60d", interval="1d")
+    if hist is None or hist.empty:
+        raise ValueError("No price history for gold symbol")
+    closes = hist["Close"].dropna().astype(float).tolist()
+    if not closes:
+        raise ValueError("Empty close series for gold")
+    return float(closes[-1]), f"yfinance:{sym}", [float(c) for c in closes[-30:]]
+
+
+def fetch_gold_spot_usd_per_oz() -> GoldPriceQuote:
+    usd, src, _ = _fetch_yfinance_gold()
+    if usd <= 0:
+        raise ValueError("Invalid non-positive gold price")
+    return GoldPriceQuote(usd_per_oz=usd, source=src)
+
+
+def recent_close_history(max_points: int = 30) -> List[float]:
+    try:
+        _, _, hist = _fetch_yfinance_gold()
+    except Exception:
+        return []
+    if max_points and len(hist) > max_points:
+        return hist[-max_points:]
+    return list(hist)
+
+
+def last_quote_or_fallback(fallback: float) -> GoldPriceQuote:
+    try:
+        return fetch_gold_spot_usd_per_oz()
+    except Exception:
+        return GoldPriceQuote(usd_per_oz=fallback, source="fallback")

server/requirements.txt

@@ -1,6 +0,0 @@
-openenv[core]>=0.2.0
-fastapi>=0.115.0
-uvicorn>=0.24.0
-
-
-

server/sqlite_store.py

@@ -0,0 +1,208 @@
+"""
+SQLite persistence: market gold purchase invoices (troy oz) and per-gram lots (FIFO for warehouse).
+"""
+from __future__ import annotations
+
+import sqlite3
+import time
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+try:
+    from ..constants import GRAMS_PER_TROY_OZ, default_sqlite_path, get_sqlite_path
+except ImportError:
+    # `python -c` / `import server` from the ShopManagerEng/ folder: `server` is a top module,
+    # so `..constants` is invalid. Parent package constants.py lives as a sibling of `server/`.
+    from constants import GRAMS_PER_TROY_OZ, default_sqlite_path, get_sqlite_path
+
+
+def _db_path() -> str:
+    p = get_sqlite_path()
+    return p if p else default_sqlite_path()
+
+
+def _connect() -> sqlite3.Connection:
+    path = _db_path()
+    from pathlib import Path
+
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path, check_same_thread=False, timeout=30.0)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_schema() -> None:
+    with _connect() as c:
+        c.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS gold_purchases (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                episode_id TEXT NOT NULL,
+                product_name TEXT NOT NULL,
+                buy_price_usd REAL NOT NULL,
+                quantity_oz REAL NOT NULL,
+                cost_usd REAL NOT NULL,
+                ai_decision TEXT NOT NULL,
+                ai_confidence_pct REAL,
+                ai_reasoning TEXT,
+                target_price_usd REAL,
+                bought_at TEXT NOT NULL,
+                fund_before_usd REAL NOT NULL,
+                fund_after_usd REAL NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_gold_purchases_episode
+                ON gold_purchases (episode_id);
+            CREATE TABLE IF NOT EXISTS gold_grams_lots (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                purchase_id INTEGER NOT NULL,
+                episode_id TEXT NOT NULL,
+                product_name TEXT NOT NULL,
+                buy_price_usd_per_gram REAL NOT NULL,
+                quantity_grams_total REAL NOT NULL,
+                quantity_grams_remaining REAL NOT NULL,
+                bought_at TEXT NOT NULL,
+                FOREIGN KEY (purchase_id) REFERENCES gold_purchases (id)
+            );
+            CREATE INDEX IF NOT EXISTS idx_lots_episode_bought
+                ON gold_grams_lots (episode_id, bought_at, id);
+            """
+        )
+        c.commit()
+
+
+@dataclass
+class PurchaseRow:
+    id: int
+    buy_price_usd: float
+    quantity_oz: float
+    cost_usd: float
+    target_price_usd: Optional[float]
+    fund_before_usd: float
+    fund_after_usd: float
+    bought_at: str
+
+
+def record_gold_purchase(
+    episode_id: str,
+    product_name: str,
+    buy_price_usd: float,
+    quantity_oz: float,
+    cost_usd: float,
+    ai_decision: str,
+    ai_confidence_pct: Optional[float],
+    ai_reasoning: Optional[str],
+    target_price_usd: Optional[float],
+    fund_before_usd: float,
+    fund_after_usd: float,
+) -> Tuple[int, int]:
+    """
+    Inserts into gold_purchases and gold_grams_lots. Returns (purchase_id, lot_id).
+    """
+    init_schema()
+    now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    g_total = round(quantity_oz * GRAMS_PER_TROY_OZ, 6)
+    ppg = round(buy_price_usd / GRAMS_PER_TROY_OZ, 8) if GRAMS_PER_TROY_OZ > 0 else 0.0
+    ai_r = (ai_reasoning or "").strip() or None
+    with _connect() as c:
+        cur = c.execute(
+            """
+            INSERT INTO gold_purchases (
+                episode_id, product_name, buy_price_usd, quantity_oz, cost_usd,
+                ai_decision, ai_confidence_pct, ai_reasoning, target_price_usd,
+                bought_at, fund_before_usd, fund_after_usd
+            ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)
+            """,
+            (
+                episode_id,
+                product_name,
+                buy_price_usd,
+                quantity_oz,
+                cost_usd,
+                ai_decision,
+                ai_confidence_pct,
+                ai_r,
+                target_price_usd,
+                now,
+                fund_before_usd,
+                fund_after_usd,
+            ),
+        )
+        purchase_id = int(cur.lastrowid)
+        cur2 = c.execute(
+            """
+            INSERT INTO gold_grams_lots (
+                purchase_id, episode_id, product_name, buy_price_usd_per_gram,
+                quantity_grams_total, quantity_grams_remaining, bought_at
+            ) VALUES (?,?,?,?,?,?,?)
+            """,
+            (
+                purchase_id,
+                episode_id,
+                product_name,
+                ppg,
+                g_total,
+                g_total,
+                now,
+            ),
+        )
+        lot_id = int(cur2.lastrowid)
+        c.commit()
+    return purchase_id, lot_id
+
+
+def fifo_consume_grams(
+    episode_id: str, grams_needed: float
+) -> Tuple[bool, float, List[dict]]:
+    """
+    Uses oldest lots first. Returns (ok, total_usd_cost, details).
+    """
+    if grams_needed <= 0:
+        return True, 0.0, []
+    init_schema()
+    rem = float(grams_needed)
+    total_usd = 0.0
+    details: List[dict] = []
+    with _connect() as c:
+        cur = c.execute(
+            """
+            SELECT id, quantity_grams_remaining, buy_price_usd_per_gram
+            FROM gold_grams_lots
+            WHERE episode_id = ? AND quantity_grams_remaining > 0.0000001
+            ORDER BY bought_at ASC, id ASC
+            """,
+            (episode_id,),
+        )
+        rows = cur.fetchall()
+        for row in rows:
+            if rem <= 1e-9:
+                break
+            lot_id = int(row["id"])
+            qrem = float(row["quantity_grams_remaining"])
+            ppg = float(row["buy_price_usd_per_gram"])
+            take = min(qrem, rem)
+            cost = take * ppg
+            new_rem = round(qrem - take, 6)
+            c.execute(
+                "UPDATE gold_grams_lots SET quantity_grams_remaining = ? WHERE id = ?",
+                (new_rem, lot_id),
+            )
+            rem -= take
+            total_usd += cost
+            details.append(
+                {
+                    "lot_id": lot_id,
+                    "grams": take,
+                    "cost_usd": round(cost, 4),
+                }
+            )
+        c.commit()
+    if rem > 1e-5:
+        return False, 0.0, []
+    return True, round(total_usd, 4), details
+
+
+def ensure_schema_once() -> None:
+    try:
+        init_schema()
+    except Exception:
+        pass

test_env_smoke.py

@@ -0,0 +1,118 @@
+"""Standalone, no-LLM, no-server smoke tests for the JewelryShop env.
+
+Run from inside the ShopManagerEng folder so `models` / `server` import.
+
+Usage:
+    cd ShopManagerEng
+    SHOPMANAGER_MARKET_MODE=synthetic python test_env_smoke.py            # default: A+B
+    SHOPMANAGER_MARKET_MODE=real      python test_env_smoke.py live       # C only
+    python test_env_smoke.py all                                          # all three
+
+Why a script: putting `f'gold_price=${o.gold_price}/oz'` inside `bash -c "..."`
+makes bash try to expand `${o.gold_price}` as a shell variable and crash with
+`bad substitution`. Running it from a .py file removes that whole class of bugs.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from server.ShopManagerEng_environment import JewelryShopEnvironment
+from models import JewelryAction
+
+
+def test_reward_path() -> None:
+    """A. Synthetic episode end-to-end, prints per-step partial + cumulative."""
+    print("\n=== A. reward path (synthetic) ===")
+    os.environ["SHOPMANAGER_MARKET_MODE"] = "synthetic"
+    e = JewelryShopEnvironment()
+    o = e.reset(seed=42, task_id="market_timing", starting_cash=10000.0)
+    print(
+        f"  reset: phase={o.phase} cash=${o.cash} gold={o.gold_oz}oz "
+        f"price=${o.gold_price} weights={o.weights}"
+    )
+
+    actions = [
+        JewelryAction(market_action="buy", gold_qty=1.0),
+        JewelryAction(product_choice="ring"),
+        JewelryAction(message="I accept"),
+    ]
+    for i, a in enumerate(actions, 1):
+        o = e.step(a)
+        print(
+            f"  step {i}: phase={o.phase} reward={o.reward:.4f} "
+            f"cum={o.cumulative_reward:.4f} done={o.done}"
+        )
+    print(f"  FINAL cum={o.cumulative_reward:.4f} (must be in [0, 1])")
+
+
+def test_bounce_loop() -> None:
+    """B. Warehouse cannot craft -> agent is bounced back to MARKET."""
+    print("\n=== B. bounce loop (warehouse -> market) ===")
+    os.environ["SHOPMANAGER_MARKET_MODE"] = "synthetic"
+    e = JewelryShopEnvironment()
+    o = e.reset(seed=42, task_id="profit_negotiator", starting_cash=10000.0)
+
+    o = e.step(JewelryAction(market_action="buy", gold_qty=0.2))
+    print(f"  bought 0.2oz: phase={o.phase}, gold={o.gold_oz}oz")
+
+    o = e.step(JewelryAction(product_choice="ring"))
+    print(
+        f"  tried ring: phase={o.phase} reentries={o.market_reentries}"
+        f"/{o.max_market_reentries} urgent={o.inventory_urgent} "
+        f"cannot_wait={o.cannot_wait}"
+    )
+    assert o.phase == "market", "expected bounce back to market"
+    assert o.inventory_urgent is True, "expected urgent flag"
+
+    o = e.step(JewelryAction(market_action="wait"))
+    print(f"  tried wait while urgent: phase={o.phase} (should still be market)")
+    assert o.phase == "market", "wait should be blocked when urgent"
+
+    o = e.step(JewelryAction(market_action="buy", gold_qty=1.0))
+    print(f"  bought 1.0oz more: phase={o.phase} gold={o.gold_oz}oz")
+
+    o = e.step(JewelryAction(product_choice="ring"))
+    print(f"  craft ring: phase={o.phase} cum={o.cumulative_reward:.4f}")
+
+    o = e.step(JewelryAction(message="I accept"))
+    print(f"  FINAL cum={o.cumulative_reward:.4f}")
+
+
+def test_live_quote() -> None:
+    """C. Real mode: live yfinance gold price (needs network)."""
+    print("\n=== C. live yfinance quote (real mode) ===")
+    os.environ["SHOPMANAGER_MARKET_MODE"] = "real"
+    e = JewelryShopEnvironment()
+    o = e.reset(seed=0, task_id="market_timing", starting_cash=10000.0)
+    print(f"  gold_price=${o.gold_price}/oz   source={o.gold_price_source}")
+    print(f"  market_mode={o.market_mode}")
+    print(f"  history(last 5)={o.gold_price_history[-5:]}")
+
+
+def main(argv: list[str]) -> None:
+    arg = (argv[1] if len(argv) > 1 else "default").lower()
+
+    if arg in ("default", "ab"):
+        test_reward_path()
+        test_bounce_loop()
+    elif arg == "live":
+        test_live_quote()
+    elif arg == "all":
+        test_reward_path()
+        test_bounce_loop()
+        test_live_quote()
+    elif arg == "a":
+        test_reward_path()
+    elif arg == "b":
+        test_bounce_loop()
+    elif arg == "c":
+        test_live_quote()
+    else:
+        print(f"unknown arg: {arg}. use one of: a / b / c / ab / live / all")
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main(sys.argv)