fix: correct inference log format, align openenv.yaml task IDs, harden Dockerfile

- inference.py: replace JSON stdout with hackathon-spec flat key=value format
([START] task=... env=... model=..., [STEP] step=... reward=0.00 ...,
[END] success=... score=... rewards=r1,r2,...); add try/finally so [END]
always emits; add max_tokens=300; fallback approve on LLM failure
- openenv.yaml: replace 3 wrong placeholder IDs with all 15 actual task IDs
(easy_001–005, medium_001–005, hard_001–005)
- Dockerfile: add curl + HEALTHCHECK --interval=30s; curl -f /health probe
- README.md: add HF openenv tag, Why This Matters section, reward/baseline tables
- server/environment.py: fix task.schema → task.schema_info (AttributeError on
request_more_context action)
- tests/test_reward.py: new file — 13 unit tests for all compute_reward() branches
- tests/test_api.py: add request_more_context regression test
- tests/test_inference.py: update run_episode assertion to match new return type
and log format

All 27 tests pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Dockerfile

@@ -4,6 +4,8 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
     PORT=8000
 
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /app
 
 COPY pyproject.toml README.md models.py client.py openenv.yaml inference.py ./
@@ -16,5 +18,7 @@ RUN pip install --no-cache-dir --upgrade pip && \
 
 EXPOSE 8000
 
-CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
 
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -5,180 +5,158 @@ colorTo: green
 sdk: docker
 app_port: 8000
 pinned: false
+tags:
+  - openenv
 ---
 
 # SQL Query Reviewer
 
-`Meta-hackathon` is the GitHub source repo for `sql-query-reviewer`, an OpenEnv-style environment where an agent reviews SQL queries for correctness, performance, and security issues.
+An OpenEnv environment where an AI agent reviews SQL queries for correctness, performance, and security — the same task thousands of engineers perform every day in code reviews, migration scripts, and ETL audits.
 
-The same repository is designed to work in both places:
-- GitHub is the canonical source, CI surface, and collaboration home.
-- Hugging Face Spaces runs the Dockerized FastAPI environment directly from this repo layout.
+## Why This Matters
+
+SQL bugs are among the most common and costly defects in production systems. A misplaced keyword breaks an API, a missing index degrades latency by 100x, and an unsanitized input opens a door to data exfiltration. Today these defects are caught by human reviewers who spend hours on repetitive pattern matching. This environment provides a standardized benchmark to train and evaluate AI agents that can automate this critical workflow — directly useful for developer tools, IDE integrations, and automated code review systems.
 
 ## What The Environment Does
 
 Each episode gives the agent:
-- a SQL query
-- schema context when it matters
+
+- a SQL query (with realistic bugs drawn from production patterns)
+- schema context when it matters (table definitions, column types, constraints)
 - a short explanation of the query's intended purpose
 
 The agent responds step by step with one of four actions:
-- `identify_issue`
-- `suggest_fix`
-- `approve`
-- `request_more_context`
 
-Rewards are deterministic and shaped for partial progress:
-- correct issue identification earns severity-weighted reward
-- valid fixes earn bonus reward
-- false positives are penalized
-- approving with missed issues is penalized
+| Action | Description |
+|---|---|
+| `identify_issue` | Flag a correctness, performance, or security problem |
+| `suggest_fix` | Propose corrected SQL for a previously identified issue |
+| `approve` | Mark the query as acceptable (ends episode) |
+| `request_more_context` | Ask for additional schema information |
 
-## Repository Layout
+## Reward Design
 
