Upload 13 files

Dockerfile

@@ -0,0 +1,28 @@
+# Use lightweight python image
+FROM python:3.10-slim
+
+# Set strict limits awareness
+ENV PYTHONUNBUFFERED=1
+ENV API_BASE_URL="https://api.openai.com/v1"
+ENV MODEL_NAME="gpt-4.1-mini"
+ENV ENABLE_WEB_INTERFACE=true
+
+# Setup working directory
+WORKDIR /app
+ENV PYTHONPATH=/app
+
+# Install dependencies securely
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all core files
+COPY . /app
+
+# Ensure HF Space port exposes correctly
+EXPOSE 7860
+
+# Alternative CMD for testing locally:
+# CMD ["python", "inference.py"]
+
+# CMD strictly runs the FastAPI server
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,44 @@
 ---
-title: Meta
-emoji: 🐢
-colorFrom: indigo
-colorTo: pink
+title: Customer Support Triage
+emoji: 🎧
+colorFrom: blue
+colorTo: indigo
 sdk: docker
+sdk_version: "1.0.0"
+python_version: "3.10.0"
+app_file: app.py
 pinned: false
-license: mit
 ---
+# Customer Support Triage Environment
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A real-world customer support simulation environment requiring information extraction, system actions, and routing. 
+Built using the official OpenEnv interface specification.
+
+## Overview
+This environment simulates a text-based customer support chat system. The agent acts on incoming support tickets and chooses actions such as asking the user for missing info, processing refunds, or routing the ticket to specialized teams. 
+
+## Action & Observation Spaces
+- **Observation:** `ticket_id`, `customer_message`, `history`, `missing_info`, `status`, `refund_processed`, `done`, `reward`.
+- **Action:** 
+  - `action_type`: One of 'ROUTE', 'ASK_INFO', 'REFUND', 'CLOSE'
+  - `argument`: The specific queue (e.g., 'BILLING'), the info to ask for (e.g., 'serial_number'), or order to refund.
+
+## Tasks
+1. **easy_password_reset** (Easy): A simple IT support routing task requiring no additional info.
+2. **medium_hardware_issue** (Medium): Requires the agent to first ask for the `serial_number` before routing to hardware support.
+3. **hard_refund_processing** (Hard): Requires the agent to ask for `order_id` and `photo_evidence`, process a refund by taking the REFUND action, and finally route the ticket to billing.
+
+## Usage
+Start the environment server using Docker:
+```bash
+docker build -t customer-support-env .
+docker run -p 8000:8000 customer-support-env
+```
+Or start directly via python:
+```bash
+uvicorn server.app:app --port 8000
+```
+Run the baseline baseline inference script:
+```bash
+python inference.py
+```

env.py

