Upload folder using huggingface_hub

Dockerfile

@@ -1,81 +1,81 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Multi-stage build using openenv-base
-# This Dockerfile is flexible and works for both:
-# - In-repo environments (with local OpenEnv sources)
-# - Standalone environments (with openenv from PyPI/Git)
-# The build script (openenv build) handles context detection and sets appropriate build args.
-
-ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
-FROM ${BASE_IMAGE} AS builder
-
-WORKDIR /app
-
-# Ensure git is available (required for installing dependencies from VCS)
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends git && \
-    rm -rf /var/lib/apt/lists/*
-
-# Build argument to control whether we're building standalone or in-repo
-ARG BUILD_MODE=in-repo
-ARG ENV_NAME=ShopManagerEng
-
-# Copy environment code (always at root of build context)
-COPY . /app/env
-
-# For in-repo builds, openenv is already vendored in the build context
-# For standalone builds, openenv will be installed via pyproject.toml
-WORKDIR /app/env
-
-# Ensure uv is available (for local builds where base image lacks it)
-RUN if ! command -v uv >/dev/null 2>&1; then \
-        curl -LsSf https://astral.sh/uv/install.sh | sh && \
-        mv /root/.local/bin/uv /usr/local/bin/uv && \
-        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
-    fi
-    
-# Install dependencies using uv sync
-# If uv.lock exists, use it; otherwise resolve on the fly
-RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --frozen --no-install-project --no-editable; \
-    else \
-        uv sync --no-install-project --no-editable; \
-    fi
-
-RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --frozen --no-editable; \
-    else \
-        uv sync --no-editable; \
-    fi
-
-# Final runtime stage
-FROM ${BASE_IMAGE}
-
-WORKDIR /app
-
-# Copy the virtual environment from builder
-COPY --from=builder /app/env/.venv /app/.venv
-
-# Copy the environment code
-COPY --from=builder /app/env /app/env
-
-# Set PATH to use the virtual environment
-ENV PATH="/app/.venv/bin:$PATH"
-
-# Set PYTHONPATH so imports work correctly
-ENV PYTHONPATH="/app/env:$PYTHONPATH"
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
-
-# Run the FastAPI server
-# The module path is constructed to work with the /app/env structure
-ENV ENABLE_WEB_INTERFACE=true
-CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=ShopManagerEng
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hardik Makwana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,154 +1,154 @@
----
-title: Shopmanagereng Environment Server
-emoji: 🎖️
-colorFrom: green
-colorTo: blue
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
----
-
-# Jewelry Shop Manager — RL Environment
-
-A reinforcement learning environment simulating a **jewelry shop management** pipeline. An AI agent navigates three sequential phases — buying raw materials, selecting products to craft based on demand, and negotiating sales — to maximize profit.
-
-## Environment Overview
-
-### Phase 1: Market (Buy / Wait)
-
-- Gold prices **fluctuate ±10% each round** (up to 3 rounds).
-- The agent analyzes price trends and decides to **buy** gold or **wait** for a better price.
-- Goal: Buy gold at the lowest possible price while reserving cash for crafting labor.
-
-### Phase 2: Warehouse (Product Selection)
-
-- The agent sees **demand levels** for each product type:
-
-| Product   | Gold (oz) | Labor ($) | Demand Range |
-|-----------|-----------|-----------|--------------|
-| Ring      | 1.0       | $200      | 40-100%      |
-| Necklace  | 2.0       | $300      | 20-80%       |
-| Bracelet  | 0.5       | $100      | 10-60%       |
-
-- The agent picks the **highest-demand product** it can afford to craft.
-- Goal: Match production to market demand.
-
-### Phase 3: Showroom (Negotiation)
-
-- A customer makes an initial offer based on cost basis and product demand.
-- The agent can **accept**, **counter-offer**, or **reject**.
-- Each counter raises the customer's offer by **5%** (up to 5 rounds).
-- Goal: Sell at maximum profit through smart negotiation.
-
-### Reward Structure
-
-| Component | Weight | Description |
-|-----------|--------|-------------|
-| R1 (Market) | 20% | How close to the lowest price did the agent buy? |
-| R2 (Warehouse) | 20% | Did the agent pick the highest-demand product? |
-| R3 (Showroom) | 60% | Normalized profit margin on the sale |
-
-**Final Score** = `0.2 × R1 + 0.2 × R2 + 0.6 × R3` (range [0, 1])
-
-## Quick Start
-
-```python
-from ShopManagerEng import JewelryAction, JewelryShopEnv
-
-async def run():
-    env = JewelryShopEnv(base_url="http://localhost:8000")
-
-    result = await env.reset()
-    print(f"Gold price: ${result.observation.gold_price}/oz")
-
-    # Phase 1 — Market: wait for better price
-    result = await env.step(JewelryAction(market_action="wait"))
-
-    # Phase 1 — Market: buy gold
-    result = await env.step(JewelryAction(market_action="buy", gold_qty=2.0))
-
-    # Phase 2 — Warehouse: choose product
-    result = await env.step(JewelryAction(product_choice="ring"))
-
-    # Phase 3 — Showroom: negotiate
-    result = await env.step(JewelryAction(message="How about $600?"))
-    result = await env.step(JewelryAction(message="I accept"))
-
-    print(f"Final reward: {result.reward}, Cash: {result.observation.cash}")
-    await env.close()
-
-import asyncio
-asyncio.run(run())
-```
-
-## Action Space
-
-```python
-class JewelryAction:
-    market_action:  str   # "buy" or "wait" (Phase 1)
-    gold_qty:       float # Ounces to buy (Phase 1)
-    product_choice: str   # "ring", "necklace", or "bracelet" (Phase 2)
-    message:        str   # Negotiation text (Phase 3)
-```
-
-## Observation Space
-
-```python
-class JewelryObservation:
-    phase:              str          # "market" | "warehouse" | "showroom"
-    cash:               float        # Current cash balance
-    gold_oz:            float        # Raw gold in inventory
-    gold_price:         float        # Current gold price ($/oz)
-    gold_price_history: List[float]  # Price trend for analysis
-    market_round:       int          # Current market round
-    demand:             Dict[str, float]  # Demand per product (0-1)
-    product_catalog:    Dict[str, dict]   # Specs per product
-    inventory:          Dict[str, int]    # Crafted products in stock
-    product_for_sale:   str          # Product being sold (showroom)
-    cost_basis:         float        # Total manufacturing cost
-    current_offer:      float        # Customer's current offer
-    negotiation_round:  int          # Counter-offer round
-    message:            str          # Environment feedback
-```
-
-## Running the Inference Script
-
-```bash
-# Terminal 1: Start the server
-cd ShopManagerEng
-uv run server
-
-# Terminal 2: Run inference (from parent directory or inside ShopManagerEng)
-python inference.py
-```
-
-Required environment variables (set in `.env`):
-- `HF_TOKEN` — Hugging Face API token
-- `MODEL_NAME` — LLM model (default: `meta-llama/Llama-3.3-70B-Instruct`)
-
-## Deploying to Hugging Face Spaces
-
-```bash
-openenv push
-```
-
-## Project Structure
-
-```
-ShopManagerEng/
-├── __init__.py            # Module exports
-├── README.md              # This file
-├── openenv.yaml           # OpenEnv manifest
-├── pyproject.toml         # Dependencies
-├── models.py              # Action, Observation, State definitions
-├── client.py              # JewelryShopEnv client
-├── inference.py           # LLM-based agent inference script
-└── server/
-    ├── __init__.py
-    ├── ShopManagerEng_environment.py  # Core environment logic
-    ├── app.py             # FastAPI application
-    └── Dockerfile         # Container image
-```
+---
+title: Shopmanagereng Environment Server
+emoji: 🎖️
+colorFrom: green
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+---
+
+# Jewelry Shop Manager — RL Environment
+
+A reinforcement learning environment simulating a **jewelry shop management** pipeline. An AI agent navigates three sequential phases — buying raw materials, selecting products to craft based on demand, and negotiating sales — to maximize profit.
+
+## Environment Overview
+
+### Phase 1: Market (Buy / Wait)
+
+- Gold prices **fluctuate ±10% each round** (up to 3 rounds).
+- The agent analyzes price trends and decides to **buy** gold or **wait** for a better price.
+- Goal: Buy gold at the lowest possible price while reserving cash for crafting labor.
+
+### Phase 2: Warehouse (Product Selection)
+
+- The agent sees **demand levels** for each product type:
+
+| Product   | Gold (oz) | Labor ($) | Demand Range |
+|-----------|-----------|-----------|--------------|
+| Ring      | 1.0       | $200      | 40-100%      |
+| Necklace  | 2.0       | $300      | 20-80%       |
+| Bracelet  | 0.5       | $100      | 10-60%       |
+
+- The agent picks the **highest-demand product** it can afford to craft.
+- Goal: Match production to market demand.
+
+### Phase 3: Showroom (Negotiation)
+
+- A customer makes an initial offer based on cost basis and product demand.
+- The agent can **accept**, **counter-offer**, or **reject**.
+- Each counter raises the customer's offer by **5%** (up to 5 rounds).
+- Goal: Sell at maximum profit through smart negotiation.
+
+### Reward Structure
+
+| Component | Weight | Description |
+|-----------|--------|-------------|
+| R1 (Market) | 20% | How close to the lowest price did the agent buy? |
+| R2 (Warehouse) | 20% | Did the agent pick the highest-demand product? |
+| R3 (Showroom) | 60% | Normalized profit margin on the sale |
+
+**Final Score** = `0.2 × R1 + 0.2 × R2 + 0.6 × R3` (range [0, 1])
+
+## Quick Start
+
+```python
+from ShopManagerEng import JewelryAction, JewelryShopEnv
+
+async def run():
+    env = JewelryShopEnv(base_url="http://localhost:8000")
+
+    result = await env.reset()
+    print(f"Gold price: ${result.observation.gold_price}/oz")
+
+    # Phase 1 — Market: wait for better price
+    result = await env.step(JewelryAction(market_action="wait"))
+
+    # Phase 1 — Market: buy gold
+    result = await env.step(JewelryAction(market_action="buy", gold_qty=2.0))
+
+    # Phase 2 — Warehouse: choose product
+    result = await env.step(JewelryAction(product_choice="ring"))
+
+    # Phase 3 — Showroom: negotiate
+    result = await env.step(JewelryAction(message="How about $600?"))
+    result = await env.step(JewelryAction(message="I accept"))
+
+    print(f"Final reward: {result.reward}, Cash: {result.observation.cash}")
+    await env.close()
+
+import asyncio
+asyncio.run(run())
+```
+
+## Action Space
+
+```python
+class JewelryAction:
+    market_action:  str   # "buy" or "wait" (Phase 1)
+    gold_qty:       float # Ounces to buy (Phase 1)
+    product_choice: str   # "ring", "necklace", or "bracelet" (Phase 2)
+    message:        str   # Negotiation text (Phase 3)
+```
+
+## Observation Space
+
+```python
+class JewelryObservation:
+    phase:              str          # "market" | "warehouse" | "showroom"
+    cash:               float        # Current cash balance
+    gold_oz:            float        # Raw gold in inventory
+    gold_price:         float        # Current gold price ($/oz)
+    gold_price_history: List[float]  # Price trend for analysis
+    market_round:       int          # Current market round
+    demand:             Dict[str, float]  # Demand per product (0-1)
+    product_catalog:    Dict[str, dict]   # Specs per product
+    inventory:          Dict[str, int]    # Crafted products in stock
+    product_for_sale:   str          # Product being sold (showroom)
+    cost_basis:         float        # Total manufacturing cost
+    current_offer:      float        # Customer's current offer
+    negotiation_round:  int          # Counter-offer round
+    message:            str          # Environment feedback
+```
+
+## Running the Inference Script
+
+```bash
+# Terminal 1: Start the server
+cd ShopManagerEng
+uv run server
+
+# Terminal 2: Run inference (from parent directory or inside ShopManagerEng)
+python inference.py
+```
+
+Required environment variables (set in `.env`):
+- `HF_TOKEN` — Hugging Face API token
+- `MODEL_NAME` — LLM model (default: `meta-llama/Llama-3.3-70B-Instruct`)
+
+## Deploying to Hugging Face Spaces
+
+```bash
+openenv push
+```
+
+## Project Structure
+
+```
+ShopManagerEng/
+├── __init__.py            # Module exports
+├── README.md              # This file
+├── openenv.yaml           # OpenEnv manifest
+├── pyproject.toml         # Dependencies
+├── models.py              # Action, Observation, State definitions
+├── client.py              # JewelryShopEnv client
+├── inference.py           # LLM-based agent inference script
+└── server/
+    ├── __init__.py
+    ├── ShopManagerEng_environment.py  # Core environment logic
+    ├── app.py             # FastAPI application
+    └── Dockerfile         # Container image
+```

__init__.py

@@ -1,12 +1,16 @@
-"""Shopmanagereng Environment."""
-
-from .client import JewelryShopEnv
-from .models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
-
-__all__ = [
-    "JewelryAction",
-    "JewelryObservation",
-    "JewelryState",
-    "JewelryShopEnv",
-    "PRODUCT_CATALOG",
-]
+"""Shopmanagereng Environment."""
+
+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",
+    "JewelryObservation",
+    "JewelryState",
+    "JewelryShopEnv",
+    "PRODUCT_CATALOG",
+    "GRAMS_PER_TROY_OZ",
+    "troy_oz_to_grams",
+    "grams_to_troy_oz",
+]

client.py

@@ -1,112 +1,169 @@
-from openenv.core.env_client import EnvClient
-from openenv.core.client_types import StepResult
-from .models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
-
-
-class JewelryShopEnv(EnvClient[JewelryAction, JewelryObservation, JewelryState]):
-    """
-    Client for the Jewelry Shop RL environment.
-
-    Usage:
-        env = JewelryShopEnv(base_url="http://localhost:8000")
-        obs = await env.reset()
-
-        # Phase 1 — Market (buy or wait)
-        obs = await env.step(JewelryAction(market_action="wait"))
-        obs = await env.step(JewelryAction(market_action="buy", gold_qty=2.0))
-
-        # Phase 2 — Warehouse (choose product)
-        obs = await env.step(JewelryAction(product_choice="ring"))
-
-        # Phase 3 — Showroom (negotiate)
-        obs = await env.step(JewelryAction(message="How about $600?"))
-        obs = await env.step(JewelryAction(message="I accept"))
-    """
-
-    # ── 1. PACK action → dict (sent TO server) ──────────────────────────────
-
-    def _step_payload(self, action: JewelryAction) -> dict:
-        payload = {}
-
-        if action.market_action is not None:
-            payload["market_action"] = action.market_action
-
-        if action.gold_qty is not None:
-            payload["gold_qty"] = action.gold_qty
-
-        if action.product_choice is not None:
-            payload["product_choice"] = action.product_choice
-
-        if action.message is not None:
-            payload["message"] = action.message
-
-        return payload
-
-    # ── 2. UNPACK dict → typed observation (received FROM server) ───────────
-
-    def _parse_result(self, payload: dict) -> StepResult:
-        obs_data = payload.get("observation", {})
-
-        observation = JewelryObservation(
-            # Base fields
-            done=payload.get("done", False),
-            reward=payload.get("reward", None),
-
-            # Phase info
-            phase=obs_data.get("phase", "market"),
-
-            # Finances & inventory
-            cash=obs_data.get("cash", 1000.0),
-            gold_oz=obs_data.get("gold_oz", 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),
-
-            # Warehouse
-            demand=obs_data.get("demand", {}),
-            product_catalog=obs_data.get("product_catalog", PRODUCT_CATALOG),
-            inventory=obs_data.get("inventory", {}),
-
-            # Showroom
-            product_for_sale=obs_data.get("product_for_sale", None),
-            cost_basis=obs_data.get("cost_basis", 0.0),
-            current_offer=obs_data.get("current_offer", None),
-            negotiation_round=obs_data.get("negotiation_round", 0),
-
-            # Feedback
-            message=obs_data.get("message", ""),
-        )
-
-        return StepResult(
-            observation=observation,
-            reward=payload.get("reward", None),
-            done=payload.get("done", False),
-        )
-
-    # ── 3. UNPACK dict → typed state (server internal state) ────────────────
-
-    def _parse_state(self, payload: dict) -> JewelryState:
-        return JewelryState(
-            episode_id=payload.get("episode_id", None),
-            step_count=payload.get("step_count", 0),
-
-            cash=payload.get("cash", 1000.0),
-            gold_oz=payload.get("gold_oz", 0.0),
-            gold_price=payload.get("gold_price", 0.0),
-            gold_price_history=payload.get("gold_price_history", []),
-            market_round=payload.get("market_round", 0),
-
-            demand=payload.get("demand", {}),
-            inventory=payload.get("inventory", {}),
-
-            phase=payload.get("phase", "market"),
-            product_for_sale=payload.get("product_for_sale", None),
-            cost_basis=payload.get("cost_basis", 0.0),
-            negotiation_round=payload.get("negotiation_round", 0),
-            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),
+from openenv.core.env_client import EnvClient
+from openenv.core.client_types import StepResult
+
+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]):
+    """
+    Client for the Jewelry Shop RL environment.
+
+    Usage:
+        env = JewelryShopEnv(base_url="http://localhost:8000")
+        obs = await env.reset()
+
+        # Phase 1 — Market (buy or wait)
+        obs = await env.step(JewelryAction(market_action="wait"))
+        obs = await env.step(JewelryAction(market_action="buy", gold_qty=2.0))
+
+        # Phase 2 — Warehouse (choose product)
+        obs = await env.step(JewelryAction(product_choice="ring"))
+
+        # Phase 3 — Showroom (negotiate)
+        obs = await env.step(JewelryAction(message="How about $600?"))
+        obs = await env.step(JewelryAction(message="I accept"))
+    """
+
+    # ── 1. PACK action → dict (sent TO server) ──────────────────────────────
+
+    def _step_payload(self, action: JewelryAction) -> dict:
+        payload = {}
+
+        if action.market_action is not None:
+            payload["market_action"] = action.market_action
+
+        if action.gold_qty is not None:
+            payload["gold_qty"] = action.gold_qty
+
+        if action.product_choice is not None:
+            payload["product_choice"] = action.product_choice
+
+        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) ───────────
+
+    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=_reward,
+
+            # Phase info
+            phase=obs_data.get("phase", "market"),
+
+            # 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", 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", {}),
+
+            # Showroom
+            product_for_sale=obs_data.get("product_for_sale", None),
+            cost_basis=obs_data.get("cost_basis", 0.0),
+            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=_reward,
+            done=payload.get("done", False),
+        )
+
+    # ── 3. UNPACK dict → typed state (server internal state) ────────────────
+
+    def _parse_state(self, payload: dict) -> JewelryState:
+        return JewelryState(
+            episode_id=payload.get("episode_id", None),
+            step_count=payload.get("step_count", 0),
+
+            cash=payload.get("cash", 1000.0),
+            gold_oz=payload.get("gold_oz", 0.0),
+            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"),
+            product_for_sale=payload.get("product_for_sale", None),
+            cost_basis=payload.get("cost_basis", 0.0),
+            negotiation_round=payload.get("negotiation_round", 0),
+            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

@@ -1,322 +1,359 @@
-import asyncio
-import math
-import os
-import sys
-import textwrap
-from typing import List, Optional
-
-from dotenv import load_dotenv
-from openai import OpenAI
-
-# Add parent directory to path so ShopManagerEng is importable as a package
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from ShopManagerEng.client import JewelryShopEnv
-from ShopManagerEng.models import JewelryAction
-
-load_dotenv()
-
-# IMAGE_NAME = os.getenv("IMAGE_NAME")
-API_KEY = os.getenv("HF_TOKEN")
-
-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")
-TASK_NAME = os.getenv("JEWELRY_ENV_TASK", "jewelry-shop")
-BENCHMARK = os.getenv("JEWELRY_ENV_BENCHMARK", "jewelry_shop_benchmark")
-MAX_STEPS = 15
-TEMPERATURE = 0.7
-MAX_TOKENS = 150
-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).
-
-    ## 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).
-    Products: ring (1oz + $200), necklace (2oz + $300), bracelet (0.5oz + $100).
-    - 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?"
-
-    CRITICAL: Respond with ONLY the action value. No explanations.
-    """
-).strip()
-
-
-# ── LOGGING ────────────────────────────────────
-
-def log_start(task: str, env: str, model: str) -> None:
-    print(f"[START] task={task} env={env} model={model}", flush=True)
-
-
-def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    error_val = error if error else "null"
-    done_val = str(done).lower()
-    print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
-        flush=True,
-    )
-
-
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
-
-
-# ── PROMPT BUILDING ────────────────────────────
-
-def build_user_prompt(step: int, obs, last_reward: float, history: List[str]) -> str:
-    history_block = "\n".join(history[-4:]) if history else "None"
-
-    if obs.phase == "market":
-        prices = obs.gold_price_history
-        trend = ""
-        if len(prices) >= 2:
-            if prices[-1] < prices[-2]:
-                trend = "FALLING ↓ (might keep dropping, consider waiting)"
-            else:
-                trend = "RISING ↑ (buy now before it gets more expensive)"
-
-        rounds_left = obs.max_market_rounds - obs.market_round
-        # Suggest buy quantity that reserves $300 for labor (max labor cost)
-        reserve = 300.0
-        if obs.gold_price > 0:
-            raw_qty = (obs.cash - reserve) / obs.gold_price
-            suggested_qty = math.floor(raw_qty * 100) / 100
-            suggested_qty = max(suggested_qty, 0.01)
-        else:
-            suggested_qty = 1.0
-
-        phase_hint = (
-            f"Price history: {prices}. Trend: {trend}. "
-            f"Rounds left: {rounds_left}. "
-            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
-        best_product = max(demand, key=demand.get) if demand else "ring"
-        phase_hint = (
-            f"Demand: ring={demand.get('ring', 0):.0%}, "
-            f"necklace={demand.get('necklace', 0):.0%}, "
-            f"bracelet={demand.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}"
-        )
-
-    elif obs.phase == "showroom":
-        margin = ""
-        if obs.current_offer and obs.cost_basis > 0:
-            margin_pct = ((obs.current_offer - obs.cost_basis) / obs.cost_basis) * 100
-            margin = f"Margin: {margin_pct:+.1f}%. "
-
-        should_accept = False
-        if obs.negotiation_round >= 4:
-            should_accept = True
-        if obs.current_offer and obs.cost_basis > 0 and obs.current_offer > obs.cost_basis * 1.3:
-            should_accept = True
-
-        if should_accept:
-            phase_hint = (
-                f"Cost: ${obs.cost_basis}. Offer: ${obs.current_offer}. {margin}"
-                f"Round {obs.negotiation_round}/5. "
-                f"Respond with EXACTLY: I accept"
-            )
-        else:
-            # Vary counter-offers per round
-            counter_msgs = [
-                "I need a better price for this quality piece",
-                "That's too low, this craftsmanship deserves more",
-                f"How about ${round(obs.cost_basis * 1.4, 2)}?",
-                f"I can't go below ${round(obs.cost_basis * 1.3, 2)}",
-            ]
-            msg = counter_msgs[min(obs.negotiation_round, len(counter_msgs) - 1)]
-            phase_hint = (
-                f"Cost: ${obs.cost_basis}. Offer: ${obs.current_offer}. {margin}"
-                f"Round {obs.negotiation_round}/5. "
-                f"DO NOT ACCEPT. Counter-offer. "
-                f"Respond with EXACTLY: {msg}"
-            )
-    else:
-        phase_hint = ""
-
-    return textwrap.dedent(
-        f"""
-        Step: {step} | Phase: {obs.phase} | Last reward: {last_reward:.2f}
-        Cash: ${obs.cash} | Gold: {obs.gold_oz}oz | Rings: {obs.inventory}
-        Gold Price: ${obs.gold_price}/oz
-        Env Message: {obs.message}
-
-        {phase_hint}
-
-        History: {history_block}
-        """
-    ).strip()
-
-
-# ── ACTION PARSING ─────────────────────────────
-
-def get_action_from_text(phase: str, text: str) -> tuple[JewelryAction, str]:
-    text = text.strip().replace("`", "").strip(' \t\n\r"\'')
-
-    if phase == "market":
-        lower = text.lower()
-        if lower.startswith("buy"):
-            # Extract quantity from "buy 2.5" or "buy2.5"
-            qty_str = lower.replace("buy", "").strip()
-            try:
-                qty = float(qty_str)
-            except ValueError:
-                qty = 1.0
-            return JewelryAction(market_action="buy", gold_qty=qty), f"buy {qty}"
-        elif "wait" in lower:
-            return JewelryAction(market_action="wait"), "wait"
-        else:
-            # Try to parse as a number (assumed buy)
-            try:
-                qty = float(text)
-                return JewelryAction(market_action="buy", gold_qty=qty), f"buy {qty}"
-            except ValueError:
-                return JewelryAction(market_action="wait"), "wait"
-
-    elif phase == "warehouse":
-        lower = text.lower()
-        for product in ["necklace", "bracelet", "ring"]:
-            if product in lower:
-                return JewelryAction(product_choice=product), product
-        return JewelryAction(product_choice="ring"), "ring"
-
-    elif phase == "showroom":
-        return JewelryAction(message=text), text
-
-    return JewelryAction(), text
-
-
-def get_model_action(client: OpenAI, step: int, obs, last_reward: float, history: List[str]) -> tuple[JewelryAction, str]:
-    user_prompt = build_user_prompt(step, obs, last_reward, history)
-    try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": user_prompt},
-            ],
-            temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-            stream=False,
-        )
-        text = (completion.choices[0].message.content or "").strip()
-        return get_action_from_text(obs.phase, text)
-    except Exception as exc:
-        # print(f"[DEBUG] Model request failed: {exc}", flush=True)
-        # Fallback actions
-        if obs.phase == "market":
-            return JewelryAction(market_action="buy", gold_qty=1.0), "buy 1.0"
-        elif obs.phase == "warehouse":
-            return JewelryAction(product_choice="ring"), "ring"
-        else:
-            return JewelryAction(message="I accept"), "I accept"
-
-
-
-# ── SINGLE EPISODE RUNNER ──────────────────────
-
-async def run_episode(client: OpenAI, task_name: str, env_name: str, base_url: str) -> float:
-    """Run a single episode and return the final score."""
-    history: List[str] = []
-    rewards: List[float] = []
-    steps_taken = 0
-    score = 0.0
-    success = False
-
-    log_start(task=task_name, env=env_name, model=MODEL_NAME)
-
-    try:
-        env = JewelryShopEnv(base_url=base_url)
-
-        result = await env.reset()
-        obs = result.observation
-        last_reward = 0.0
-
-        for step in range(1, MAX_STEPS + 1):
-            if result.done:
-                break
-
-            action, raw_action_str = get_model_action(client, step, obs, last_reward, history)
-            current_phase = obs.phase
-
-            result = await env.step(action)
-            obs = result.observation
-
-            reward = result.reward or 0.0
-            done = result.done
-            error = None
-
-            rewards.append(reward)
-            steps_taken = step
-            last_reward = reward
-
-            log_step(step=step, action=raw_action_str.replace('\n', ' '), reward=reward, done=done, error=error)
-            history.append(f"Step {step} ({current_phase}): {raw_action_str!r} -> reward {reward:+.2f}")
-
-            if done:
-                break
-
-        if rewards:
-            score = rewards[-1]
-        else:
-            score = 0.0
-
-        score = min(max(score, 0.0), 1.0)
-        success = score >= SUCCESS_SCORE_THRESHOLD
-
-    finally:
-        try:
-            await env.close()
-        except Exception as e:
-            pass
-            # print(f"[DEBUG] env.close() error: {e}", flush=True)
-        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
-
-    return score
-
-
-# ── MAIN ───────────────────────────────────────
-
-TASKS = [
-    {"id": "market_timing", "env": "jewelry_shop_benchmark"},
-    {"id": "demand_crafter", "env": "jewelry_shop_benchmark"},
-    {"id": "profit_negotiator", "env": "jewelry_shop_benchmark"},
-]
-
-async def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-    base_url = os.getenv("ENV_BASE_URL", "https://hard007ik-shopmanagereng.hf.space")
-    # base_url = os.getenv("ENV_BASE_URL", "http://localhost:8000")
-
-    for task in TASKS:
-        await run_episode(client, task["id"], task["env"], base_url)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
+import asyncio
+import math
+import os
+import sys
+import textwrap
+from typing import List, Optional
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# Add parent directory to path so ShopManagerEng is importable as a package
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from ShopManagerEng.client import JewelryShopEnv
+from ShopManagerEng.models import JewelryAction
+
+load_dotenv()
+
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+
+# ── 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
+TEMPERATURE = 0.7
+MAX_TOKENS = 150
+SUCCESS_SCORE_THRESHOLD = 0.01
+
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    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 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).
+    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)
+    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.
+    """
+).strip()
+
+
+# ── LOGGING ────────────────────────────────────
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+
+# ── PROMPT BUILDING ────────────────────────────
+
+def build_user_prompt(step: int, obs, last_reward: float, history: List[str]) -> str:
+    history_block = "\n".join(history[-4:]) if history else "None"
+
+    if obs.phase == "market":
+        prices = obs.gold_price_history
+        trend = ""
+        if len(prices) >= 2:
+            if prices[-1] < prices[-2]:
+                trend = "FALLING ↓ (might keep dropping, consider waiting)"
+            else:
+                trend = "RISING ↑ (buy now before it gets more expensive)"
+
+        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:
+            raw_qty = (obs.cash - reserve) / obs.gold_price
+            suggested_qty = math.floor(raw_qty * 100) / 100
+            suggested_qty = max(suggested_qty, 0.01)
+        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 / 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 (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}"
+        )
+
+    elif obs.phase == "showroom":
+        margin = ""
+        if obs.current_offer and obs.cost_basis > 0:
+            margin_pct = ((obs.current_offer - obs.cost_basis) / obs.cost_basis) * 100
+            margin = f"Margin: {margin_pct:+.1f}%. "
+
+        should_accept = False
+        if obs.negotiation_round >= 4:
+            should_accept = True
+        if obs.current_offer and obs.cost_basis > 0 and obs.current_offer > obs.cost_basis * 1.3:
+            should_accept = True
+
+        if should_accept:
+            phase_hint = (
+                f"Cost: ${obs.cost_basis}. Offer: ${obs.current_offer}. {margin}"
+                f"Round {obs.negotiation_round}/5. "
+                f"Respond with EXACTLY: I accept"
+            )
+        else:
+            # Vary counter-offers per round
+            counter_msgs = [
+                "I need a better price for this quality piece",
+                "That's too low, this craftsmanship deserves more",
+                f"How about ${round(obs.cost_basis * 1.4, 2)}?",
+                f"I can't go below ${round(obs.cost_basis * 1.3, 2)}",
+            ]
+            msg = counter_msgs[min(obs.negotiation_round, len(counter_msgs) - 1)]
+            phase_hint = (
+                f"Cost: ${obs.cost_basis}. Offer: ${obs.current_offer}. {margin}"
+                f"Round {obs.negotiation_round}/5. "
+                f"DO NOT ACCEPT. Counter-offer. "
+                f"Respond with EXACTLY: {msg}"
+            )
+    else:
+        phase_hint = ""
+
+    return textwrap.dedent(
+        f"""
+        Step: {step} | Phase: {obs.phase} | Last reward: {last_reward:.2f}
+        Cash: ${obs.cash} | Gold: {obs.gold_oz}oz | Rings: {obs.inventory}
+        Gold Price: ${obs.gold_price}/oz
+        Env Message: {obs.message}
+
+        {phase_hint}
+
+        History: {history_block}
+        """
+    ).strip()
+
+
+# ── ACTION PARSING ─────────────────────────────
+
+def get_action_from_text(phase: str, text: str) -> tuple[JewelryAction, str]:
+    text = text.strip().replace("`", "").strip(' \t\n\r"\'')
+
+    if phase == "market":
+        lower = text.lower()
+        if lower.startswith("buy"):
+            # Extract quantity from "buy 2.5" or "buy2.5"
+            qty_str = lower.replace("buy", "").strip()
+            try:
+                qty = float(qty_str)
+            except ValueError:
+                qty = 1.0
+            return JewelryAction(market_action="buy", gold_qty=qty), f"buy {qty}"
+        elif "wait" in lower:
+            return JewelryAction(market_action="wait"), "wait"
+        else:
+            # Try to parse as a number (assumed buy)
+            try:
+                qty = float(text)
+                return JewelryAction(market_action="buy", gold_qty=qty), f"buy {qty}"
+            except ValueError:
+                return JewelryAction(market_action="wait"), "wait"
+
+    elif phase == "warehouse":
+        lower = text.lower()
+        for product in ["necklace", "bracelet", "ring"]:
+            if product in lower:
+                return JewelryAction(product_choice=product), product
+        return JewelryAction(product_choice="ring"), "ring"
+
+    elif phase == "showroom":
+        return JewelryAction(message=text), text
+
+    return JewelryAction(), text
+
+
+def get_model_action(client: OpenAI, step: int, obs, last_reward: float, history: List[str]) -> tuple[JewelryAction, str]:
+    user_prompt = build_user_prompt(step, obs, last_reward, history)
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+            stream=False,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        return get_action_from_text(obs.phase, text)
+    except Exception as exc:
+        # print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        # Fallback actions
+        if obs.phase == "market":
+            return JewelryAction(market_action="buy", gold_qty=1.0), "buy 1.0"
+        elif obs.phase == "warehouse":
+            return JewelryAction(product_choice="ring"), "ring"
+        else:
+            return JewelryAction(message="I accept"), "I accept"
+
+
+
+# ── SINGLE EPISODE RUNNER ──────────────────────
+
+async def run_episode(client: OpenAI, task_name: str, env_name: str, base_url: str) -> float:
+    """Run a single episode and return the final score."""
+    history: List[str] = []
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=task_name, env=env_name, model=MODEL_NAME)
+
+    try:
+        env = JewelryShopEnv(base_url=base_url)
+
+        # 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
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            action, raw_action_str = get_model_action(client, step, obs, last_reward, history)
+            current_phase = obs.phase
+
+            result = await env.step(action)
+            obs = result.observation
+
+            reward = result.reward or 0.0
+            done = result.done
+            error = None
+
+            rewards.append(reward)
+            steps_taken = step
+            last_reward = reward
+
+            log_step(step=step, action=raw_action_str.replace('\n', ' '), reward=reward, done=done, error=error)
+            history.append(f"Step {step} ({current_phase}): {raw_action_str!r} -> reward {reward:+.2f}")
+
+            if done:
+                break
+
+        # 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
+
+    finally:
+        try:
+            await env.close()
+        except Exception as e:
+            pass
+            # print(f"[DEBUG] env.close() error: {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+    return score
+
+
+# ── MAIN ───────────────────────────────────────
+
+TASKS = [
+    {"id": "market_timing", "env": "jewelry_shop_benchmark"},
+    {"id": "demand_crafter", "env": "jewelry_shop_benchmark"},
+    {"id": "profit_negotiator", "env": "jewelry_shop_benchmark"},
+]
+
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+    # ── 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)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

models.py

@@ -1,88 +1,137 @@
-from typing import Optional, Dict, List
-from openenv.core.env_server import Action, Observation, State
-
-
-# ─────────────────────────────────────────────
-#  PRODUCT CATALOG (shared constant)
-# ─────────────────────────────────────────────
-
-PRODUCT_CATALOG = {
-    "ring":     {"gold_oz": 1.0, "labor": 200.0, "base_demand": 0.8},
-    "necklace": {"gold_oz": 2.0, "labor": 300.0, "base_demand": 0.5},
-    "bracelet": {"gold_oz": 0.5, "labor": 100.0, "base_demand": 0.3},
-}
-
-
-# ─────────────────────────────────────────────
-#  ACTION
-#  One unified action covers all 3 phases.
-# ─────────────────────────────────────────────
-
-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_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
-
-
-# ─────────────────────────────────────────────
-#  OBSERVATION
-#  Everything the agent can SEE each step.
-# ─────────────────────────────────────────────
-
-class JewelryObservation(Observation):
-    # Base fields: done, reward (inherited)
-
-    phase:              str                    # "market" | "warehouse" | "showroom"
-    cash:               float                  # Agent's current cash ($)
-    gold_oz:            float                  # Raw gold in inventory (oz)
-
-    # Market phase
-    gold_price:         float                  # Current gold price ($/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
-
-    # Warehouse phase
-    demand:             Dict[str, float] = {}  # Demand level per product (0-1)
-    product_catalog:    Dict[str, dict] = {}   # Gold/labor costs per product
-    inventory:          Dict[str, int] = {}    # Crafted products in stock
-
-    # Showroom phase
-    product_for_sale:   Optional[str] = None   # Which product is being sold
-    cost_basis:         float = 0.0            # Total cost to make the product
-    current_offer:      Optional[float] = None # Customer's live offer
-    negotiation_round:  int = 0                # Counter-offer rounds so far
-
-    message:            str = ""               # Human-readable feedback
-
-
-# ─────────────────────────────────────────────
-#  STATE
-#  Full internal state (server-side truth).
-# ─────────────────────────────────────────────
-
-class JewelryState(State):
-    # Base: episode_id, step_count (inherited)
-
-    cash:               float = 1000.0
-    gold_oz:            float = 0.0
-    gold_price:         float = 0.0
-    gold_price_history: List[float] = []
-    market_round:       int = 0
-
-    demand:             Dict[str, float] = {}
-    inventory:          Dict[str, int] = {}
-
-    phase:              str = "market"
-    product_for_sale:   Optional[str] = None
-    cost_basis:         float = 0.0
-    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
+from typing import Optional, Dict, List
+from openenv.core.env_server import Action, Observation, State
+
+
+# ─────────────────────────────────────────────
+#  PRODUCT CATALOG (shared constant)
+# ─────────────────────────────────────────────
+
+PRODUCT_CATALOG = {
+    "ring":     {"gold_oz": 1.0, "labor": 200.0, "base_demand": 0.8},
+    "necklace": {"gold_oz": 2.0, "labor": 300.0, "base_demand": 0.5},
+    "bracelet": {"gold_oz": 0.5, "labor": 100.0, "base_demand": 0.3},
+}
+
+
+# ─────────────────────────────────────────────
+#  ACTION
+#  One unified action covers all 3 phases.
+# ─────────────────────────────────────────────
+
+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
+#  Everything the agent can SEE each step.
+# ─────────────────────────────────────────────
+
+class JewelryObservation(Observation):
+    # Base fields: done, reward (inherited)
+
+    phase:              str                    # "market" | "warehouse" | "showroom"
+    cash:               float                  # Agent's current cash ($)
+    gold_oz:            float                  # Raw gold in inventory (oz)
+
+    # 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                # "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] = {}  # "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
+
+    # Showroom phase
+    product_for_sale:   Optional[str] = None   # Which product is being sold
+    cost_basis:         float = 0.0            # Total cost to make the product
+    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
+
+
+# ─────────────────────────────────────────────
+#  STATE
+#  Full internal state (server-side truth).
+# ─────────────────────────────────────────────
+
+class JewelryState(State):
+    # Base: episode_id, step_count (inherited)
+
+    cash:               float = 1000.0
+    gold_oz:            float = 0.0
+    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"
+    product_for_sale:   Optional[str] = None
+    cost_basis:         float = 0.0
+    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
+
+    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

@@ -1,37 +1,38 @@
-spec_version: 1
-name: ShopManagerEng
-type: space
-runtime: fastapi
-app: server.app:app
-port: 8000
-
-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).
-    grader:
-      type: reward_threshold
-      threshold: 0.3
-
-  - id: demand_crafter
-    name: "Demand-Based Crafter"
-    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).
-    grader:
-      type: reward_threshold
-      threshold: 0.2
-
-  - id: profit_negotiator
-    name: "Profit Maximizer"
-    description: >
-      Complete the full pipeline: buy gold at a good price, craft the
-      best product based on demand, and negotiate with the customer.
-      Counter-offer to drive up the price before accepting.
-    grader:
-      type: reward_threshold
-      threshold: 0.25
+spec_version: 1
+name: ShopManagerEng
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+
+tasks:
+  - id: market_timing
+    name: "Market Price Analyst"
+    description: >
+      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 (Inventory)"
+    description: >
+      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
+
+  - id: profit_negotiator
+    name: "Profit Maximizer"
+    description: >
+      Complete the full pipeline: buy gold at a good price, craft the
+      best product based on demand, and negotiate with the customer.
+      Counter-offer to drive up the price before accepting.
+    grader:
+      type: reward_threshold
+      threshold: 0.25

pyproject.toml

@@ -1,45 +1,40 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv-ShopManagerEng"
-version = "0.1.0"
-description = "Shopmanagereng environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
-    # 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",
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-]
-
-[project.scripts]
-# Server entry point - enables running via: uv run --project . server
-# or: python -m ShopManagerEng.server.app
-server = "ShopManagerEng.server.app:main"
-
-[tool.setuptools]
-include-package-data = true
-packages = ["ShopManagerEng", "ShopManagerEng.server"]
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-ShopManagerEng"
+version = "0.1.0"
+description = "Shopmanagereng environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    "yfinance>=0.2.40",
+    "python-dotenv>=1.0.0",
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m ShopManagerEng.server.app
+server = "ShopManagerEng.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["ShopManagerEng", "ShopManagerEng.server"]
 package-dir = { "ShopManagerEng" = ".", "ShopManagerEng.server" = "server" }

server/ShopManagerEng_environment.py

@@ -1,510 +1,704 @@
-import random
-import uuid
-from openenv.core.env_server import Environment
-
-try:
-    from ..models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
-except ImportError:
-    from models import JewelryAction, JewelryObservation, JewelryState, PRODUCT_CATALOG
-
-
-# ─────────────────────────────────────────────
-#  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
-
-
-# ─────────────────────────────────────────────
-#  KEYWORD DETECTION  (Phase 3 — Showroom)
-# ─────────────────────────────────────────────
-
-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:
-        if kw in msg:
-            return "accept"
-    for kw in REJECT_KEYWORDS:
-        if kw in msg:
-            return "reject"
-    return "counter"
-
-
-# ─────────────────────────────────────────────
-#  REWARD HELPERS
-# ─────────────────────────────────────────────
-
-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.
-    """
-    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)
-
-
-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.
-    """
-    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)
-
-
-def compute_r3(accepted_price: float, cost_basis: float) -> float:
-    """
-    Phase 3 reward: normalized profit margin on sale.
-    """
-    if cost_basis <= 0:
-        return 0.0
-    profit = accepted_price - cost_basis
-    if profit <= 0:
-        return 0.0
-    max_profit = cost_basis * (MAX_PROFIT_MULT - 1)
-    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)
-
-
-# ─────────────────────────────────────────────
-#  ENVIRONMENT
-# ─────────────────────────────────────────────
-
-class JewelryShopEnvironment(Environment):
-    SUPPORTS_CONCURRENT_SESSIONS = True
-
-    def __init__(self):
-        self._state = JewelryState()
-        self._r1 = 0.0
-        self._r2 = 0.0
-
-    # ── RESET ──────────────────────────────────
-
-    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),
-            "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()),
-            step_count=0,
-            cash=STARTING_CASH,
-            gold_oz=0.0,
-            gold_price=gold_price,
-            gold_price_history=[gold_price],
-            market_round=0,
-            demand=demand,
-            inventory={"ring": 0, "necklace": 0, "bracelet": 0},
-            phase="market",
-            product_for_sale=None,
-            cost_basis=0.0,
-            negotiation_round=0,
-            current_offer=0.0,
-            base_offer=0.0,
-            lowest_price_seen=gold_price,
-        )
-        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}."
-            ),
-        )
-
-    # ── STEP ───────────────────────────────────
-
-    def step(self, action: JewelryAction, timeout_s=None, **kwargs) -> JewelryObservation:
-        self._state.step_count += 1
-        phase = self._state.phase
-
-        if phase == "market":
-            return self._step_market(action)
-        elif phase == "warehouse":
-            return self._step_warehouse(action)
-        elif phase == "showroom":
-            return self._step_showroom(action)
-        else:
-            raise ValueError(f"Unknown phase: {phase}")
-
-    # ── PHASE 1: MARKET ────────────────────────
-
-    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)
-
-            # Advance to warehouse
-            s.phase = "warehouse"
-
-            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
-
-            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."
-                    ),
-                )
-
-            # 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?"
-                ),
-            )
-
-    # ── PHASE 2: WAREHOUSE ─────────────────────
-
-    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
-
-        spec = PRODUCT_CATALOG[choice]
-        gold_needed = 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
-            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})"
-            )
-            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.",
-            )
-
-        # 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
-
-        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
-        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?"
-            ),
-        )
-
-    # ── PHASE 3: SHOWROOM ──────────────────────
-
-    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.",
-            )
-
-        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)
-            s.cash += s.current_offer
-            s.inventory[s.product_for_sale] -= 1
-            product_sold = 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}."
-                ),
-            )
-
-        # ── REJECT ──
-        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}."
-                ),
-            )
-
-        # ── COUNTER ──
-        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}."
-                ),
-            )
-
-        # Customer raises offer by 5%
-        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 ─────────────────────────
-
-    @property
-    def state(self) -> JewelryState:
-        return self._state
+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
+
+
+# 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
+
+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:
+        if kw in msg:
+            return "accept"
+    for kw in REJECT_KEYWORDS:
+        if kw in msg:
+            return "reject"
+    return "counter"
+
+
+# ─────────────────────────────────────────────
+#  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 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
+    return round(min(ratio, 1.0), 4)
+
+
+def compute_r2(product_choice: str, demand: dict) -> float:
+    """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, 4)
+
+
+def compute_r3(accepted_price: float, cost_basis: float) -> float:
+    """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
+    if profit <= 0:
+        return 0.0
+    max_profit = cost_basis * (MAX_PROFIT_MULT - 1)
+    return round(min(profit / max_profit, 1.0), 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
+
+
+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,
+        )
+
+    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)
+        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),
+        }
+        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,
+            gold_oz=0.0,
+            gold_price=gp,
+            gold_price_history=hist,
+            market_round=0,
+            max_market_rounds=max_r0,
+            demand=dem,
+            demand_forecast=dem_fc,
+            inventory={"ring": 0, "necklace": 0, "bracelet": 0},
+            phase="market",
+            product_for_sale=None,
+            cost_basis=0.0,
+            negotiation_round=0,
+            current_offer=0.0,
+            base_offer=0.0,
+            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
+        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()}"
+            ),
+        )
+        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
+        if self._state.phase == "market":
+            self._apply_action_inventory_fields(action)
+        if self._state.phase == "market":
+            return self._step_market(action)
+        if self._state.phase == "warehouse":
+            return self._step_warehouse(action)
+        if self._state.phase == "showroom":
+            return self._step_showroom(action)
+        raise ValueError(f"Unknown phase: {self._state.phase}")
+
+    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 s.market_mode == "synthetic":
+            return self._step_market_synthetic(action, market_action)
+        return self._step_market_real(action, market_action)
+
+    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)
+
+    def _exec_buy_synthetic_common(self, action: JewelryAction, market_action: str) -> JewelryObservation:
+        return self._step_market_buy_and_advance(
+            action,
+            persist_db=False,
+        )
+
+    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.",
+                )
+                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)
+
+    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"
+        spec = PRODUCT_CATALOG[choice]
+        gold_needed_oz = spec["gold_oz"]
+        labor_cost = spec["labor"]
+        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"
+            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}."
+            )
+            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)
+
+        s.cash -= labor_cost
+        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)
+        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
+        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"
+        )
+        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
+        if s.product_for_sale is None:
+            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)
+        if intent == "accept":
+            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
+            _ps = s.product_for_sale
+            s.product_for_sale = None
+            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}."
+            )
+            o4["product_for_sale"] = None
+            o4["current_offer"] = s.current_offer
+            return self._obs_from(o4)
+        if intent == "reject":
+            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}."
+            )
+            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:
+            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}."
+            )
+            return self._obs_from(o6)
+        s.current_offer = round(s.current_offer * COUNTER_BUMP, 2)
+        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

server/__init__.py

@@ -1,14 +1,14 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Shopmanagereng environment server components."""
-
-try:
-    from .ShopManagerEng_environment import JewelryShopEnvironment
-except ImportError:
-    from server.ShopManagerEng_environment import JewelryShopEnvironment
-
-__all__ = ["JewelryShopEnvironment"]
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Shopmanagereng environment server components."""
+
+try:
+    from .ShopManagerEng_environment import JewelryShopEnvironment
+except ImportError:
+    from server.ShopManagerEng_environment import JewelryShopEnvironment
+
+__all__ = ["JewelryShopEnvironment"]

server/app.py

@@ -1,18 +1,44 @@
-from openenv.core.env_server import create_fastapi_app
-
-try:
-    from .ShopManagerEng_environment import JewelryShopEnvironment
-    from ..models import JewelryAction, JewelryObservation
-except ImportError:
-    from server.ShopManagerEng_environment import JewelryShopEnvironment
-    from models import JewelryAction, JewelryObservation
-
-import uvicorn
-
-app = create_fastapi_app(JewelryShopEnvironment, JewelryAction, JewelryObservation)
-
-def main():
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-if __name__ == "__main__":
+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
+except ImportError:
+    from server.ShopManagerEng_environment import JewelryShopEnvironment
+    from models import JewelryAction, JewelryObservation
+
+import uvicorn
+
+# 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)
+
+if __name__ == "__main__":
     main()

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/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