-```text
-.
-|-- .github/workflows/
-|-- client.py
-|-- Dockerfile
-|-- inference.py
-|-- models.py
-|-- openenv.yaml
-|-- pyproject.toml
-|-- server/
-|-- sql_query_reviewer/
-|-- tasks/
-`-- tests/
-```
+Rewards are deterministic and shaped for partial progress throughout the trajectory:
+
+- **Correct issue identification**: +0.10 to +0.35 scaled by issue severity
+- **Valid fix suggestion**: +0.08 to +0.10 bonus
+- **Confidence bonus**: up to +0.05 for high-confidence correct identifications
+- **False positive**: −0.10 penalty
+- **Duplicate identification**: −0.02 penalty
+- **Approving with missed issues**: −0.15 per missed issue
+- **Complete correct approval**: +0.20
 
 ## Task Bank
 
-The environment ships with 15 tasks:
-- 5 easy syntax and basic logic reviews
-- 5 medium schema-aware performance reviews
-- 5 hard security and advanced optimization reviews
+The environment ships with **15 tasks** across three difficulty levels:
 
-Task data lives in:
-- `tasks/easy_tasks.json`
-- `tasks/medium_tasks.json`
-- `tasks/hard_tasks.json`
+| Difficulty | Count | Examples | Expected Baseline Score |
+|---|---|---|---|
+| Easy | 5 | Misspelled keywords, missing FROM, = NULL vs IS NULL | ~0.75–0.90 |
+| Medium | 5 | SELECT *, missing indexes, correlated subqueries, unbounded queries | ~0.40–0.60 |
+| Hard | 5 | SQL injection, privilege escalation, PII leakage, self-join optimization | ~0.20–0.40 |
 
-## Local Development
+Task data: `tasks/easy_tasks.json`, `tasks/medium_tasks.json`, `tasks/hard_tasks.json`
 
-Install dependencies:
+## Action & Observation Spaces
 
-```bash
-python -m venv .venv
-.venv\Scripts\activate
-python -m pip install --upgrade pip
-python -m pip install -e .[dev]
-```
+**Action** (`SQLReviewAction`):
+- `action_type`: identify_issue | suggest_fix | approve | request_more_context
+- `issue_category`: syntax | performance | security | logic | style
+- `issue_description`: concise statement of the problem
+- `suggested_fix`: corrected SQL fragment
+- `confidence`: float 0.0–1.0
 
-Run the API locally:
+**Observation** (`SQLReviewObservation`):
+- `query`: the full SQL query text
+- `schema_info`: dict of table → column definitions
+- `context`: natural language description of query intent
+- `issues_found_so_far`: previously identified issues this episode
+- `remaining_actions`: steps left before episode ends
+- `difficulty`: easy | medium | hard
+- `feedback`: result of last action
 
-```bash
-uvicorn server.app:app --reload --port 8000
+## Repository Layout
+
+```
+.
+├── openenv.yaml
+├── models.py
+├── client.py
+├── inference.py          ← baseline agent (root directory)
+├── Dockerfile
+├── sql_query_reviewer/   ← typed models and client package
+├── server/               ← FastAPI environment server
+│   ├── environment.py    ← reset(), step(), state()
+│   ├── grader.py         ← deterministic scoring
+│   ├── reward.py         ← per-step reward computation
+│   └── app.py            ← HTTP routes
+├── tasks/                ← 15 SQL query tasks (JSON)
+└── tests/                ← pytest suite
 ```
 
-Smoke-test the API:
+## Local Development
 
 ```bash
-curl -X POST http://localhost:8000/reset -H "Content-Type: application/json" -d "{\"task_id\":\"easy_001\"}"
-curl http://localhost:8000/state
+python -m venv .venv
+source .venv/bin/activate   # or .venv\Scripts\activate on Windows
+pip install -e .[dev]
+uvicorn server.app:app --reload --port 8000
 ```
 
-Run tests:
-
+Test the API:
 ```bash
+curl -X POST http://localhost:8000/reset -H "Content-Type: application/json" -d '{"task_id":"easy_001"}'
+curl http://localhost:8000/state
 pytest
 ```
 
-Build the container:
+## Docker
 
 ```bash
 docker build -t sql-query-reviewer .
 docker run -p 8000:8000 sql-query-reviewer
 ```
 
-## Inference Script
-
-`inference.py` uses the OpenAI Python client against any OpenAI-compatible endpoint.
-
-Expected environment variables:
+## Inference
 
 ```bash
-set ENV_BASE_URL=http://localhost:8000
-set API_BASE_URL=https://router.huggingface.co/v1
-set MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
-set HF_TOKEN=hf_xxx
+export ENV_BASE_URL=http://localhost:8000
+export API_BASE_URL=https://router.huggingface.co/v1
+export MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
+export HF_TOKEN=hf_xxx
 python inference.py
 ```
 
-The script emits structured logs using:
-- `[START]`
-- `[STEP]`
-- `[END]`
+The script emits structured `[START]`, `[STEP]`, `[END]` logs per the OpenEnv spec.
 
 ## Hugging Face Spaces
 