@@ -0,0 +1,121 @@
+from models import Observation, Action, State
+from tasks import TASKS, grader
+import copy
+from typing import Any, Optional
+import openenv.core.env_server as es
+
+class CustomerSupportEnv(es.Environment):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.current_task_idx = 0
+        self.state_data = {}
+        self.step_count = 0
+        self.max_steps = 10
+        self.done = False
+        self.reset()
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, task_idx: int = 0, **kwargs: Any) -> Observation:
+        self.current_task_idx = task_idx
+        task = TASKS[self.current_task_idx]
+        self.step_count = 0
+        self.done = False
+        
+        self.state_data = {
+            "ticket_id": f"TKT-{1000 + task_idx}",
+            "customer_message": task.initial_msg,
+            "history":[f"Customer: {task.initial_msg}"],
+            "missing_info": task.required_info.copy(),
+            "collected_info":[],
+            "route": None,
+            "refund_processed": False,
+            "status": "OPEN",
+            "episode_id": episode_id
+        }
+        return self._get_obs(reward=0.0, feedback="")
+
+    @property
+    def state(self) -> State:
+        return State(
+            ticket_id=self.state_data.get("ticket_id", ""),
+            customer_message=self.state_data.get("customer_message", ""),
+            history=copy.deepcopy(self.state_data.get("history", [])),
+            missing_info=copy.deepcopy(self.state_data.get("missing_info", [])),
+            status=self.state_data.get("status", "OPEN"),
+            refund_processed=self.state_data.get("refund_processed", False),
+            episode_id=self.state_data.get("episode_id", None),
+            step_count=self.step_count
+        )
+
+    def _get_obs(self, reward: float = 0.0, feedback: str = "") -> Observation:
+        return Observation(
+            ticket_id=self.state_data["ticket_id"],
+            customer_message=self.state_data["customer_message"],
+            history=self.state_data["history"],
+            missing_info=self.state_data["missing_info"],
+            status=self.state_data["status"],
+            refund_processed=self.state_data["refund_processed"],
+            done=self.done,
+            reward=reward,
+            metadata={"feedback": feedback, "state": self.state_data}
+        )
+
+    def step(self, action: Action, timeout_s: Optional[float] = None, **kwargs: Any) -> Observation:
+        if self.done:
+            return self._get_obs(reward=0.0, feedback="Episode already done")
+
+        self.step_count += 1
+        reward_val = 0.0
+        feedback = ""
+        task = TASKS[self.current_task_idx]
+
+        # Penalize infinite loops / max steps
+        if self.step_count >= self.max_steps:
+            self.done = True
+            return self._get_obs(reward=-0.5, feedback="Max steps reached")
+
+        if action.action_type == "ASK_INFO":
+            asked = action.argument.lower()
+            found = False
+            for req in self.state_data["missing_info"]:
+                if req.lower() in asked.lower():
+                    self.state_data["missing_info"].remove(req)
+                    self.state_data["collected_info"].append(req)
+                    reply = f"Here is my {req}: [MOCK_DATA]"
+                    self.state_data["history"].extend([f"Agent: {action.argument}", f"Customer: {reply}"])
+                    self.state_data["customer_message"] = reply
+                    reward_val = 0.2
+                    feedback = f"Successfully collected {req}"
+                    found = True
+                    break
+            if not found:
+                reward_val = -0.1
+                feedback = "Asked for unnecessary information."
+
+        elif action.action_type == "REFUND":
+            if task.needs_refund and "order_id" in self.state_data["collected_info"]:
+                self.state_data["refund_processed"] = True
+                reward_val = 0.3
+                feedback = "Refund processed successfully."
+            else:
+                reward_val = -0.5
+                feedback = "Cannot process refund without order ID or refund not required."
+
+        elif action.action_type == "ROUTE":
+            self.state_data["route"] = action.argument
+            if self.state_data["missing_info"]:
+                reward_val = -0.5
+                feedback = "Routed prematurely without gathering required info."
+            else:
+                self.done = True
+                final_score = grader(task, self.state_data)
+                reward_val = float(final_score)
+                feedback = f"Ticket routed. Final Score: {final_score}"
+
+        elif action.action_type == "CLOSE":
+            self.done = True
+            self.state_data["status"] = "CLOSED"
+            final_score = grader(task, self.state_data)
+            reward_val = float(final_score)
+            feedback = f"Ticket closed. Final Score: {final_score}"
+
+        return self._get_obs(reward=reward_val, feedback=feedback)

full_validate.sh