-This repo is Space-ready because:
-- the README starts with Hugging Face YAML front matter
-- the repo includes a root `Dockerfile`
-- the API listens on port `8000`
-
-Recommended setup:
-1. Create a new Space at `https://huggingface.co/new-space`
-2. Set owner to your Hugging Face namespace, name to `sql-query-reviewer`, and SDK to `Docker`
-3. In GitHub, add repository secret `HF_TOKEN` with a Hugging Face token that can write to Spaces
-4. In GitHub, add repository variable `HF_SPACE_ID` with the exact repo id, for example `hellinferno/sql-query-reviewer`
-5. Push to `main` or run the `Sync To Hugging Face` workflow manually from the Actions tab
-
-Using `HF_SPACE_ID` is the safest option because your Hugging Face namespace may not match your GitHub owner name exactly.
-
-To deploy manually from a local machine with git:
+This repo is Space-ready: HF YAML front matter in README, root Dockerfile, API on port 8000. Deploy with:
 
 ```bash
-git remote add hf https://huggingface.co/spaces/<hf-username>/sql-query-reviewer
+git remote add hf https://huggingface.co/spaces/<username>/sql-query-reviewer
 git push hf main
 ```
 
-If you install the OpenEnv CLI, you can also use:
-
-```bash
-python -m pip install "git+https://github.com/meta-pytorch/OpenEnv.git"
-openenv push --repo-id <hf-username>/sql-query-reviewer
-```
-
-## GitHub Actions
-
-CI runs tests and a Docker build on pushes and pull requests.
-
-The Hugging Face sync workflow expects:
-- GitHub secret `HF_TOKEN`
-- optional GitHub variable `HF_SPACE_ID`
-
-If `HF_SPACE_ID` is not set, the workflow defaults to:
-
-```text
-<lowercased-github-repository-owner>/sql-query-reviewer
-```
-
 ## Usage Example
 
 ```python
 from sql_query_reviewer import SQLReviewAction, SQLReviewEnv
 
-with SQLReviewEnv(base_url="http://localhost:8000").sync() as env:
+with SQLReviewEnv(base_url="https://hellinferno-sql-query-reviewer.hf.space").sync() as env:
     result = env.reset(task_id="easy_001")
-    result = env.step(
-        SQLReviewAction(
-            action_type="identify_issue",
-            issue_category="syntax",
-            issue_description="SELCT is misspelled and should be SELECT",
-            suggested_fix="SELECT * FROM users WHERE id = 1;",
-            confidence=0.98,
-        )
-    )
+    result = env.step(SQLReviewAction(
+        action_type="identify_issue",
+        issue_category="syntax",
+        issue_description="SELCT is misspelled and should be SELECT",
+        suggested_fix="SELECT * FROM users WHERE id = 1;",
+        confidence=0.98,
+    ))
     print(result.reward)
     print(result.observation.feedback)
 ```
+
+## Author
+
+**Hellinferno** — Solo participant, Meta PyTorch OpenEnv Hackathon 2026

inference.py

@@ -1,15 +1,40 @@
+"""
+Inference Script — SQL Query Reviewer
+======================================
+MANDATORY environment variables:
+    API_BASE_URL   The API endpoint for the LLM.
+    MODEL_NAME     The model identifier to use for inference.
+    HF_TOKEN       Your Hugging Face / API key.
+
+STDOUT FORMAT:
+    [START] task=<task_name> env=<benchmark> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> score=<score> rewards=<r1,r2,...,rn>
+"""
+
 from __future__ import annotations
 
 import json
 import os
-from typing import Any
+from typing import Any, List, Optional
 
 from openai import OpenAI
 
 from sql_query_reviewer.client import SyncSQLReviewEnv
 from sql_query_reviewer.models import SQLReviewAction, SQLReviewObservation
 
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
 DEFAULT_TASK_IDS = ("easy_001", "medium_001", "hard_001")
+BENCHMARK = "sql-query-reviewer"
+SUCCESS_SCORE_THRESHOLD = 0.1
+
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:8000")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
 
 SYSTEM_PROMPT = """You are reviewing a SQL query for correctness, performance, and security.
 Return exactly one JSON object with these keys:
@@ -25,9 +50,39 @@ Guidelines:
 - Keep the JSON valid and do not wrap it in prose.
 """
 
+# ---------------------------------------------------------------------------
+# Structured stdout logging — MUST match the hackathon spec exactly
+# ---------------------------------------------------------------------------
+
+
+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:
+    done_str = str(done).lower()
+    error_str = error if error else "null"
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} "
+        f"done={done_str} error={error_str}",
+        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} "
+        f"score={score:.2f} rewards={rewards_str}",
+        flush=True,
+    )
 
-def print_event(prefix: str, payload: dict[str, Any]) -> None:
-    print(f"[{prefix}] {json.dumps(payload, sort_keys=True)}")
+
+# ---------------------------------------------------------------------------
+# LLM interaction
+# ---------------------------------------------------------------------------
 
 
 def build_user_prompt(observation: SQLReviewObservation) -> str:
@@ -35,7 +90,9 @@ def build_user_prompt(observation: SQLReviewObservation) -> str:
         "query": observation.query,
         "schema_info": observation.schema_info,
         "context": observation.context,
-        "issues_found_so_far": [issue.model_dump() for issue in observation.issues_found_so_far],
+        "issues_found_so_far": [
+            issue.model_dump() for issue in observation.issues_found_so_far
+        ],
         "remaining_actions": observation.remaining_actions,
         "difficulty": observation.difficulty,
         "feedback": observation.feedback,
@@ -48,7 +105,6 @@ def extract_json(content: str) -> dict[str, Any]:
     if stripped.startswith("```"):
         lines = [line for line in stripped.splitlines() if not line.startswith("```")]
         stripped = "\n".join(lines).strip()
-
     start = stripped.find("{")
     end = stripped.rfind("}")
     if start == -1 or end == -1 or end <= start:
@@ -56,76 +112,116 @@ def extract_json(content: str) -> dict[str, Any]:
     return json.loads(stripped[start : end + 1])
 
 
-def choose_action(llm_client: Any, model_name: str, observation: SQLReviewObservation) -> SQLReviewAction:
-    response = llm_client.chat.completions.create(
-        model=model_name,
-        temperature=0,
-        messages=[
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": build_user_prompt(observation)},
-        ],
-    )
-    content = response.choices[0].message.content or ""
-    return SQLReviewAction.model_validate(extract_json(content))
-
-
-def run_episode(env: Any, llm_client: Any, model_name: str, task_id: str) -> dict[str, Any]:
-    result = env.reset(task_id=task_id)
-    print_event(
-        "START",
-        {
-            "difficulty": result.observation.difficulty,
-            "remaining_actions": result.observation.remaining_actions,
-            "task_id": task_id,
-        },
-    )
-
-    while True:
-        action = choose_action(llm_client=llm_client, model_name=model_name, observation=result.observation)
-        result = env.step(action)
-        print_event(
-            "STEP",
-            {
-                "action": action.model_dump(exclude_none=True),
-                "done": result.done,
-                "feedback": result.observation.feedback,
-                "reward": result.reward,
-                "task_id": task_id,
-            },
+def choose_action(
+    llm_client: OpenAI, model_name: str, observation: SQLReviewObservation
+) -> SQLReviewAction:
+    try:
+        response = llm_client.chat.completions.create(
+            model=model_name,
+            temperature=0,
+            max_tokens=300,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": build_user_prompt(observation)},
+            ],
         )
-        if result.done:
-            state = env.state()
-            summary = {
-                "final_score": state.final_score,
-                "steps": state.step_count,
-                "task_id": task_id,
-                "total_reward": state.total_reward,
-            }
-            print_event("END", summary)
-            return summary
+        content = response.choices[0].message.content or ""
+        return SQLReviewAction.model_validate(extract_json(content))
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        # Fallback: approve to end the episode gracefully
+        return SQLReviewAction(action_type="approve", confidence=0.1)
+
+
+# ---------------------------------------------------------------------------
+# Episode runner
+# ---------------------------------------------------------------------------
+
+
+def run_episode(
+    env: SyncSQLReviewEnv, llm_client: OpenAI, model_name: str, task_id: str
+) -> None:
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+    last_error: Optional[str] = None
+
+    log_start(task=task_id, env=BENCHMARK, model=model_name)
+
+    try:
+        result = env.reset(task_id=task_id)
+
+        step = 0
+        while not result.done:
+            step += 1
+            action = choose_action(
+                llm_client=llm_client,
+                model_name=model_name,
+                observation=result.observation,
+            )
+
+            action_str = action.action_type
+            if action.issue_description:
+                # Keep action string short and readable
+                action_str = f"{action.action_type}({action.issue_category})"
+
+            result = env.step(action)
+
+            reward = result.reward
+            rewards.append(reward)
+            steps_taken = step
+            last_error = result.info.get("error") if result.info else None
+
+            log_step(
+                step=step,
+                action=action_str,
+                reward=reward,
+                done=result.done,
+                error=last_error,
+            )
+
+        # Get final score from state
+        state = env.state()
+        score = state.final_score if state.final_score is not None else 0.0
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    except Exception as exc:
+        print(f"[DEBUG] Episode error: {exc}", flush=True)
+        last_error = str(exc)
+
+    finally:
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
 
 
 def main() -> int:
-    env_base_url = os.getenv("ENV_BASE_URL", "http://localhost:8000")
-    api_base_url = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
-    model_name = os.getenv("MODEL_NAME", "gpt-4o-mini")
-    api_key = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY")
-    if not api_key:
+    if not API_KEY:
         raise SystemExit("Set HF_TOKEN or OPENAI_API_KEY before running inference.py")
 
     task_ids = tuple(
-        task_id.strip()
-        for task_id in os.getenv("TASK_IDS", ",".join(DEFAULT_TASK_IDS)).split(",")
-        if task_id.strip()
+        tid.strip()
+        for tid in os.getenv("TASK_IDS", ",".join(DEFAULT_TASK_IDS)).split(",")
+        if tid.strip()
     )
 
-    llm_client = OpenAI(api_key=api_key, base_url=api_base_url)
-    with SyncSQLReviewEnv(base_url=env_base_url) as env:
+    llm_client = OpenAI(api_key=API_KEY, base_url=API_BASE_URL)
+
+    with SyncSQLReviewEnv(base_url=ENV_BASE_URL) as env:
         for task_id in task_ids:
-            run_episode(env=env, llm_client=llm_client, model_name=model_name, task_id=task_id)
+            run_episode(
+                env=env,
+                llm_client=llm_client,
+                model_name=MODEL_NAME,
+                task_id=task_id,
+            )
+
     return 0
 
 
 if __name__ == "__main__":
     raise SystemExit(main())
-

openenv.yaml

@@ -8,16 +8,63 @@ tags:
   - code-review
   - security
 tasks:
-  - id: easy_syntax
-    name: Syntax Error Detection
+  - id: easy_001
+    name: Syntax Keyword Typos
     difficulty: easy
-    description: Find obvious SQL syntax and logic defects.
-  - id: medium_performance
+    description: "Detect misspelled SQL keywords (SELCT, FORM, WEHRE) and unnecessary SELECT *."
+  - id: easy_002
+    name: Missing FROM Clause
+    difficulty: easy
+    description: "Find missing FROM keyword before table name."
+  - id: easy_003
+    name: NULL Comparison Logic
+    difficulty: easy
+    description: "Detect = NULL instead of IS NULL."
+  - id: easy_004
+    name: Unclosed String Literal
+    difficulty: easy
+    description: "Find unterminated quote in WHERE clause."
+  - id: easy_005
+    name: Unknown Column Name
+    difficulty: easy
+    description: "Detect column name typo (statuz vs status)."
+  - id: medium_001
     name: Performance Anti-Pattern Review
     difficulty: medium
-    description: Identify schema-aware performance problems.
-  - id: hard_security
-    name: Security and Optimization Audit
+    description: "Identify schema-aware performance problems like SELECT *, missing indexes, correlated subqueries."
+  - id: medium_002
+    name: Unbounded Query Detection
+    difficulty: medium
+    description: "Find queries missing LIMIT on large tables."
+  - id: medium_003
+    name: Redundant Operations
+    difficulty: medium
+    description: "Detect unnecessary DISTINCT on unique columns."
+  - id: medium_004
+    name: Correlated Subquery Optimization
+    difficulty: medium
+    description: "Find correlated subqueries that could be JOINs."
+  - id: medium_005
+    name: Join Performance Issues
+    difficulty: medium
+    description: "Identify missing index hints and inefficient joins."
+  - id: hard_001
+    name: SQL Injection Detection
+    difficulty: hard
+    description: "Find string concatenation enabling SQL injection vectors."
+  - id: hard_002
+    name: Privilege Escalation via UNION
+    difficulty: hard
+    description: "Detect UNION with system tables exposing sensitive data."
+  - id: hard_003
+    name: PII Data Leakage
+    difficulty: hard
+    description: "Find unfiltered JOINs exposing personally identifiable information."
+  - id: hard_004
+    name: Self-Join Optimization
+    difficulty: hard
+    description: "Detect self-joins replaceable with window functions for 10x improvement."
+  - id: hard_005
+    name: Transaction Isolation Issues
     difficulty: hard
-    description: Detect injection, data exposure, and advanced optimization issues.
-
+    description: "Find missing transaction isolation causing phantom reads."

tests/test_inference.py

@@ -72,11 +72,13 @@ def test_run_episode_emits_start_step_end_logs(capsys) -> None:
         def __init__(self) -> None:
             self.chat = SimpleNamespace(completions=DummyCompletions())
 
-    summary = inference.run_episode(DummyEnv(), DummyClient(), "dummy-model", "easy_999")
+    inference.run_episode(DummyEnv(), DummyClient(), "dummy-model", "easy_999")
     captured = capsys.readouterr().out
 
     assert "[START]" in captured
+    assert "task=easy_999" in captured
     assert "[STEP]" in captured
     assert "[END]" in captured
-    assert summary["final_score"] == 1.0
+    assert "success=true" in captured
+    assert "score=1.00" in captured