@@ -0,0 +1,185 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Prerequisites:
+#   - Docker:       https://docs.docker.com/get-docker/
+#   - openenv-core: pip install openenv-core
+#   - curl (usually pre-installed)
+#
+# Run:
+#   curl -fsSL https://raw.githubusercontent.com/<owner>/<repo>/main/scripts/validate-submission.sh | bash -s -- <ping_url> [repo_dir]
+#
+#   Or download and run locally:
+#     chmod +x validate-submission.sh
+#     ./validate-submission.sh <ping_url> [repo_dir]
+#
+# Arguments:
+#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
+#   repo_dir   Path to your repo (default: current directory)
+#
+# Examples:
+#   ./validate-submission.sh https://my-team.hf.space
+#   ./validate-submission.sh https://my-team.hf.space ./my-repo
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+run_with_timeout() {
+  local secs="$1"; shift
+  if command -v timeout &>/dev/null; then
+    timeout "$secs" "$@"
+  elif command -v gtimeout &>/dev/null; then
+    gtimeout "$secs" "$@"
+  else
+    "$@" &
+    local pid=$!
+    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
+    local watcher=$!
+    wait "$pid" 2>/dev/null
+    local rc=$?
+    kill "$watcher" 2>/dev/null
+    wait "$watcher" 2>/dev/null
+    return $rc
+  fi
+}
+
+portable_mktemp() {
+  local prefix="${1:-validate}"
+  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
+}
+
+CLEANUP_FILES=()
+cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
+trap cleanup EXIT
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
+  printf "\n"
+  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
+  printf "  repo_dir   Path to your repo (default: current directory)\n"
+  exit 1
+fi
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  printf "Error: directory '%s' not found\n" "${2:-.}"
+  exit 1
+fi
+PING_URL="${PING_URL%/}"
+export PING_URL
+PASS=0
+
+log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
+fail() { log "${RED}FAILED${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+stop_at() {
+  printf "\n"
+  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
+  exit 1
+}
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${BOLD}  OpenEnv Submission Validator${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Repo:     $REPO_DIR"
+log "Ping URL: $PING_URL"
+printf "\n"
+
+log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
+
+CURL_OUTPUT=$(portable_mktemp "validate-curl")
+CLEANUP_FILES+=("$CURL_OUTPUT")
+HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responds to /reset"
+elif [ "$HTTP_CODE" = "000" ]; then
+  fail "HF Space not reachable (connection failed or timed out)"
+  hint "Check your network connection and that the Space is running."
+  hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset"
+  stop_at "Step 1"
+else
+  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
+  hint "Make sure your Space is running and the URL is correct."
+  hint "Try opening $PING_URL in your browser first."
+  stop_at "Step 1"
+fi
+
+log "${BOLD}Step 2/3: Running docker build${NC} ..."
+
+if ! command -v docker &>/dev/null; then
+  fail "docker command not found"
+  hint "Install Docker: https://docs.docker.com/get-docker/"
+  stop_at "Step 2"
+fi
+
+if [ -f "$REPO_DIR/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR"
+elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR/server"
+else
+  fail "No Dockerfile found in repo root or server/ directory"
+  stop_at "Step 2"
+fi
+
+log "  Found Dockerfile in $DOCKER_CONTEXT"
+
+BUILD_OK=false
+BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
+
+if [ "$BUILD_OK" = true ]; then
+  pass "Docker build succeeded"
+else
+  fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
+  printf "%s\n" "$BUILD_OUTPUT" | tail -20
+  stop_at "Step 2"
+fi
+
+log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
+
+if ! command -v openenv &>/dev/null; then
+  fail "openenv command not found"
+  hint "Install it: pip install openenv-core"
+  stop_at "Step 3"
+fi
+
+VALIDATE_OK=false
+VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
+
+if [ "$VALIDATE_OK" = true ]; then
+  pass "openenv validate passed"
+  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
+else
+  fail "openenv validate failed"
+  printf "%s\n" "$VALIDATE_OUTPUT"
+  stop_at "Step 3"
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}  All 3/3 checks passed!${NC}\n"
+printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+printf "\n"
+
+exit 0

inference.py

@@ -0,0 +1,102 @@
+import os
+import json
+from openai import OpenAI
+from env import CustomerSupportEnv
+from models import Action
+from tasks import TASKS
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+
+# 1. Required Environment Variables
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+if HF_TOKEN is None:
+    raise ValueError("HF_TOKEN environment variable is required")
+
+# 2. Open AI Client Only
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=HF_TOKEN
+)
+
+def run_inference():
+    env = CustomerSupportEnv()
+    
+    for idx, task in enumerate(TASKS):
+        obs = env.reset(task_idx=idx)
+        done = False
+        step_idx = 0
+        rewards_history = []
+        
+        # [START] FORMAT
+        print(f"[START] task={task.name} env=customer_support model={MODEL_NAME}")
+        
+        while not done:
+            step_idx += 1
+            error_msg = "null"
+            reward_val = 0.00
+            action_str = ""
+            
+            # 🚀 HEAVILY ENGINEERED PROMPT FOR STRICT COMPLIANCE
+            prompt = (
+                "System: You are an automated customer support AI. You MUST respond strictly in JSON format matching this schema: "
+                "{\"action_type\": \"ROUTE\"|\"ASK_INFO\"|\"REFUND\"|\"CLOSE\", \"argument\": \"string\"}\n\n"
+                "CRITICAL RULES:\n"
+                "1. If 'missing_info' in the observation is empty ([]), DO NOT use ASK_INFO. You must take action (ROUTE or REFUND).\n"
+                "2. If 'missing_info' contains items, you MUST use ASK_INFO. The 'argument' MUST contain the EXACT string from 'missing_info' (e.g., 'serial_number', 'order_id', 'photo_evidence'). Ask for ONLY ONE missing item at a time\n"
+                "3. When using ROUTE, the 'argument' MUST be exactly one of these three codes: 'IT_SUPPORT', 'HARDWARE_SUPPORT', or 'BILLING'. Do not output full sentences.\n"
+                "4. If the user wants a refund, and you have collected 'order_id', you MUST first use the REFUND action. Then, in the next step, use ROUTE with 'BILLING'.\n\n"
+                f"Observation: {obs.model_dump_json()}"
+            )
+
+            try:
+                response = client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=[{"role": "user", "content": prompt}],
+                    response_format={"type": "json_object"}
+                )
+                
+                # Safely parse JSON in case Qwen outputs markdown ticks
+                raw_action = response.choices[0].message.content.strip()
+                if raw_action.startswith("```json"):
+                    raw_action = raw_action[7:-3].strip()
+                elif raw_action.startswith("```"):
+                    raw_action = raw_action[3:-3].strip()
+                    
+                action_data = json.loads(raw_action)
+                
+                # Pydantic validation
+                action = Action(**action_data)
+                action_str = f"{action.action_type}('{action.argument}')"
+                
+                # Env Step
+                obs = env.step(action)
+                done = obs.done
+                reward_val = float(obs.reward) if obs.reward is not None else 0.0
+                rewards_history.append(reward_val)
+                
+            except Exception as e:
+                error_msg = str(e).replace('\n', ' ')
+                action_str = "ERROR"
+                done = True
+                rewards_history.append(0.00)
+                
+            # [STEP] FORMAT
+            print(f"[STEP] step={step_idx} action={action_str} reward={reward_val:.2f} done={str(done).lower()} error={error_msg}")
+
+        # [END] FORMAT
+        # A score > 0.8 typically means success based on our grader logic
+        final_score = sum(rewards_history) if rewards_history else 0.0
+        success = final_score > 0.8
+        rewards_str = ",".join([f"{r:.2f}" for r in rewards_history])
+        print(f"[END] success={str(success).lower()} steps={step_idx} score={final_score:.2f} rewards={rewards_str}")
+
+if __name__ == "__main__":
+    run_inference()

local_validate.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+PING_URL="http://localhost:7860"
+REPO_DIR="."
+
+echo "Step 1/3: Pinging HF Space ($PING_URL/reset) ..."
+HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST -H "Content-Type: application/json" -d '{}' "$PING_URL/reset" --max-time 30 2>/dev/null || printf "000")
+echo "HTTP_CODE: $HTTP_CODE"
+
+echo "Step 2/3: Running docker build ..."
+docker build "$REPO_DIR"
+
+echo "Step 3/3: Running openenv validate ..."
+openenv validate

models.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, ConfigDict, Field
+from typing import List, Literal, Optional
+import openenv.core.env_server.types as openenv_types
+
+class Observation(openenv_types.Observation):
+    ticket_id: str = Field(default="", description="Unique ID of the ticket")
+    customer_message: str = Field(default="", description="The current message from the customer")
+    history: List[str] = Field(default_factory=list, description="Conversation history")
+    missing_info: List[str] = Field(default_factory=list, description="Fields required before routing")
+    status: str = Field(default="OPEN", description="Ticket status")
+    refund_processed: bool = Field(default=False, description="True if a refund was already executed")
+
+class Action(openenv_types.Action):
+    action_type: Literal["ROUTE", "ASK_INFO", "REFUND", "CLOSE"] = Field(..., description="Type of action to take")
+    argument: str = Field(..., description="The category to route to, the question to ask, or the order ID to refund")
+
+class State(openenv_types.State):
+    ticket_id: str = Field(default="", description="Unique ID of the ticket")
+    customer_message: str = Field(default="", description="The current message from the customer")
+    history: List[str] = Field(default_factory=list, description="Conversation history")
+    missing_info: List[str] = Field(default_factory=list, description="Fields required before routing")
+    status: str = Field(default="OPEN", description="Ticket status")
+    refund_processed: bool = Field(default=False, description="True if a refund was already executed")
+
+class Reward(BaseModel):
+    value: float = Field(..., description="Numerical reward between -1.0 and 1.0")
+    feedback: str = Field(..., description="Incremental feedback for the agent")

openenv.yaml

@@ -0,0 +1,13 @@
+spec_version: 1
+name: "customer-support-triage"
+version: "1.0.0"
+type: "space"
+runtime: "fastapi"
+app: "server.app:app"
+port: 7860
+description: "A real-world customer support simulation environment requiring information extraction, system actions, and routing."
+tags: ["openenv", "text", "customer-support"]
+tasks:
+  - easy_password_reset
+  - medium_hardware_issue
+  - hard_refund_processing

pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "metapy"
+version = "1.0.0"
+description = "A real-world customer support simulation environment"
+dependencies = [
+    "openenv-core",
+    "fastapi",
+    "uvicorn",
+    "openai>=1.12.0",
+    "pydantic>=2.0.0",
+    "python-dotenv>=1.0.0"
+]
+
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[project.scripts]
+server = "server.app:main"

requirements.txt

@@ -0,0 +1,6 @@
+openai>=1.12.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+openenv-core>=0.1.0
+fastapi>=0.100.0
+uvicorn>=0.23.0

server/app.py

@@ -0,0 +1,21 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+import uvicorn
+from openenv.core.env_server.http_server import create_app
+from env import CustomerSupportEnv
+from models import Action, Observation
+
+# Use the environment class and Pydantic types to create the app
+app = create_app(
+    CustomerSupportEnv, 
+    Action, 
+    Observation, 
+    env_name="customer_support_env"
+)
+
+def main():
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+
+if __name__ == "__main__":
+    main()

tasks.py

@@ -0,0 +1,46 @@
+class TaskDef:
+    def __init__(self, name: str, initial_msg: str, expected_route: str, required_info: list = None, needs_refund: bool = False):
+        self.name = name
+        self.initial_msg = initial_msg
+        self.expected_route = expected_route
+        self.required_info = required_info or[]
+        self.needs_refund = needs_refund
+
+# Define 3 strict tasks (Easy, Medium, Hard)
+TASKS =[
+    TaskDef(
+        name="easy_password_reset",
+        initial_msg="I forgot my password and cannot log in.",
+        expected_route="IT_SUPPORT"
+    ),
+    TaskDef(
+        name="medium_hardware_issue",
+        initial_msg="My laptop won't turn on.",
+        expected_route="HARDWARE_SUPPORT",
+        required_info=["serial_number"]
+    ),
+    TaskDef(
+        name="hard_refund_processing",
+        initial_msg="I want a refund for my recent purchase, it arrived broken.",
+        expected_route="BILLING",
+        required_info=["order_id", "photo_evidence"],
+        needs_refund=True
+    )
+]
+
+def grader(task: TaskDef, final_state: dict) -> float:
+    """Deterministic programmatic grader returning 0.0 to 1.0"""
+    score = 0.0
+    total_checks = 1 + len(task.required_info) + (1 if task.needs_refund else 0)
+    
+    if final_state.get("route") == task.expected_route:
+        score += 1.0
+        
+    for info in task.required_info:
+        if info in final_state.get("collected_info",[]):
+            score += 1.0
+            
+    if task.needs_refund and final_state.get("refund_processed", False):
+        score += 1.0
+        
+    return score / total_checks