Upload folder using huggingface_hub

README.md

@@ -0,0 +1,33 @@
+---
+title: OpenEnv Pathway Analysis Environment
+emoji: 🧬
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 8000
+tags:
+  - openenv
+  - bioinformatics
+  - ai-agents
+---
+
+# OpenEnv Pathway Analysis Environment
+
+This repository packages `pathway_analysis_env` for Hugging Face Hub publication.
+
+## Contents
+- `envs/pathway_analysis_env/` environment code
+- reproducible GEO benchmark inputs for 3 tasks
+- task expansion scripts:
+  - `create_geo_task.py`
+  - `append_task_to_manifest.py`
+
+## Run locally
+```bash
+uv sync --all-extras
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_agent_eval_suite.py   --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json
+```
+
+## Note on Spaces
+Publishing as a Docker Space from a free user namespace may require Hugging Face PRO.
+This repo is ready for maintainers to deploy under an entitled namespace.

envs/pathway_analysis_env/README.md

@@ -0,0 +1,109 @@
+# Pathway Analysis Environment
+
+`pathway_analysis_env` is an OpenEnv environment for evaluating tool-using agents
+on a realistic RNA-seq-style analysis loop.
+
+Each task gives:
+- a gene-expression matrix (`counts_file`)
+- sample groups (`sample_metadata`)
+- a default contrast (reference vs alternate condition)
+
+The agent must execute:
+1. inspect/understand design
+2. differential expression (which genes changed)
+3. pathway enrichment (which biological programs are implicated)
+4. submit a final pathway hypothesis
+
+## Quick start
+
+From repo root:
+
+```bash
+uv sync --all-extras
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_agent_eval_suite.py \
+  --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json
+```
+
+Run LLM eval:
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py \
+  --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json
+```
+
+Run LLM judge for one case:
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_judge.py \
+  --case geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json \
+  --agent-model gpt-5 \
+  --judge-model gpt-5
+```
+
+## Add a new GEO task (2 commands)
+
+### Where to download public data
+
+Use NCBI GEO as the primary source:
+
+- GEO home: [https://www.ncbi.nlm.nih.gov/geo/](https://www.ncbi.nlm.nih.gov/geo/)
+- GEO DataSets search: [https://www.ncbi.nlm.nih.gov/gds](https://www.ncbi.nlm.nih.gov/gds)
+- Series record page pattern: `https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSEXXXX`
+
+From each series page, use:
+- **Series Matrix File(s)** for metadata/expression tables
+- **Supplementary file** links for count tables
+
+If you need raw sequencing reads instead of processed tables:
+- SRA home: [https://www.ncbi.nlm.nih.gov/sra](https://www.ncbi.nlm.nih.gov/sra)
+- GEO-to-SRA links are usually available from the GEO series page
+
+### 1) Create case + copy counts
+
+Prepare a metadata CSV with columns:
+- `sample_id`
+- `condition`
+
+Then run:
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/create_geo_task.py \
+  --task-id gseXXXX_example \
+  --accession GSEXXXX \
+  --summary "One-line study summary" \
+  --counts-file /absolute/path/to/counts.csv.gz \
+  --metadata-csv /absolute/path/to/samples.csv \
+  --reference-condition control \
+  --alternate-condition treated
+```
+
+This creates:
+- `data/geo_eval/gseXXXX_example/gsexxxx_case.json`
+- `data/geo_eval/gseXXXX_example/<counts file>`
+
+### 2) Add it to a manifest
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/append_task_to_manifest.py \
+  --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json \
+  --episode-id geo_gseXXXX_example \
+  --case-file geo_eval/gseXXXX_example/gsexxxx_case.json \
+  --hypothesis "expected biological theme"
+```
+
+Now rerun eval on that manifest.
+
+## Scripts
+
+- `scripts/create_geo_task.py` — create a GEO case from counts + metadata.
+- `scripts/append_task_to_manifest.py` — append/update one episode in a manifest.
+- `scripts/run_agent_eval_suite.py` — run scripted environment evaluation.
+- `scripts/run_llm_agent_eval.py` — run tool-calling LLM evaluation.
+- `scripts/run_llm_judge.py` — score report quality with an LLM judge.
+- `scripts/export_agent_safe_cases.py` — export secret-stripped case files.
+
+## Notes
+
+- Keep large intermediate artifacts (`de_all.json`, `enrichment.json`, `work/`) out of commits unless required.
+- For reproducibility, commit only case JSON + minimal raw inputs (counts/metadata mapping) needed to rerun.
+- Eval defaults are documented in `docs/AGENT_EVAL.md`.

envs/pathway_analysis_env/__init__.py

@@ -0,0 +1,27 @@
+# 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.
+
+"""
+Pathway Analysis Environment for OpenEnv.
+
+A toy computational-biology environment where an agent identifies the
+activated signaling pathway from synthetic omics data.
+
+Example:
+    >>> from pathway_analysis_env import PathwayEnv, PathwayAction
+    >>>
+    >>> with PathwayEnv(base_url="http://localhost:8000") as client:
+    ...     result = client.reset()
+    ...     result = client.step(PathwayAction(action_type="inspect_dataset"))
+    ...     result = client.step(PathwayAction(action_type="run_differential_expression"))
+    ...     result = client.step(PathwayAction(action_type="run_pathway_enrichment"))
+    ...     result = client.step(PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling"))
+"""
+
+from .client import PathwayEnv
+from .models import PathwayAction, PathwayObservation, PathwayState
+
+__all__ = ["PathwayEnv", "PathwayAction", "PathwayObservation", "PathwayState"]

envs/pathway_analysis_env/agent_openai_tools.json

@@ -0,0 +1,161 @@
+{
+  "schema_version": "openai_chat_completions_tools_v1",
+  "notes": [
+    "One function per environment action (recommended). Map tool name -> PathwayAction.action_type in the harness.",
+    "Call env reset() before the tool loop; reset is not an OpenAI tool.",
+    "Compatible with Chat Completions tools= and Responses API function tools (same shape)."
+  ],
+  "tools": [
+    {
+      "type": "function",
+      "function": {
+        "name": "understand_experiment_design",
+        "description": "Summarize experimental groups (conditions, sample counts, default contrast). Optionally validate a DESeq2 contrast by providing reference (condition_a) and alternate (condition_b). Does not run differential expression. Provide both condition fields or neither.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "condition_a": {
+              "type": "string",
+              "description": "Reference / baseline condition name (denominator for log2FC). Must match a value in available_conditions."
+            },
+            "condition_b": {
+              "type": "string",
+              "description": "Alternate / comparison condition name. Must differ from condition_a."
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "inspect_dataset",
+        "description": "Return sample IDs, per-sample condition metadata, and whether PyDESeq2 is available. Does not run DE or enrichment.",
+        "parameters": {
+          "type": "object",
+          "properties": {},
+          "additionalProperties": false
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "run_differential_expression",
+        "description": "Run PyDESeq2 differential expression for reference vs alternate on the episode count matrix. Requires condition_a and condition_b unless a contrast was validated via understand_experiment_design or the case defines default_contrast.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "condition_a": {
+              "type": "string",
+              "description": "Reference condition (baseline)."
+            },
+            "condition_b": {
+              "type": "string",
+              "description": "Alternate condition (comparison)."
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "run_pathway_enrichment",
+        "description": "Run over-representation analysis (Fisher ORA) on DE genes against pathway gene sets in the case. In pipeline mode, run_differential_expression must succeed first.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "gene_list": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Optional explicit gene list for ORA. If omitted, uses significant DE genes from the last DE step per case analysis_options."
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "compare_pathways",
+        "description": "Compare exclusive vs shared differential-expression gene support between two named pathways from the case pathway_genes.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "pathway_a": {
+              "type": "string",
+              "description": "First pathway name (exact string as in enrichment results or case pathway_genes keys)."
+            },
+            "pathway_b": {
+              "type": "string",
+              "description": "Second pathway name."
+            }
+          },
+          "required": ["pathway_a", "pathway_b"],
+          "additionalProperties": false
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "submit_answer",
+        "description": "Submit final hypothesis: the activated signaling pathway name. Ends the episode. String must match case pathway naming exactly (case-insensitive match on server).",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "hypothesis": {
+              "type": "string",
+              "description": "Pathway name, e.g. 'MAPK signaling'."
+            }
+          },
+          "required": ["hypothesis"],
+          "additionalProperties": false
+        }
+      }
+    }
+  ],
+  "unified_alternative": {
+    "description": "Single-tool variant that maps 1:1 to PathwayAction if you prefer one function with action_type enum.",
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "pathway_env_step",
+          "description": "Execute one step in the pathway analysis environment.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "action_type": {
+                "type": "string",
+                "enum": [
+                  "understand_experiment_design",
+                  "inspect_dataset",
+                  "run_differential_expression",
+                  "run_pathway_enrichment",
+                  "compare_pathways",
+                  "submit_answer"
+                ]
+              },
+              "condition_a": { "type": "string" },
+              "condition_b": { "type": "string" },
+              "gene_list": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "hypothesis": { "type": "string" },
+              "pathway_a": { "type": "string" },
+              "pathway_b": { "type": "string" }
+            },
+            "required": ["action_type"],
+            "additionalProperties": false
+          }
+        }
+      }
+    ]
+  }
+}

envs/pathway_analysis_env/agent_openai_tools.py

@@ -0,0 +1,178 @@
+# 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.
+
+"""
+OpenAI-style tool definitions and mapping to PathwayAction.
+
+Usage:
+    from pathway_analysis_env.agent_openai_tools import (
+        OPENAI_TOOLS,
+        tool_call_to_pathway_action,
+    )
+
+    # Pass OPENAI_TOOLS to OpenAI Chat Completions `tools=` or Responses API.
+    # On tool_call, convert and step:
+    action = tool_call_to_pathway_action(
+        name=tool_call.function.name,
+        arguments_json=tool_call.function.arguments,
+    )
+    result = await client.step(action)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Optional, Set
+
+from pathway_analysis_env.models import PathwayAction
+
+_TOOL_NAMES: Set[str] = {
+    "understand_experiment_design",
+    "inspect_dataset",
+    "run_differential_expression",
+    "run_pathway_enrichment",
+    "compare_pathways",
+    "submit_answer",
+    "pathway_env_step",
+}
+
+
+# Per-action tools (recommended). Load from JSON to keep a single source of truth.
+def _load_tools() -> List[Dict[str, Any]]:
+    path = Path(__file__).with_name("agent_openai_tools.json")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return list(data["tools"])
+
+
+OPENAI_TOOLS: List[Dict[str, Any]] = _load_tools()
+
+
+def _coerce_optional_str(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    s = str(value).strip()
+    return s if s else None
+
+
+def _coerce_gene_list(value: Any) -> Optional[List[str]]:
+    if value is None:
+        return None
+    if not isinstance(value, list):
+        raise ValueError("gene_list must be an array of strings")
+    return [str(g).strip() for g in value if str(g).strip()]
+
+
+def tool_call_to_pathway_action(
+    *,
+    name: str,
+    arguments_json: str | Mapping[str, Any],
+) -> PathwayAction:
+    """
+    Convert an OpenAI tool call into a PathwayAction for env.step().
+
+    Supports:
+      - Six named tools (name = action_type)
+      - Unified ``pathway_env_step`` with action_type inside arguments
+    """
+    if isinstance(arguments_json, str):
+        parsed: Any = json.loads(arguments_json) if arguments_json.strip() else {}
+    else:
+        parsed = arguments_json
+    # Models occasionally emit ``null`` / non-object arguments (e.g. the JSON
+    # literal ``null`` parses to ``None``). Treat anything that is not a
+    # mapping as empty so callers fail gracefully instead of raising
+    # ``AttributeError`` on ``args.get(...)``.
+    args: Dict[str, Any] = dict(parsed) if isinstance(parsed, Mapping) else {}
+
+    if name == "pathway_env_step":
+        action_type = args.get("action_type")
+        if not action_type or action_type not in _TOOL_NAMES - {"pathway_env_step"}:
+            raise ValueError(
+                f"Invalid action_type in pathway_env_step: {action_type!r}"
+            )
+    elif name in _TOOL_NAMES:
+        action_type = name
+    else:
+        raise ValueError(f"Unknown tool name: {name!r}")
+
+    return PathwayAction(
+        action_type=action_type,
+        condition_a=_coerce_optional_str(args.get("condition_a")),
+        condition_b=_coerce_optional_str(args.get("condition_b")),
+        gene_list=_coerce_gene_list(args.get("gene_list")),
+        hypothesis=_coerce_optional_str(args.get("hypothesis")),
+        pathway_a=_coerce_optional_str(args.get("pathway_a")),
+        pathway_b=_coerce_optional_str(args.get("pathway_b")),
+    )
+
+
+# Default row caps for list-valued observation fields. Large omics tables
+# (differential expression results, enrichment rows) otherwise balloon the LLM
+# context and burn tokens; the agent only needs the top-ranked rows to reason,
+# and the environment scores against its own full internal tables regardless.
+_OBS_LIST_CAPS: Dict[str, int] = {
+    "de_genes": 30,
+    "pathway_enrichment": 20,
+    "top_genes": 30,
+    "top_pathways": 20,
+}
+
+
+def truncate_observation_payload(
+    payload: Dict[str, Any],
+    *,
+    list_caps: Optional[Mapping[str, int]] = None,
+) -> Dict[str, Any]:
+    """
+    Cap long list-valued fields in an observation payload to control token use.
+
+    Returns a shallow copy with capped lists. A ``_truncation_note`` field is
+    added when anything was truncated so the agent knows results were trimmed.
+    The local ``trace_path`` is dropped (not useful to a remote agent).
+    """
+    caps = dict(_OBS_LIST_CAPS)
+    if list_caps:
+        caps.update(list_caps)
+    out = dict(payload)
+    notes: List[str] = []
+    for key, cap in caps.items():
+        val = out.get(key)
+        if isinstance(val, list) and len(val) > cap:
+            notes.append(f"{key}: showing top {cap} of {len(val)}")
+            out[key] = val[:cap]
+    out.pop("trace_path", None)
+    if notes:
+        out["_truncation_note"] = "; ".join(notes)
+    return out
+
+
+def observation_to_tool_result_content(
+    observation: Any,
+    *,
+    truncate: bool = True,
+    list_caps: Optional[Mapping[str, int]] = None,
+) -> str:
+    """Serialize observation for OpenAI tool role message (truncation-friendly).
+
+    By default, long omics tables are capped (see ``truncate_observation_payload``)
+    to keep tool results within practical context/token budgets. Pass
+    ``truncate=False`` to serialize the full payload.
+    """
+    if hasattr(observation, "model_dump"):
+        payload = observation.model_dump()
+    elif isinstance(observation, dict):
+        payload = observation
+    else:
+        payload = {
+            "message": getattr(observation, "message", ""),
+            "reward": getattr(observation, "reward", 0.0),
+            "done": getattr(observation, "done", False),
+            "metadata": getattr(observation, "metadata", {}),
+        }
+    if truncate:
+        payload = truncate_observation_payload(payload, list_caps=list_caps)
+    return json.dumps(payload, default=str)

envs/pathway_analysis_env/client.py

@@ -0,0 +1,116 @@
+# 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.
+
+"""
+Pathway Analysis Environment Client.
+
+Provides a WebSocket-based client for interacting with a running
+Pathway Analysis server.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import httpx
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_client import EnvClient
+
+from .models import PathwayAction, PathwayObservation, PathwayState
+
+
+class PathwayEnv(EnvClient[PathwayAction, PathwayObservation, PathwayState]):
+    """
+    Client for the Pathway Analysis Environment.
+
+    Example:
+        >>> with PathwayEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     result = client.step(PathwayAction(action_type="inspect_dataset"))
+        ...     print(result.observation.message)
+    """
+
+    def _step_payload(self, action: PathwayAction) -> Dict[str, Any]:
+        return {
+            "action_type": action.action_type,
+            "condition_a": action.condition_a,
+            "condition_b": action.condition_b,
+            "gene_list": action.gene_list,
+            "hypothesis": action.hypothesis,
+            "pathway_a": action.pathway_a,
+            "pathway_b": action.pathway_b,
+        }
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[PathwayObservation]:
+        obs_data = payload.get("observation", {})
+        observation = PathwayObservation(
+            message=obs_data.get("message", ""),
+            available_conditions=obs_data.get("available_conditions", []),
+            top_genes=obs_data.get("top_genes", []),
+            top_pathways=obs_data.get("top_pathways", []),
+            de_genes=obs_data.get("de_genes", []),
+            pathway_enrichment=obs_data.get("pathway_enrichment", []),
+            pathway_comparison=obs_data.get("pathway_comparison"),
+            overlap_summary=obs_data.get("overlap_summary"),
+            statistical_ambiguity=obs_data.get("statistical_ambiguity"),
+            trace_path=obs_data.get("trace_path"),
+            experiment_design=obs_data.get("experiment_design"),
+            done=obs_data.get("done", False),
+            reward=obs_data.get("reward", 0.0),
+            metadata=obs_data.get("metadata", {}),
+        )
+        return StepResult(
+            observation=observation,
+            reward=observation.reward,
+            done=observation.done,
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> PathwayState:
+        return PathwayState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            conditions=payload.get("conditions", []),
+            de_run=payload.get("de_run", False),
+            enrichment_run=payload.get("enrichment_run", False),
+            is_done=payload.get("is_done", False),
+            pipeline_mode=payload.get("pipeline_mode", False),
+            strict_mode=payload.get("strict_mode", False),
+            legacy_mode=payload.get("legacy_mode", False),
+            eval_mode=payload.get("eval_mode", True),
+            max_steps=payload.get("max_steps", 30),
+            design_understood=payload.get("design_understood", False),
+            validated_reference=payload.get("validated_reference"),
+            validated_alternate=payload.get("validated_alternate"),
+        )
+
+    def _http_base_url(self) -> str:
+        ws = getattr(self, "_ws_url", "ws://localhost:8000/ws")
+        http = ws.replace("wss://", "https://").replace("ws://", "http://")
+        if http.endswith("/ws"):
+            http = http[:-3]
+        return http.rstrip("/")
+
+    def fetch_episode_outcome(self, timeout: float = 30.0) -> Dict[str, Any]:
+        """
+        Fetch orchestrator episode score from a running pathway server.
+
+        Requires the server started with web interface (default). Only valid after
+        ``submit_answer`` in the same session.
+        """
+        base = self._http_base_url()
+        with httpx.Client(timeout=timeout) as client:
+            r = client.get(f"{base}/orchestrator/episode_outcome")
+            r.raise_for_status()
+            return r.json()
+
+    def fetch_eval_protocol(self, timeout: float = 30.0) -> Dict[str, Any]:
+        """Fetch eval protocol summary from ``GET /orchestrator/eval_protocol``."""
+        base = self._http_base_url()
+        with httpx.Client(timeout=timeout) as client:
+            r = client.get(f"{base}/orchestrator/eval_protocol")
+            r.raise_for_status()
+            return r.json()

envs/pathway_analysis_env/data/eval_manifest_geo.json

@@ -0,0 +1,18 @@
+{
+  "description": "Real-world GEO task: GSE128911 fulvestrant vs DMSO.",
+  "defaults": {
+    "eval_mode": true,
+    "max_steps": 30,
+    "orchestrator_mode": true
+  },
+  "episodes": [
+    {
+      "id": "geo_gse128911_fulvestrant",
+      "case_file": "geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json",
+      "hypothesis": "estrogen response",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    }
+  ]
+}

envs/pathway_analysis_env/data/eval_manifest_geo2.json

@@ -0,0 +1,26 @@
+{
+  "description": "Two additional real-world GEO tasks: GSE111151 (tamoxifen resistance) and GSE216540 (fulvestrant pseudo-counts).",
+  "defaults": {
+    "eval_mode": true,
+    "max_steps": 30,
+    "orchestrator_mode": true
+  },
+  "episodes": [
+    {
+      "id": "geo_gse111151_tamoxifen_resistance",
+      "case_file": "geo_eval/gse111151_tamoxifen_benchmark/gse111151_case.json",
+      "hypothesis": "estrogen / tamoxifen resistance",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    },
+    {
+      "id": "geo_gse216540_fulvestrant_pseudo",
+      "case_file": "geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_case.json",
+      "hypothesis": "interferon / immune response",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    }
+  ]
+}

envs/pathway_analysis_env/data/eval_manifest_geo3.json

@@ -0,0 +1,34 @@
+{
+  "description": "Three real-world GEO tasks for capability comparison.",
+  "defaults": {
+    "eval_mode": true,
+    "max_steps": 30,
+    "orchestrator_mode": true
+  },
+  "episodes": [
+    {
+      "id": "geo_gse128911_fulvestrant",
+      "case_file": "geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json",
+      "hypothesis": "estrogen response",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    },
+    {
+      "id": "geo_gse111151_tamoxifen_resistance",
+      "case_file": "geo_eval/gse111151_tamoxifen_benchmark/gse111151_case.json",
+      "hypothesis": "estrogen / tamoxifen resistance",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    },
+    {
+      "id": "geo_gse216540_fulvestrant_pseudo",
+      "case_file": "geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_case.json",
+      "hypothesis": "interferon / immune response",
+      "requires_pydeseq2": true,
+      "requires_gseapy": true,
+      "score_mode": "keywords"
+    }
+  ]
+}

envs/pathway_analysis_env/data/geo_eval/gse111151_tamoxifen_benchmark/gse111151_case.json

@@ -0,0 +1,49 @@
+{
+  "case_id": "GSE111151_tamoxifen_resistance_parental",
+  "strict_mode": false,
+  "experiment_metadata": {
+    "accession": "GSE111151",
+    "reference": "https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE111151",
+    "summary": "Merged author per-sample raw counts (GEO legacy supplement files GSE111151_GSM1417177\u201384 \u2192 GSM3024053\u201360); 8/11 matrix columns (BT-474 arm not on this FTP mirror)."
+  },
+  "counts_file": "geo_eval/gse111151_tamoxifen_benchmark/gse111151_counts.csv.gz",
+  "sample_ids": [
+    "GSM3024053",
+    "GSM3024054",
+    "GSM3024055",
+    "GSM3024056",
+    "GSM3024057",
+    "GSM3024058",
+    "GSM3024059",
+    "GSM3024060"
+  ],
+  "sample_metadata": {
+    "GSM3024053": "parental",
+    "GSM3024054": "tamoxifen_resistant",
+    "GSM3024055": "parental",
+    "GSM3024056": "tamoxifen_resistant",
+    "GSM3024057": "tamoxifen_resistant",
+    "GSM3024058": "parental",
+    "GSM3024059": "tamoxifen_resistant",
+    "GSM3024060": "tamoxifen_resistant"
+  },
+  "conditions": [
+    "parental",
+    "tamoxifen_resistant"
+  ],
+  "default_contrast": {
+    "reference": "parental",
+    "alternate": "tamoxifen_resistant"
+  },
+  "analysis_options": {
+    "min_total_count": 10,
+    "padj_alpha": 0.05,
+    "de_query_direction": "both"
+  },
+  "enrichr_libraries": [
+    "MSigDB_Hallmark_2020",
+    "KEGG_2021_Human",
+    "Reactome_2022"
+  ],
+  "true_pathway": "Unknown (GEO benchmark)"
+}

envs/pathway_analysis_env/data/geo_eval/gse111151_tamoxifen_benchmark/gse111151_counts.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c4c9d087b82c73bf33b8a6a0aaaf9f80d5d8f30e4bb72d692bb864b594467a7
+size 574584

envs/pathway_analysis_env/data/geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json

@@ -0,0 +1,43 @@
+{
+  "case_id": "GSE128911_mda_mb_134_vi_fulvestrant_vs_dmso",
+  "strict_mode": false,
+  "experiment_metadata": {
+    "accession": "GSE128911",
+    "reference": "https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE128911",
+    "summary": "Dataset 2 count matrix subset (MDA-MB-134-VI; 2\u00d72 DMSO vs Fulvestrant)."
+  },
+  "counts_file": "geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_dataset2_subset_counts.csv.gz",
+  "sample_ids": [
+    "SAM24360838",
+    "SAM24360839",
+    "SAM24360844",
+    "SAM24360845"
+  ],
+  "sample_metadata": {
+    "SAM24360838": "dmso",
+    "SAM24360839": "dmso",
+    "SAM24360844": "fulvestrant",
+    "SAM24360845": "fulvestrant"
+  },
+  "conditions": [
+    "dmso",
+    "fulvestrant"
+  ],
+  "default_contrast": {
+    "reference": "dmso",
+    "alternate": "fulvestrant"
+  },
+  "analysis_options": {
+    "min_total_count": 10,
+    "padj_alpha": 0.05,
+    "de_query_direction": "both"
+  },
+  "enrichr_libraries": [
+    "MSigDB_Hallmark_2020",
+    "KEGG_2021_Human",
+    "Reactome_2022"
+  ],
+  "true_pathway": "Unknown (GEO benchmark)",
+  "eval_mode": true,
+  "max_steps": 30
+}

envs/pathway_analysis_env/data/geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_dataset2_subset_counts.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd8c97b666b6640046a506aa68afee80aa877ec12df46323a9865aafb1e6e855
+size 236321

envs/pathway_analysis_env/data/geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_case.json

@@ -0,0 +1,114 @@
+{
+  "case_id": "GSE216540_FULV_vs_DMSO_tpm_pseudo_full",
+  "strict_mode": false,
+  "experiment_metadata": {
+    "accession": "GSE216540",
+    "reference": "https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE216540",
+    "summary": "TPM matrix from GEO supplement; pseudo-counts = round(TPM * 100.0). For OpenEnv pipeline testing only, not DESeq2-ground-truth counts."
+  },
+  "counts_file": "geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_pseudo_counts.csv.gz",
+  "sample_ids": [
+    "28_CM_DMSO_1",
+    "28_CM_DMSO_2",
+    "28_CM_DMSO_3",
+    "28_CM_DMSO_4",
+    "28_CM_FULV_1",
+    "28_CM_FULV_2",
+    "28_CM_FULV_3",
+    "28_CM_FULV_4",
+    "28_NC_DMSO_1",
+    "28_NC_DMSO_2",
+    "28_NC_DMSO_3",
+    "28_NC_DMSO_4",
+    "28_NC_FULV_1",
+    "28_NC_FULV_2",
+    "28_NC_FULV_3",
+    "28_NC_FULV_4",
+    "30_CM_DMSO_1",
+    "30_CM_DMSO_2",
+    "30_CM_DMSO_3",
+    "30_CM_DMSO_4",
+    "30_CM_FULV_1",
+    "30_CM_FULV_2",
+    "30_CM_FULV_3",
+    "30_CM_FULV_4",
+    "30_NC_DMSO_1",
+    "30_NC_DMSO_2",
+    "30_NC_DMSO_3",
+    "30_NC_DMSO_4",
+    "30_NC_FULV_1",
+    "30_NC_FULV_2",
+    "30_NC_FULV_3",
+    "30_NC_FULV_4",
+    "46_CM_DMSO_1",
+    "46_CM_DMSO_2",
+    "46_CM_FULV_1",
+    "46_CM_FULV_2",
+    "46_NC_DMSO_1",
+    "46_NC_DMSO_2",
+    "46_NC_FULV_1",
+    "46_NC_FULV_2"
+  ],
+  "sample_metadata": {
+    "28_CM_DMSO_1": "DMSO",
+    "28_CM_DMSO_2": "DMSO",
+    "28_CM_DMSO_3": "DMSO",
+    "28_CM_DMSO_4": "DMSO",
+    "28_CM_FULV_1": "FULV",
+    "28_CM_FULV_2": "FULV",
+    "28_CM_FULV_3": "FULV",
+    "28_CM_FULV_4": "FULV",
+    "28_NC_DMSO_1": "DMSO",
+    "28_NC_DMSO_2": "DMSO",
+    "28_NC_DMSO_3": "DMSO",
+    "28_NC_DMSO_4": "DMSO",
+    "28_NC_FULV_1": "FULV",
+    "28_NC_FULV_2": "FULV",
+    "28_NC_FULV_3": "FULV",
+    "28_NC_FULV_4": "FULV",
+    "30_CM_DMSO_1": "DMSO",
+    "30_CM_DMSO_2": "DMSO",
+    "30_CM_DMSO_3": "DMSO",
+    "30_CM_DMSO_4": "DMSO",
+    "30_CM_FULV_1": "FULV",
+    "30_CM_FULV_2": "FULV",
+    "30_CM_FULV_3": "FULV",
+    "30_CM_FULV_4": "FULV",
+    "30_NC_DMSO_1": "DMSO",
+    "30_NC_DMSO_2": "DMSO",
+    "30_NC_DMSO_3": "DMSO",
+    "30_NC_DMSO_4": "DMSO",
+    "30_NC_FULV_1": "FULV",
+    "30_NC_FULV_2": "FULV",
+    "30_NC_FULV_3": "FULV",
+    "30_NC_FULV_4": "FULV",
+    "46_CM_DMSO_1": "DMSO",
+    "46_CM_DMSO_2": "DMSO",
+    "46_CM_FULV_1": "FULV",
+    "46_CM_FULV_2": "FULV",
+    "46_NC_DMSO_1": "DMSO",
+    "46_NC_DMSO_2": "DMSO",
+    "46_NC_FULV_1": "FULV",
+    "46_NC_FULV_2": "FULV"
+  },
+  "conditions": [
+    "DMSO",
+    "FULV"
+  ],
+  "default_contrast": {
+    "reference": "DMSO",
+    "alternate": "FULV"
+  },
+  "analysis_options": {
+    "min_total_count": 10,
+    "padj_alpha": 0.05,
+    "de_query_direction": "both"
+  },
+  "enrichr_libraries": [
+    "MSigDB_Hallmark_2020",
+    "KEGG_2021_Human",
+    "Reactome_2022"
+  ],
+  "gene_id_to_symbol_file": "geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_id_to_symbol.json",
+  "true_pathway": "Unknown (GEO benchmark)"
+}

envs/pathway_analysis_env/data/geo_eval/gse216540_tpm_pseudo_benchmark/gse216540_pseudo_counts.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf7f9c931c3787d73b91bde371963cb1c40c73d62acffd038c8324339bcfb0d4
+size 1485512

envs/pathway_analysis_env/docs/AGENT_EVAL.md

@@ -0,0 +1,100 @@
+# Agent evaluation guide — pathway_analysis_env
+
+This guide covers how to evaluate tool-calling LLM agents in `pathway_analysis_env`.
+
+## Eval defaults
+
+`reset()` enables `eval_mode=True` by default.
+
+In eval mode:
+
+- `true_pathway` is hidden from agent-visible state
+- `submit_answer` requires DE + ORA first
+- custom ORA `gene_list` injection is blocked
+- intermediate shaping rewards are flattened
+- step budget is enforced (`max_steps`, default 30)
+
+For local debugging only, set `eval_mode=False`.
+
+## Standard environment eval
+
+Run the manifest-driven harness:
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_agent_eval_suite.py
+```
+
+Default manifest: `envs/pathway_analysis_env/data/eval_manifest.json`.
+
+## LLM eval (tool-calling)
+
+Set one provider credential in env or `.env`:
+
+- `GROQ_API_KEY`
+- `OPENAI_API_KEY`
+- `OPENROUTER_API_KEY`
+
+Then run:
+
+```bash
+export MPLCONFIGDIR=/tmp/mpl
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py
+```
+
+Useful flags:
+
+```bash
+# Choose provider explicitly
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py --provider groq
+
+# Override models
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py --models gpt-5
+
+# Use custom manifest
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json
+```
+
+Reports are written to:
+
+- `envs/pathway_analysis_env/outputs/llm_eval/latest.json`
+- `envs/pathway_analysis_env/outputs/llm_eval/latest.md`
+
+## LLM judge eval (report quality)
+
+Run agent + judge against a single case:
+
+```bash
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_judge.py \
+  --case geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json \
+  --agent-model gpt-5 \
+  --judge-model gpt-5 \
+  --out-json envs/pathway_analysis_env/outputs/llm_eval/live_judge_gse128911_gpt5_gpt5.json
+```
+
+## Scoring access (orchestrator side)
+
+After submit:
+
+```python
+outcome = env.episode_outcome
+```
+
+With HTTP server:
+
+- `GET /orchestrator/episode_outcome`
+- `GET /orchestrator/eval_protocol`
+
+## Agent-safe case export
+
+Export sanitized cases for agent-facing deployments:
+
+```bash
+cd envs/pathway_analysis_env
+PYTHONPATH=../../src:.. uv run python scripts/export_agent_safe_cases.py
+```
+
+Output path: `data/agent_safe/`.
+
+## Failure codes
+
+Failure code definitions are in `docs/FAILURE_CODES.md`.

envs/pathway_analysis_env/docs/FAILURE_CODES.md

@@ -0,0 +1,63 @@
+# Pathway analysis env — failure codes (v1)
+
+Observations use **`metadata["failure_code"]`** for stable, machine-readable failure labels. Success steps may omit this field or set it to `null` in future versions.
+
+See `server/pathway_environment.py` for where each code is set.
+
+## v1 taxonomy
+
+| `failure_code` | When |
+|----------------|------|
+| `episode_already_done` | `step` after the episode ended (`submit` or strict failure). |
+| `unknown_action_type` | `action_type` is not a recognized pathway action. |
+| `design_partial_contrast` | `understand_experiment_design` with only one of reference/alternate. |
+| `design_invalid_contrast_names` | Proposed reference/alternate not in `conditions`, or ref equals alt. |
+| `design_insufficient_samples_per_arm` | Pipeline case: a contrast arm has no samples in `sample_metadata`. |
+| `de_missing_contrast` | Pipeline DE: no reference/alternate from action, validated design, or `default_contrast`. |
+| `de_pydeseq2_unavailable` | PyDESeq2 not installed (non-strict: recoverable; strict: episode ends). |
+| `de_deseq2_failed` | `run_deseq2_contrast` returned an error string. |
+| `de_invalid_counts_matrix` | `validate_counts_case` failed. |
+| `de_too_few_genes_after_filter` | Prefilter leaves too few genes for stable DESeq2. |
+| `case_sample_metadata_mismatch` | `build_sample_metadata` raised (e.g. sample id missing from metadata). |
+| `ora_de_prerequisite` | Pipeline ORA before DE has been run. |
+| `ora_no_pathway_definitions` | Case has no `pathway_genes` for ORA. |
+| `compare_missing_pathway_names` | `compare_pathways` without both `pathway_a` and `pathway_b`. |
+| `max_steps_exceeded` | Eval mode: step count exceeded case `max_steps`. |
+| `submit_prerequisite_de` | Eval mode: submit before differential expression. |
+| `submit_prerequisite_ora` | Eval mode: submit before pathway enrichment. |
+| `ora_gene_list_blocked` | Eval mode: custom `gene_list` on ORA (must use DE output). |
+| `compare_requires_ora` | Eval mode: compare before enrichment. |
+| `submit_empty_hypothesis` | Submit with empty `hypothesis`. |
+| `submit_incorrect_hypothesis` | `submit_answer` scored incorrect (orchestrator metadata when enabled). |
+| `strict_termination` | Strict mode ended the episode; prefer the specific code above when also set. |
+
+## Strict mode
+
+When **`strict_mode`** ends an episode, observations include **`metadata["strict_failure"]: true`** and a specific **`failure_code`** (e.g. `de_missing_contrast`) when applicable, or `strict_termination` as a fallback.
+
+## Implementation map (v1)
+
+| Code | Where set in `pathway_environment.py` |
+|------|----------------------------------------|
+| `episode_already_done` | `step` when `s.is_done` |
+| `unknown_action_type` | `step` fallback |
+| `design_partial_contrast` | `_step_understand_experiment_design` (partial contrast) |
+| `design_invalid_contrast_names` | `_validate_contrast_proposal` |
+| `design_insufficient_samples_per_arm` | `_validate_contrast_proposal` |
+| `de_missing_contrast` | `_step_de` (no ref/alt) |
+| `de_pydeseq2_unavailable` | `_step_de` |
+| `de_deseq2_failed` | `_step_de` after `run_deseq2_contrast` error |
+| `de_invalid_counts_matrix` | `_step_de` after `validate_counts_case` |
+| `de_too_few_genes_after_filter` | `_step_de` after prefilter |
+| `case_sample_metadata_mismatch` | `_step_de` `build_sample_metadata` `ValueError` |
+| `ora_de_prerequisite` | `_step_enrichment` (no DE rows, pipeline) |
+| `ora_no_pathway_definitions` | `_step_enrichment` |
+| `compare_missing_pathway_names` | `_step_compare` |
+| `expert_disabled` | `_step_expert` |
+| `expert_budget_exhausted` | `_step_expert` |
+| `submit_incorrect_hypothesis` | `_step_submit` when `correct` is false |
+| `strict_termination` | `_fail_strict` default only if no other code passed |
+
+## Constants
+
+Python constants live in **`server/failure_codes.py`** — import these instead of hard-coding strings in new code.

envs/pathway_analysis_env/docs/LLM_JUDGE_EVAL.md

@@ -0,0 +1,63 @@
+# LLM Judge Evaluation (Pure Report Comparison)
+
+This document describes the non-training evaluation workflow for comparing an
+agent's written analysis report against a reference report.
+
+## What This Is
+
+- **Purpose:** richer scientific assessment than keyword matching.
+- **Scope:** eval-only (offline analysis), not environment reward shaping.
+- **Judge input:** agent report + reference report.
+- **Judge output:** 0-1 scores for:
+  - primary_biology
+  - supporting_pathways
+  - evidence_grounding
+  - mechanism
+  - overall
+
+## Important Design Choice
+
+The reference report is generated from the **same live episode outputs** (DE and
+ORA) that the agent saw during that run. This avoids mismatches between:
+
+- stale precomputed `enrichment.json` artifacts, and
+- live Enrichr results at evaluation time.
+
+## Scripts
+
+- `scripts/run_llm_judge.py`
+  - Runs one case with a tool-calling agent model.
+  - Builds live reference from that same episode.
+  - Calls a judge model and writes JSON artifact.
+- `scripts/build_judge_pdf.py`
+  - Builds a visual PDF from a judge artifact JSON.
+
+## Example Commands
+
+Run a single case:
+
+```bash
+MPLCONFIGDIR=/tmp/mpl PYTHONPATH=src:envs uv run python \
+  envs/pathway_analysis_env/scripts/run_llm_judge.py \
+  --case geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json \
+  --agent-model gpt-5 \
+  --judge-model gpt-4o \
+  --out-json envs/pathway_analysis_env/outputs/llm_eval/live_judge_gse128911_gpt5.json
+```
+
+Build a PDF:
+
+```bash
+MPLCONFIGDIR=/tmp/mpl PYTHONPATH=src:envs uv run python \
+  envs/pathway_analysis_env/scripts/build_judge_pdf.py \
+  --artifact envs/pathway_analysis_env/outputs/llm_eval/live_judge_gse128911_gpt5.json \
+  --enrichment envs/pathway_analysis_env/data/geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/enrichment.json \
+  --out envs/pathway_analysis_env/outputs/llm_eval/live_judge_gse128911_gpt5.pdf
+```
+
+## Notes
+
+- LLM judging is **non-deterministic** and should not replace deterministic
+  environment rewards for RL training.
+- Keep judge model separate from agent model when possible (reduces self-bias).
+- Do not commit secrets; keep API keys in `.env` (gitignored).

envs/pathway_analysis_env/models.py

@@ -0,0 +1,80 @@
+# 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.
+
+"""
+Data models for Pathway Analysis Environment.
+
+Supports pipeline-style episodes (count matrix + sample metadata + gene sets)
+with PyDESeq2 differential expression, Fisher ORA, overlap-aware summaries,
+and HTML step traces.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from openenv.core.env_server import Action, Observation, State
+from pydantic import Field
+
+
+class PathwayAction(Action):
+    """
+    Action for the Pathway Analysis environment.
+
+    action_type:
+        - ``inspect_dataset``: describe available samples and conditions.
+        - ``understand_experiment_design``: **(1)** Summarize groups (conditions, sample counts);
+          optionally **(2)** validate ``condition_a``/``condition_b`` as reference/alternate for
+          DGE (does not run DESeq2). Valid pairs feed ``run_differential_expression`` when DE omits
+          conditions. **(3)** Pathway steps follow DE.
+        - ``run_differential_expression``: PyDESeq2 contrast (needs ``condition_a`` /
+          ``condition_b`` when using count-matrix cases).
+        - ``run_pathway_enrichment``: ORA on DE genes vs pathway gene sets.
+        - ``compare_pathways``: contrast exclusive vs shared DE support between two
+          pathways (``pathway_a``, ``pathway_b``).
+        - ``submit_answer``: submit ``hypothesis`` pathway name and end episode.
+    """
+
+    action_type: str
+    condition_a: Optional[str] = None
+    condition_b: Optional[str] = None
+    gene_list: Optional[List[str]] = None
+    hypothesis: Optional[str] = None
+    pathway_a: Optional[str] = None
+    pathway_b: Optional[str] = None
+
+
+class PathwayObservation(Observation):
+    """Observation with optional rich DE / ORA structures (JSON-serializable)."""
+
+    message: str = ""
+    available_conditions: List[str] = Field(default_factory=list)
+    top_genes: List[str] = Field(default_factory=list)
+    top_pathways: List[str] = Field(default_factory=list)
+    de_genes: List[Dict[str, Any]] = Field(default_factory=list)
+    pathway_enrichment: List[Dict[str, Any]] = Field(default_factory=list)
+    pathway_comparison: Optional[Dict[str, Any]] = None
+    overlap_summary: Optional[Dict[str, Any]] = None
+    statistical_ambiguity: Optional[Dict[str, Any]] = None
+    trace_path: Optional[str] = None
+    experiment_design: Optional[Dict[str, Any]] = None
+
+
+class PathwayState(State):
+    """Agent-visible episode state (ground truth is never included)."""
+
+    conditions: List[str] = Field(default_factory=list)
+    de_run: bool = False
+    enrichment_run: bool = False
+    is_done: bool = False
+    pipeline_mode: bool = False
+    strict_mode: bool = False
+    legacy_mode: bool = False
+    eval_mode: bool = True
+    max_steps: int = 30
+    design_understood: bool = False
+    validated_reference: Optional[str] = None
+    validated_alternate: Optional[str] = None

envs/pathway_analysis_env/openenv.yaml

@@ -0,0 +1,6 @@
+spec_version: 1
+name: pathway_analysis_env
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000

envs/pathway_analysis_env/pyproject.toml

@@ -0,0 +1,42 @@
+# 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-pathway-analysis-env"
+version = "0.1.0"
+description = "Toy pathway analysis environment for OpenEnv — identify activated signaling pathways from synthetic omics data"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]>=0.2.1",
+    "fastapi>=0.115.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.31.0",
+    "numpy>=1.24.0",
+    "pandas>=2.0.0",
+    "scipy>=1.10.0",
+    "pydeseq2>=0.4.0",
+    "anndata>=0.10.0",
+    "gseapy>=1.1.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+server = "pathway_analysis_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["pathway_analysis_env", "pathway_analysis_env.server"]
+package-dir = { "pathway_analysis_env" = ".", "pathway_analysis_env.server" = "server" }

envs/pathway_analysis_env/scripts/append_task_to_manifest.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Append or update one task episode in an eval manifest.
+
+Example:
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/append_task_to_manifest.py \
+  --manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json \
+  --episode-id geo_gseXXXX \
+  --case-file geo_eval/gseXXXX_example/gsexxxx_case.json \
+  --hypothesis "estrogen response"
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def _default_manifest() -> Dict[str, Any]:
+    return {
+        "description": "GEO evaluation tasks.",
+        "defaults": {
+            "eval_mode": True,
+            "max_steps": 30,
+            "orchestrator_mode": True,
+        },
+        "episodes": [],
+    }
+
+
+def _load_manifest(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        return _default_manifest()
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _upsert_episode(episodes: List[Dict[str, Any]], episode: Dict[str, Any]) -> str:
+    episode_id = episode["id"]
+    for i, existing in enumerate(episodes):
+        if existing.get("id") == episode_id:
+            episodes[i] = episode
+            return "updated"
+    episodes.append(episode)
+    return "added"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Append or update a single episode in a manifest."
+    )
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--episode-id", required=True)
+    parser.add_argument("--case-file", required=True, help="Path relative to data/ (e.g. geo_eval/.../case.json)")
+    parser.add_argument("--hypothesis", default="pathway hypothesis")
+    parser.add_argument(
+        "--requires-pydeseq2",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+    parser.add_argument(
+        "--requires-gseapy",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+    parser.add_argument("--score-mode", default="keywords")
+    args = parser.parse_args()
+
+    manifest = _load_manifest(args.manifest)
+    episodes = manifest.setdefault("episodes", [])
+
+    episode = {
+        "id": args.episode_id,
+        "case_file": args.case_file,
+        "hypothesis": args.hypothesis,
+        "requires_pydeseq2": bool(args.requires_pydeseq2),
+        "requires_gseapy": bool(args.requires_gseapy),
+        "score_mode": args.score_mode,
+    }
+    action = _upsert_episode(episodes, episode)
+    args.manifest.parent.mkdir(parents=True, exist_ok=True)
+    args.manifest.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+
+    print(f"[ok] {action} episode '{args.episode_id}' in {args.manifest}")
+    print(f"[ok] total episodes: {len(episodes)}")
+
+
+if __name__ == "__main__":
+    main()
+

envs/pathway_analysis_env/scripts/create_geo_task.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Create a GEO-style task case from counts + sample metadata.
+
+Example:
+PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/create_geo_task.py \
+  --task-id gseXXXX_example \
+  --accession GSEXXXX \
+  --summary "Short study summary" \
+  --counts-file /path/to/counts.csv.gz \
+  --metadata-csv /path/to/samples.csv \
+  --reference-condition control \
+  --alternate-condition treated
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import shutil
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+DEFAULT_LIBRARIES = ["MSigDB_Hallmark_2020", "KEGG_2021_Human", "Reactome_2022"]
+
+
+def _read_metadata_csv(path: Path) -> Tuple[List[str], Dict[str, str], List[str]]:
+    with path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        fields = set(reader.fieldnames or [])
+        required = {"sample_id", "condition"}
+        missing = required - fields
+        if missing:
+            raise ValueError(
+                f"{path} is missing required columns: {sorted(missing)} "
+                "(required: sample_id, condition)"
+            )
+
+        sample_ids: List[str] = []
+        sample_metadata: Dict[str, str] = {}
+        conditions: List[str] = []
+        seen_conditions = set()
+
+        for row in reader:
+            sample_id = (row.get("sample_id") or "").strip()
+            condition = (row.get("condition") or "").strip()
+            if not sample_id or not condition:
+                raise ValueError(
+                    f"{path} has empty sample_id/condition row: {row!r}"
+                )
+            sample_ids.append(sample_id)
+            sample_metadata[sample_id] = condition
+            if condition not in seen_conditions:
+                seen_conditions.add(condition)
+                conditions.append(condition)
+
+    if not sample_ids:
+        raise ValueError(f"{path} has no sample rows")
+    return sample_ids, sample_metadata, conditions
+
+
+def _counts_dest_name(src: Path) -> str:
+    name = src.name
+    if name.endswith(".csv") or name.endswith(".csv.gz"):
+        return name
+    return f"{src.stem}.csv.gz" if src.suffix == ".gz" else f"{src.name}.csv.gz"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Create a GEO task case JSON from counts + sample metadata."
+    )
+    parser.add_argument("--task-id", required=True, help="Folder id under data/geo_eval/")
+    parser.add_argument("--accession", required=True, help="Study accession (e.g. GSE216540)")
+    parser.add_argument("--summary", required=True, help="Short human-readable study summary")
+    parser.add_argument("--counts-file", type=Path, required=True, help="Path to counts .csv/.csv.gz")
+    parser.add_argument(
+        "--metadata-csv",
+        type=Path,
+        required=True,
+        help="CSV with columns: sample_id,condition",
+    )
+    parser.add_argument("--reference-condition", required=True, help="Reference group name")
+    parser.add_argument("--alternate-condition", required=True, help="Alternate group name")
+    parser.add_argument(
+        "--geo-ref-url",
+        default="",
+        help="Optional GEO URL; default is generated from accession",
+    )
+    parser.add_argument(
+        "--libraries",
+        default=",".join(DEFAULT_LIBRARIES),
+        help="Comma-separated Enrichr libraries",
+    )
+    parser.add_argument(
+        "--out-dir",
+        type=Path,
+        default=Path("envs/pathway_analysis_env/data/geo_eval"),
+        help="Directory that stores task folders",
+    )
+    parser.add_argument(
+        "--copy-counts",
+        action="store_true",
+        help="Copy counts file into task folder (default behavior)",
+    )
+    parser.add_argument(
+        "--no-copy-counts",
+        action="store_true",
+        help="Do not copy counts file (use existing file under task folder)",
+    )
+    args = parser.parse_args()
+
+    if args.reference_condition == args.alternate_condition:
+        raise ValueError("reference-condition and alternate-condition must be different")
+
+    sample_ids, sample_metadata, conditions = _read_metadata_csv(args.metadata_csv)
+    if args.reference_condition not in conditions:
+        raise ValueError(
+            f"reference-condition '{args.reference_condition}' not found in metadata conditions {conditions}"
+        )
+    if args.alternate_condition not in conditions:
+        raise ValueError(
+            f"alternate-condition '{args.alternate_condition}' not found in metadata conditions {conditions}"
+        )
+
+    task_dir = args.out_dir / args.task_id
+    task_dir.mkdir(parents=True, exist_ok=True)
+
+    counts_src = args.counts_file.resolve()
+    if not counts_src.exists():
+        raise FileNotFoundError(f"counts file not found: {counts_src}")
+
+    should_copy = not args.no_copy_counts
+    if args.copy_counts:
+        should_copy = True
+
+    if should_copy:
+        counts_name = _counts_dest_name(counts_src)
+        counts_dst = task_dir / counts_name
+        shutil.copy2(counts_src, counts_dst)
+    else:
+        counts_dst = counts_src
+        if task_dir not in counts_dst.parents:
+            raise ValueError(
+                "--no-copy-counts requires counts-file to already be inside task folder"
+            )
+
+    counts_rel = f"geo_eval/{args.task_id}/{counts_dst.name}"
+    case_name = f"{args.accession.lower()}_case.json"
+    case_path = task_dir / case_name
+
+    ref_url = args.geo_ref_url.strip() or f"https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc={args.accession}"
+    libraries = [s.strip() for s in args.libraries.split(",") if s.strip()]
+    if not libraries:
+        libraries = DEFAULT_LIBRARIES
+
+    case = {
+        "case_id": args.task_id,
+        "strict_mode": False,
+        "experiment_metadata": {
+            "accession": args.accession,
+            "reference": ref_url,
+            "summary": args.summary,
+        },
+        "counts_file": counts_rel,
+        "sample_ids": sample_ids,
+        "sample_metadata": sample_metadata,
+        "conditions": conditions,
+        "default_contrast": {
+            "reference": args.reference_condition,
+            "alternate": args.alternate_condition,
+        },
+        "analysis_options": {
+            "min_total_count": 10,
+            "padj_alpha": 0.05,
+            "de_query_direction": "both",
+        },
+        "enrichr_libraries": libraries,
+        "true_pathway": "Unknown (GEO benchmark)",
+    }
+    case_path.write_text(json.dumps(case, indent=2) + "\n", encoding="utf-8")
+
+    print(f"[ok] wrote case: {case_path}")
+    print(f"[ok] counts file: {counts_dst}")
+    print(
+        "[next] append to manifest:\n"
+        "  PYTHONPATH=src:envs uv run python "
+        "envs/pathway_analysis_env/scripts/append_task_to_manifest.py "
+        f"--manifest envs/pathway_analysis_env/data/eval_manifest_geo3.json "
+        f"--episode-id {args.task_id} --case-file {counts_rel.rsplit('/', 1)[0]}/{case_name} "
+        '--hypothesis "your expected theme"'
+    )
+
+
+if __name__ == "__main__":
+    main()
+

envs/pathway_analysis_env/scripts/export_agent_safe_cases.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""Export agent-safe case JSON files (no ground-truth fields) under data/agent_safe/."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from pathway_analysis_env.server.case_loader import export_agent_safe_case
+from pathway_analysis_env.server.pathway_environment import DATA_DIR
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--out-dir",
+        type=Path,
+        default=DATA_DIR / "agent_safe",
+        help="Output root (mirrors relative paths from data/).",
+    )
+    parser.add_argument(
+        "cases",
+        nargs="*",
+        default=[
+            "toy_case_001.json",
+            "toy_case_002.json",
+            "toy_case_legacy.json",
+            "toy_case_no_default.json",
+            "geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json",
+        ],
+    )
+    args = parser.parse_args()
+    out_root: Path = args.out_dir
+    for rel in args.cases:
+        src = DATA_DIR / rel
+        if not src.is_file():
+            print(f"skip missing {src}")
+            continue
+        dst = out_root / rel
+        export_agent_safe_case(src, dst)
+        print(f"wrote {dst}")
+
+
+if __name__ == "__main__":
+    main()

envs/pathway_analysis_env/scripts/run_agent_eval_suite.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Run the standard pathway agent eval manifest (fixed policy baseline).
+
+Scores via ``env.episode_outcome`` (orchestrator mode). Writes JSON summary.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+from pathway_analysis_env.models import PathwayAction
+from pathway_analysis_env.server.analysis import gseapy_available, pydeseq2_available
+from pathway_analysis_env.server.pathway_environment import (
+    DATA_DIR,
+    PathwayEnvironment,
+)
+
+
+def _run_episode(spec: Dict[str, Any], *, strict: bool) -> Dict[str, Any]:
+    case_file = spec["case_file"]
+    if spec.get("requires_pydeseq2") and not pydeseq2_available():
+        return {
+            "id": spec["id"],
+            "skipped": True,
+            "reason": "pydeseq2_unavailable",
+        }
+    if spec.get("requires_gseapy") and not gseapy_available():
+        return {
+            "id": spec["id"],
+            "skipped": True,
+            "reason": "gseapy_unavailable",
+        }
+
+    from pathway_analysis_env.server.pathway_environment import load_case
+
+    case = load_case(case_file)
+    ref = (case.get("default_contrast") or {}).get("reference")
+    alt = (case.get("default_contrast") or {}).get("alternate")
+
+    env = PathwayEnvironment(case_file=case_file)
+    env.reset(strict=strict, orchestrator_mode=True)
+
+    actions: List[str] = []
+
+    def go(kind: str, **kw: Any):
+        actions.append(kind)
+        return env.step(PathwayAction(action_type=kind, **kw))
+
+    go("understand_experiment_design")
+    go("inspect_dataset")
+    o_de = go(
+        "run_differential_expression",
+        condition_a=ref,
+        condition_b=alt,
+    )
+    if o_de.metadata and o_de.metadata.get("failure_code"):
+        return {
+            "id": spec["id"],
+            "case_file": case_file,
+            "passed": False,
+            "stage": "de",
+            "failure_code": o_de.metadata.get("failure_code"),
+            "actions": actions,
+        }
+    o_ora = go("run_pathway_enrichment")
+    if o_ora.metadata and o_ora.metadata.get("failure_code"):
+        return {
+            "id": spec["id"],
+            "case_file": case_file,
+            "passed": False,
+            "stage": "ora",
+            "failure_code": o_ora.metadata.get("failure_code"),
+            "actions": actions,
+        }
+    hyp = spec.get("hypothesis", "")
+    go("submit_answer", hypothesis=hyp)
+    outcome = env.episode_outcome or {}
+    return {
+        "id": spec["id"],
+        "case_file": case_file,
+        "passed": bool(outcome.get("correct")),
+        "episode_outcome": outcome,
+        "actions": actions,
+        "steps": env.state.step_count,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=DATA_DIR / "eval_manifest.json",
+    )
+    parser.add_argument("--strict", action="store_true")
+    parser.add_argument("--json-out", type=Path, default=None)
+    args = parser.parse_args()
+
+    manifest = json.loads(args.manifest.read_text(encoding="utf-8"))
+    results = [_run_episode(ep, strict=args.strict) for ep in manifest.get("episodes", [])]
+    n_pass = sum(1 for r in results if r.get("passed"))
+    n_run = sum(1 for r in results if not r.get("skipped"))
+    summary = {
+        "manifest": str(args.manifest),
+        "passed": n_pass,
+        "run": n_run,
+        "total": len(results),
+        "pass_rate": (n_pass / n_run) if n_run else 0.0,
+        "results": results,
+    }
+    text = json.dumps(summary, indent=2)
+    if args.json_out:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(text + "\n", encoding="utf-8")
+    print(text)
+
+
+if __name__ == "__main__":
+    main()

envs/pathway_analysis_env/scripts/run_llm_agent_eval.py

@@ -0,0 +1,614 @@
+#!/usr/bin/env python3
+"""
+Tool-calling LLM agent evaluation for pathway_analysis_env.
+
+Runs a tool-calling LLM agent over ``data/eval_manifest.json``. The agent is
+given the pathway tools and decides which to call and when to submit_answer.
+Writes JSON + Markdown reports.
+
+Free providers (no credit card):
+  Groq:       export GROQ_API_KEY=...  (https://console.groq.com)
+  OpenRouter: export OPENROUTER_API_KEY=...  (model openrouter/free)
+  Ollama:     ollama serve && ollama pull llama3.1:8b  (--provider ollama)
+
+Usage:
+  export GROQ_API_KEY=...
+  export MPLCONFIGDIR=/tmp/mpl
+  PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_agent_eval.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import time
+import traceback
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from pathway_analysis_env.agent_openai_tools import (
+    OPENAI_TOOLS,
+    observation_to_tool_result_content,
+    tool_call_to_pathway_action,
+)
+from pathway_analysis_env.server.analysis import gseapy_available, pydeseq2_available
+from pathway_analysis_env.server.pathway_environment import DATA_DIR, PathwayEnvironment
+
+DEFAULT_SYSTEM_PROMPT = """You are a computational biologist agent operating a pathway analysis environment.
+
+Required workflow (eval mode):
+1. understand_experiment_design and/or inspect_dataset — learn groups and sample layout.
+2. run_differential_expression — set reference (baseline) vs alternate (treatment) conditions.
+3. run_pathway_enrichment — ORA on DE genes (do not pass a custom gene_list).
+4. Optionally compare_pathways between two top pathway names.
+5. submit_answer — one pathway hypothesis string supported by ORA.
+
+Rules:
+- Never guess without running DE and ORA first.
+- Use condition names exactly as returned in available_conditions.
+- For submit_answer, name a specific pathway (e.g. from top_pathways), not a long essay.
+"""
+
+MINIMAL_SYSTEM_PROMPT = """Run pathway workflow: design/inspect → DE (reference vs alternate) → ORA → submit_answer with one pathway from ORA. Use exact condition names."""
+
+# OpenAI-compatible providers (Groq is free — no credit card).
+LLM_PROVIDERS: Dict[str, Dict[str, Any]] = {
+    "groq": {
+        "api_key_env": "GROQ_API_KEY",
+        "base_url": "https://api.groq.com/openai/v1",
+        "default_models": ["llama-3.3-70b-versatile"],
+    },
+    "openrouter": {
+        "api_key_env": "OPENROUTER_API_KEY",
+        "base_url": "https://openrouter.ai/api/v1",
+        "default_models": ["openrouter/free"],
+    },
+    "openai": {
+        "api_key_env": "OPENAI_API_KEY",
+        "base_url": None,
+        "default_models": ["gpt-4o-mini", "gpt-4o"],
+    },
+    "ollama": {
+        "api_key_env": None,
+        "base_url": "http://127.0.0.1:11434/v1",
+        "default_models": ["llama3.1:8b"],
+    },
+}
+
+
+@dataclass
+class LLMProvider:
+    name: str
+    api_key: str
+    base_url: Optional[str]
+    default_models: List[str]
+
+
+@dataclass
+class EpisodeResult:
+    agent_id: str
+    model: str
+    episode_id: str
+    case_file: str
+    passed: bool
+    score: float
+    steps: int
+    turns: int
+    wall_time_s: float
+    done: bool
+    hypothesis: Optional[str] = None
+    match_mode: Optional[str] = None
+    failure_code: Optional[str] = None
+    action_trace: List[str] = field(default_factory=list)
+    error: Optional[str] = None
+    skipped: bool = False
+    skip_reason: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "agent_id": self.agent_id,
+            "model": self.model,
+            "episode_id": self.episode_id,
+            "case_file": self.case_file,
+            "passed": self.passed,
+            "score": self.score,
+            "steps": self.steps,
+            "turns": self.turns,
+            "wall_time_s": round(self.wall_time_s, 2),
+            "done": self.done,
+            "hypothesis": self.hypothesis,
+            "match_mode": self.match_mode,
+            "failure_code": self.failure_code,
+            "action_trace": self.action_trace,
+            "error": self.error,
+            "skipped": self.skipped,
+            "skip_reason": self.skip_reason,
+        }
+
+
+def _load_dotenv() -> None:
+    root = Path(__file__).resolve().parents[3]
+    env_path = root / ".env"
+    if not env_path.is_file():
+        return
+    for line in env_path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key, val = key.strip(), val.strip().strip('"').strip("'")
+        if key and val and key not in os.environ:
+            os.environ[key] = val
+
+
+def _ollama_reachable() -> bool:
+    try:
+        import urllib.request
+
+        with urllib.request.urlopen(
+            "http://127.0.0.1:11434/api/tags", timeout=1.5
+        ) as resp:
+            return resp.status == 200
+    except Exception:
+        return False
+
+
+def resolve_llm_provider(explicit: str = "auto") -> Optional[LLMProvider]:
+    """Pick an LLM backend from env vars or an explicit --provider flag."""
+    order = ["groq", "openrouter", "openai", "ollama"]
+    names = [explicit] if explicit != "auto" else order
+
+    for name in names:
+        if name not in LLM_PROVIDERS:
+            raise SystemExit(
+                f"Unknown provider {name!r}. Choose: auto, {', '.join(order)}"
+            )
+        spec = LLM_PROVIDERS[name]
+        key_env = spec.get("api_key_env")
+        if key_env:
+            api_key = os.environ.get(key_env, "")
+            if not api_key:
+                continue
+        elif name == "ollama":
+            if not _ollama_reachable():
+                continue
+            api_key = "ollama"
+        else:
+            continue
+        return LLMProvider(
+            name=name,
+            api_key=api_key,
+            base_url=spec.get("base_url"),
+            default_models=list(spec["default_models"]),
+        )
+    return None
+
+
+def make_llm_client(provider: LLMProvider):
+    from openai import AsyncOpenAI
+
+    kwargs: Dict[str, Any] = {"api_key": provider.api_key}
+    if provider.base_url:
+        kwargs["base_url"] = provider.base_url
+    return AsyncOpenAI(**kwargs)
+
+
+def _episode_skipped(spec: Dict[str, Any]) -> Optional[str]:
+    if spec.get("requires_pydeseq2") and not pydeseq2_available():
+        return "pydeseq2_unavailable"
+    if spec.get("requires_gseapy") and not gseapy_available():
+        return "gseapy_unavailable"
+    return None
+
+
+def _skipped_result(
+    agent_id: str, model: str, spec: Dict[str, Any], reason: str
+) -> EpisodeResult:
+    return EpisodeResult(
+        agent_id=agent_id,
+        model=model,
+        episode_id=spec["id"],
+        case_file=spec["case_file"],
+        passed=False,
+        score=0.0,
+        steps=0,
+        turns=0,
+        wall_time_s=0.0,
+        done=False,
+        skipped=True,
+        skip_reason=reason,
+    )
+
+
+def _retry_after_seconds(exc: Exception) -> Optional[float]:
+    """Parse a provider 'try again in Xs' hint from a rate-limit error."""
+    import re
+
+    text = str(exc)
+    m = re.search(r"try again in\s*(?:(\d+)m)?\s*([\d.]+)s", text)
+    if not m:
+        return None
+    minutes = float(m.group(1)) if m.group(1) else 0.0
+    seconds = float(m.group(2)) if m.group(2) else 0.0
+    return minutes * 60.0 + seconds
+
+
+def _supports_temperature_override(model: str) -> bool:
+    """Some models (e.g. gpt-5) only support default temperature."""
+    return not model.startswith("gpt-5")
+
+
+async def _chat_with_retry(
+    client,
+    *,
+    model: str,
+    messages: List[Dict[str, Any]],
+    max_retries: int,
+):
+    """Call chat.completions with backoff on rate limits / transient errors.
+
+    Honors the provider's "try again in Xs" hint when present; otherwise uses
+    exponential backoff. Tool-use parser hiccups (Groq ``tool_use_failed``) are
+    also retried since they are non-deterministic.
+    """
+    attempt = 0
+    tool_hiccups = 0
+    while True:
+        # Base call is deterministic (T=0). On a provider tool-call parser
+        # failure, nudge temperature up so retries are not identical (and thus
+        # not guaranteed to fail the same way).
+        temperature = min(0.2 * tool_hiccups, 0.8)
+        try:
+            kwargs: Dict[str, Any] = {
+                "model": model,
+                "messages": messages,
+                "tools": OPENAI_TOOLS,
+                "tool_choice": "auto",
+            }
+            if _supports_temperature_override(model):
+                kwargs["temperature"] = temperature
+            return await client.chat.completions.create(**kwargs)
+        except Exception as exc:  # noqa: BLE001 - provider-agnostic retry
+            text = str(exc)
+            is_rate_limit = "429" in text or "rate_limit" in text.lower()
+            is_tool_hiccup = "tool_use_failed" in text
+            if attempt >= max_retries or not (is_rate_limit or is_tool_hiccup):
+                raise
+            if is_tool_hiccup:
+                tool_hiccups += 1
+            hinted = _retry_after_seconds(exc) if is_rate_limit else None
+            if hinted is not None:
+                delay = hinted + 1.0  # cushion past the rate-limit window
+            elif is_tool_hiccup:
+                delay = 1.0  # parser hiccup: retry quickly with new temperature
+            else:
+                delay = min(2.0 * (2**attempt), 60.0)
+            print(
+                f"    retry {attempt + 1}/{max_retries} after "
+                f"{'rate limit' if is_rate_limit else 'tool_use_failed'} "
+                f"(sleeping {delay:.1f}s, temp->{min(0.2 * tool_hiccups, 0.8):.1f})...",
+                flush=True,
+            )
+            await asyncio.sleep(delay)
+            attempt += 1
+
+
+async def run_llm_episode(
+    *,
+    agent_id: str,
+    model: str,
+    case_file: str,
+    episode_id: str,
+    system_prompt: str,
+    max_turns: int,
+    strict: bool,
+    provider: LLMProvider,
+    max_retries: int = 6,
+) -> EpisodeResult:
+    t0 = time.perf_counter()
+    action_trace: List[str] = []
+    client = make_llm_client(provider)
+    env = PathwayEnvironment(case_file=case_file)
+    try:
+        obs = env.reset(orchestrator_mode=True, strict=strict)
+        messages: List[Dict[str, Any]] = [
+            {"role": "system", "content": system_prompt},
+            {
+                "role": "user",
+                "content": (
+                    f"Episode {episode_id}. Case: {case_file}. "
+                    f"Conditions: {obs.available_conditions}. {obs.message}"
+                ),
+            },
+        ]
+        last_failure: Optional[str] = None
+        turn = 0
+        for turn in range(max_turns):
+            response = await _chat_with_retry(
+                client,
+                model=model,
+                messages=messages,
+                max_retries=max_retries,
+            )
+            msg = response.choices[0].message
+            if not msg.tool_calls:
+                messages.append({"role": "assistant", "content": msg.content or ""})
+                if env.state.is_done:
+                    break
+                continue
+            # Reconstruct a clean assistant message with only fields that
+            # OpenAI-compatible providers universally accept. The OpenAI SDK
+            # adds extra fields (e.g. ``annotations``) that strict providers
+            # such as Groq reject with a 400 error on the next request.
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in msg.tool_calls
+                    ],
+                }
+            )
+            for tc in msg.tool_calls:
+                action = tool_call_to_pathway_action(
+                    name=tc.function.name,
+                    arguments_json=tc.function.arguments,
+                )
+                action_trace.append(action.action_type)
+                step_obs = env.step(action)
+                meta = step_obs.metadata or {}
+                if meta.get("failure_code"):
+                    last_failure = str(meta["failure_code"])
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tc.id,
+                        "content": observation_to_tool_result_content(step_obs),
+                    }
+                )
+                if step_obs.done:
+                    break
+            if env.state.is_done:
+                break
+        outcome = env.episode_outcome or {}
+        return EpisodeResult(
+            agent_id=agent_id,
+            model=model,
+            episode_id=episode_id,
+            case_file=case_file,
+            passed=bool(outcome.get("correct")),
+            score=float(outcome.get("score") or 0.0),
+            steps=env.state.step_count,
+            turns=turn + 1,
+            wall_time_s=time.perf_counter() - t0,
+            done=env.state.is_done,
+            hypothesis=outcome.get("hypothesis"),
+            match_mode=outcome.get("match_mode"),
+            failure_code=last_failure if not outcome.get("correct") else None,
+            action_trace=action_trace,
+        )
+    except Exception as exc:
+        return EpisodeResult(
+            agent_id=agent_id,
+            model=model,
+            episode_id=episode_id,
+            case_file=case_file,
+            passed=False,
+            score=0.0,
+            steps=0,
+            turns=0,
+            wall_time_s=time.perf_counter() - t0,
+            done=False,
+            error=f"{type(exc).__name__}: {exc}",
+            action_trace=action_trace,
+        )
+
+
+def aggregate(results: List[EpisodeResult]) -> Dict[str, Any]:
+    by_agent: Dict[str, List[EpisodeResult]] = {}
+    for r in results:
+        by_agent.setdefault(r.agent_id, []).append(r)
+    agents_summary = []
+    for agent_id, rows in sorted(by_agent.items()):
+        run_rows = [x for x in rows if not x.skipped]
+        passed = sum(1 for x in run_rows if x.passed)
+        agents_summary.append(
+            {
+                "agent_id": agent_id,
+                "model": rows[0].model if rows else "",
+                "episodes_run": len(run_rows),
+                "episodes_passed": passed,
+                "pass_rate": passed / len(run_rows) if run_rows else 0.0,
+                "avg_score": (
+                    sum(x.score for x in run_rows) / len(run_rows) if run_rows else 0.0
+                ),
+                "avg_steps": (
+                    sum(x.steps for x in run_rows) / len(run_rows) if run_rows else 0.0
+                ),
+                "avg_wall_time_s": (
+                    sum(x.wall_time_s for x in run_rows) / len(run_rows)
+                    if run_rows
+                    else 0.0
+                ),
+            }
+        )
+    return {"agents": agents_summary}
+
+
+def write_markdown_report(summary: Dict[str, Any], path: Path) -> None:
+    lines = [
+        "# Pathway Agent Evaluation Report",
+        "",
+        f"Generated: {summary.get('generated_at', '')}",
+        "",
+        "## Eval plan",
+        "",
+        summary.get("eval_plan", ""),
+        "",
+        "## Leaderboard",
+        "",
+        "| Agent | Model | Pass rate | Avg score | Avg steps | Avg time (s) |",
+        "|-------|-------|-----------|-----------|-----------|--------------|",
+    ]
+    for a in summary.get("aggregate", {}).get("agents", []):
+        lines.append(
+            f"| {a['agent_id']} | {a['model']} | {a['pass_rate']:.0%} "
+            f"({a['episodes_passed']}/{a['episodes_run']}) | {a['avg_score']:.2f} | "
+            f"{a['avg_steps']:.1f} | {a['avg_wall_time_s']:.1f} |"
+        )
+    lines.extend(["", "## Per-episode results", ""])
+    for r in summary.get("results", []):
+        status = "SKIP" if r.get("skipped") else ("PASS" if r.get("passed") else "FAIL")
+        lines.append(
+            f"- **{status}** `{r.get('agent_id')}` / `{r.get('episode_id')}` "
+            f"— score={r.get('score')} steps={r.get('steps')} "
+            f"hypothesis={r.get('hypothesis')!r} "
+            f"failure={r.get('failure_code') or r.get('error') or '—'}"
+        )
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+async def main_async(
+    args: argparse.Namespace,
+) -> Tuple[Dict[str, Any], Optional[LLMProvider]]:
+    manifest = json.loads(args.manifest.read_text(encoding="utf-8"))
+    episodes = manifest.get("episodes", [])
+    provider = resolve_llm_provider(args.provider)
+    models = [m.strip() for m in args.models.split(",") if m.strip()]
+    if not models and provider:
+        models = list(provider.default_models)
+
+    eval_plan = (
+        "Tool-calling LLM agent at T=0 over the manifest episodes "
+        "(provider: Groq/OpenRouter/OpenAI/Ollama). The agent is given the "
+        "pathway tools and decides which to call and when to submit_answer. "
+        "Metrics: pass rate, avg score, steps, wall time, action trace, failure codes."
+    )
+
+    results: List[EpisodeResult] = []
+
+    if provider is None:
+        print(
+            "No LLM API key found — cannot run the agent.\n"
+            "  Free option: export GROQ_API_KEY=...  (sign up at https://console.groq.com)\n"
+            "  Or: ollama serve && --provider ollama\n"
+            "  Or add GROQ_API_KEY to repo-root .env",
+            flush=True,
+        )
+    else:
+        print(f"LLM provider: {provider.name}  models: {', '.join(models)}", flush=True)
+        prompt_variants = [("llm_default", DEFAULT_SYSTEM_PROMPT)]
+        if args.prompt_ablation:
+            prompt_variants.append(("llm_minimal", MINIMAL_SYSTEM_PROMPT))
+        for model in models:
+            for prompt_name, prompt_text in prompt_variants:
+                agent_id = f"{prompt_name}__{model.replace('/', '_').replace(':', '_')}"
+                for spec in episodes:
+                    skip = _episode_skipped(spec)
+                    if skip:
+                        results.append(_skipped_result(agent_id, model, spec, skip))
+                        continue
+                    print(f"Running {agent_id} on {spec['id']}...", flush=True)
+                    r = await run_llm_episode(
+                        agent_id=agent_id,
+                        model=model,
+                        case_file=spec["case_file"],
+                        episode_id=spec["id"],
+                        system_prompt=prompt_text,
+                        max_turns=args.max_turns,
+                        strict=args.strict,
+                        provider=provider,
+                        max_retries=args.max_retries,
+                    )
+                    results.append(r)
+                    print(
+                        f"  -> {'PASS' if r.passed else 'FAIL'} score={r.score} steps={r.steps}",
+                        flush=True,
+                    )
+
+    summary = {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "eval_plan": eval_plan,
+        "manifest": str(args.manifest),
+        "llm_provider": provider.name if provider else None,
+        "models": models if provider else [],
+        "aggregate": aggregate(results),
+        "results": [r.to_dict() for r in results],
+    }
+    return summary, provider
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Tool-calling LLM agent eval for pathway env"
+    )
+    parser.add_argument(
+        "--manifest", type=Path, default=DATA_DIR / "eval_manifest.json"
+    )
+    parser.add_argument(
+        "--provider",
+        default="auto",
+        choices=["auto", "groq", "openrouter", "openai", "ollama"],
+        help="LLM backend (auto tries Groq, OpenRouter, OpenAI, then Ollama)",
+    )
+    parser.add_argument(
+        "--models",
+        default="",
+        help="Comma-separated model IDs (defaults per provider if omitted)",
+    )
+    parser.add_argument("--max-turns", type=int, default=20)
+    parser.add_argument(
+        "--max-retries",
+        type=int,
+        default=6,
+        help="Retries per LLM call on rate-limit / transient tool errors",
+    )
+    parser.add_argument("--strict", action="store_true")
+    parser.add_argument("--prompt-ablation", action="store_true")
+    parser.add_argument(
+        "--json-out",
+        type=Path,
+        default=Path("envs/pathway_analysis_env/outputs/llm_eval/latest.json"),
+    )
+    parser.add_argument(
+        "--md-out",
+        type=Path,
+        default=Path("envs/pathway_analysis_env/outputs/llm_eval/latest.md"),
+    )
+    args = parser.parse_args()
+
+    _load_dotenv()
+
+    try:
+        summary, _provider = asyncio.run(main_async(args))
+    except Exception:
+        traceback.print_exc()
+        raise
+
+    args.json_out.parent.mkdir(parents=True, exist_ok=True)
+    args.json_out.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    write_markdown_report(summary, args.md_out)
+    print(f"\nWrote {args.json_out}")
+    print(f"Wrote {args.md_out}")
+    print("\nLeaderboard:")
+    for a in summary["aggregate"]["agents"]:
+        print(
+            f"  {a['agent_id']:40s} pass={a['pass_rate']:.0%} "
+            f"avg_score={a['avg_score']:.2f} avg_steps={a['avg_steps']:.1f}"
+        )
+
+
+if __name__ == "__main__":
+    main()

envs/pathway_analysis_env/scripts/run_llm_judge.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+LLM-judge evaluation for pathway_analysis_env (eval-only, non-deterministic).
+
+Runs a tool-calling agent on one GEO case, asks it to produce a findings
+report, builds a *reference* report from the same live episode outputs (DE/ORA)
+that the agent saw, then asks a judge model to rate the agent report.
+
+This is an EVALUATION aid only. It is deliberately NOT wired into the
+environment reward (which must stay deterministic for RL training).
+
+Usage:
+  export OPENAI_API_KEY=...
+  PYTHONPATH=src:envs uv run python envs/pathway_analysis_env/scripts/run_llm_judge.py \
+    --case geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso/gse128911_case.json \
+    --reference-dir envs/pathway_analysis_env/data/geo_eval/gse128911_mda_mb_134_vi_fulvestrant_vs_dmso \
+    --agent-model gpt-4o-mini --judge-model gpt-4o-mini
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+from openai import AsyncOpenAI
+
+from pathway_analysis_env.agent_openai_tools import (
+    OPENAI_TOOLS,
+    observation_to_tool_result_content,
+    tool_call_to_pathway_action,
+)
+from pathway_analysis_env.server.pathway_environment import DATA_DIR, PathwayEnvironment
+
+AGENT_SYSTEM_PROMPT = """You are a computational biologist agent operating a pathway analysis environment.
+
+Workflow: understand_experiment_design / inspect_dataset -> run_differential_expression
+(reference vs alternate) -> run_pathway_enrichment -> optionally compare_pathways ->
+submit_answer with the activated pathway. Never guess before running DE and ORA.
+After you submit, you will be asked to write a short findings report."""
+
+REPORT_REQUEST = """The episode is complete. Write a concise findings report (5-8 sentences)
+of what you discovered: the contrast you ran, the most significant differentially
+expressed genes/direction, the top enriched pathways, and your biological interpretation
+of what program is activated/repressed in this experiment."""
+
+
+def _chat_kwargs_for_model(model: str) -> Dict[str, Any]:
+    """
+    Some models (e.g. gpt-5) do not accept non-default temperature values.
+    Return a safe kwargs dict for chat.completions.create.
+    """
+    if model.startswith("gpt-5"):
+        return {}
+    return {"temperature": 0.0}
+
+
+def _load_dotenv() -> None:
+    root = Path(__file__).resolve().parents[3]
+    env_path = root / ".env"
+    if not env_path.is_file():
+        return
+    for line in env_path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key, val = key.strip(), val.strip().strip('"').strip("'")
+        if key and val and key not in os.environ:
+            os.environ[key] = val
+
+
+def build_reference_report_from_live(
+    case: Dict[str, Any],
+    *,
+    de_rows: List[Dict[str, Any]],
+    ora_rows: List[Dict[str, Any]],
+    contrast: str,
+) -> str:
+    """Build reference report from the same live outputs seen by the agent."""
+    top = []
+    for row in ora_rows[:10]:
+        name = row.get("pathway")
+        q = row.get("q_value")
+        q_txt = f"{q:.2e}" if isinstance(q, (int, float)) else str(q)
+        genes = ", ".join((row.get("overlap_genes") or [])[:8])
+        top.append(f"  - {name} (q={q_txt}); key genes: {genes}")
+    top_block = "\n".join(top) if top else "  - (none)"
+
+    sig_n = sum(1 for r in de_rows if bool(r.get("significant")))
+    meta = case.get("experiment_metadata", {})
+    return (
+        f"STUDY: {meta.get('accession')} - {meta.get('summary')}\n"
+        f"CONTRAST: {contrast}\n"
+        f"SIGNIFICANT GENES (padj<0.05): {sig_n}\n"
+        f"TOP ENRICHED PATHWAYS (ground-truth, from same live episode outputs):\n"
+        f"{top_block}\n"
+    )
+
+
+async def run_agent_report(
+    client: AsyncOpenAI, model: str, case_file: str
+) -> tuple[str, str]:
+    env = PathwayEnvironment(case_file=case_file)
+    obs = env.reset(orchestrator_mode=True)
+    messages: List[Dict[str, Any]] = [
+        {"role": "system", "content": AGENT_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"Case: {case_file}. Conditions: {obs.available_conditions}. {obs.message}",
+        },
+    ]
+    for _ in range(20):
+        resp = await client.chat.completions.create(
+            model=model,
+            messages=messages,
+            tools=OPENAI_TOOLS,
+            tool_choice="auto",
+            **_chat_kwargs_for_model(model),
+        )
+        msg = resp.choices[0].message
+        if not msg.tool_calls:
+            messages.append({"role": "assistant", "content": msg.content or ""})
+            if env.state.is_done:
+                break
+            continue
+        messages.append({
+            "role": "assistant", "content": msg.content or "",
+            "tool_calls": [
+                {"id": tc.id, "type": "function",
+                 "function": {"name": tc.function.name, "arguments": tc.function.arguments}}
+                for tc in msg.tool_calls
+            ],
+        })
+        for tc in msg.tool_calls:
+            action = tool_call_to_pathway_action(
+                name=tc.function.name, arguments_json=tc.function.arguments)
+            step_obs = env.step(action)
+            messages.append({
+                "role": "tool", "tool_call_id": tc.id,
+                "content": observation_to_tool_result_content(step_obs),
+            })
+        if env.state.is_done:
+            break
+
+    # Build reference from exactly the outputs this episode produced.
+    de_rows = list(getattr(env, "_de_rows", []) or [])
+    ora_rows = list(getattr(env, "_ora_rows", []) or [])
+    c_ref = getattr(env._state, "validated_reference", None) or (
+        (env._case.get("default_contrast") or {}).get("reference")
+    )
+    c_alt = getattr(env._state, "validated_alternate", None) or (
+        (env._case.get("default_contrast") or {}).get("alternate")
+    )
+    contrast = (
+        f"{c_alt} vs {c_ref} (reference={c_ref})" if c_ref and c_alt else "unknown"
+    )
+    reference = build_reference_report_from_live(
+        env._case, de_rows=de_rows, ora_rows=ora_rows, contrast=contrast
+    )
+
+    messages.append({"role": "user", "content": REPORT_REQUEST})
+    resp = await client.chat.completions.create(
+        model=model, messages=messages, **_chat_kwargs_for_model(model)
+    )
+    return resp.choices[0].message.content or "", reference
+
+
+JUDGE_SYSTEM = """You are a strict scientific reviewer. Compare an AGENT REPORT against a
+REFERENCE (ground-truth pathway-analysis result). Score how well the agent recovered the
+correct biology. Return STRICT JSON only."""
+
+JUDGE_RUBRIC = """Score 0.0-1.0 on each criterion, then an overall 0.0-1.0:
+- primary_biology: did the agent identify the correct dominant program?
+- supporting_pathways: did it mention the secondary/related pathways?
+- evidence_grounding: are claims tied to the actual DE/enrichment results (not generic priors)?
+- mechanism: correct biological interpretation of the experiment?
+Return JSON: {"primary_biology":x,"supporting_pathways":x,"evidence_grounding":x,
+"mechanism":x,"overall":x,"justification":"2-3 sentences"}"""
+
+
+async def judge(client: AsyncOpenAI, model: str, agent_report: str, reference: str) -> Dict[str, Any]:
+    resp = await client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": JUDGE_SYSTEM},
+            {
+                "role": "user",
+                "content": f"{JUDGE_RUBRIC}\n\n=== REFERENCE ===\n{reference}\n\n=== AGENT REPORT ===\n{agent_report}",
+            },
+        ],
+        response_format={"type": "json_object"},
+        **_chat_kwargs_for_model(model),
+    )
+    return json.loads(resp.choices[0].message.content or "{}")
+
+
+async def main_async(args: argparse.Namespace) -> None:
+    client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    case_path = DATA_DIR / args.case
+    case = json.loads(case_path.read_text())
+
+    print("Running agent and generating report...", flush=True)
+    agent_report, reference = await run_agent_report(client, args.agent_model, args.case)
+    print("Judging...", flush=True)
+    verdict = await judge(client, args.judge_model, agent_report, reference)
+
+    print("\n" + "=" * 70)
+    print("REFERENCE REPORT\n" + "-" * 70)
+    print(reference)
+    print("=" * 70)
+    print(f"AGENT REPORT ({args.agent_model})\n" + "-" * 70)
+    print(agent_report)
+    print("=" * 70)
+    print(f"JUDGE VERDICT ({args.judge_model})\n" + "-" * 70)
+    print(json.dumps(verdict, indent=2))
+
+    if args.out_json:
+        out = Path(args.out_json)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(
+            json.dumps(
+                {
+                    "case": args.case,
+                    "agent_model": args.agent_model,
+                    "judge_model": args.judge_model,
+                    "reference": reference,
+                    "agent_report": agent_report,
+                    "verdict": verdict,
+                    "experiment_metadata": case.get("experiment_metadata", {}),
+                },
+                indent=2,
+            ),
+            encoding="utf-8",
+        )
+        print(f"\nWrote {out}")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="LLM-judge eval for pathway env")
+    p.add_argument("--case", required=True, help="Case file path relative to data dir")
+    p.add_argument(
+        "--reference-dir",
+        required=False,
+        default=None,
+        help="Deprecated: reference is now built from live episode outputs",
+    )
+    p.add_argument("--agent-model", default="gpt-4o-mini")
+    p.add_argument("--judge-model", default="gpt-4o-mini")
+    p.add_argument("--out-json", default=None, help="Optional path to save artifacts")
+    args = p.parse_args()
+    _load_dotenv()
+    asyncio.run(main_async(args))
+
+
+if __name__ == "__main__":
+    main()

envs/pathway_analysis_env/server/Dockerfile

@@ -0,0 +1,55 @@
+# 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.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+ARG BUILD_MODE=in-repo
+
+COPY . /app/env
+
+WORKDIR /app/env
+
+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
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+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
+
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+COPY --from=builder /app/env/.venv /app/.venv
+COPY --from=builder /app/env /app/env
+
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

envs/pathway_analysis_env/server/__init__.py

@@ -0,0 +1,5 @@
+# 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.

envs/pathway_analysis_env/server/analysis.py

@@ -0,0 +1,624 @@
+# 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.
+
+"""
+Differential expression (PyDESeq2) and over-representation analysis (ORA).
+
+Counts matrices use **samples × genes** layout for PyDESeq2 ≥ 0.5.
+"""
+
+from __future__ import annotations
+
+import io
+import math
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple
+
+import numpy as np
+import pandas as pd
+from scipy.stats import false_discovery_control, fisher_exact
+
+try:
+    from pydeseq2.dds import DeseqDataSet
+    from pydeseq2.ds import DeseqStats
+
+    _PYDESQ2_AVAILABLE = True
+except ImportError:  # pragma: no cover - optional heavy dep
+    DeseqDataSet = None  # type: ignore[misc, assignment]
+    DeseqStats = None  # type: ignore[misc, assignment]
+    _PYDESQ2_AVAILABLE = False
+
+try:
+    import gseapy as gp
+
+    _GSEAPY_AVAILABLE = True
+except ImportError:  # pragma: no cover - optional extra dep
+    gp = None  # type: ignore[assignment]
+    _GSEAPY_AVAILABLE = False
+
+
+def pydeseq2_available() -> bool:
+    return _PYDESQ2_AVAILABLE
+
+
+def gseapy_available() -> bool:
+    return _GSEAPY_AVAILABLE
+
+
+def default_analysis_options() -> Dict[str, Any]:
+    """Defaults aligned with common RNA-seq practice (DESeq2 prefilter, directional ORA)."""
+    return {
+        "min_total_count": 10,
+        "padj_alpha": 0.05,
+        "ora_min_pathway_genes": 3,
+        # Use "up" for treated-vs-control activation screens; "both" is the safe default.
+        "de_query_direction": "both",
+        "min_abs_log2fc": 0.0,
+    }
+
+
+def merge_analysis_options(case: Dict[str, Any]) -> Dict[str, Any]:
+    out = default_analysis_options()
+    raw = case.get("analysis_options")
+    if not isinstance(raw, dict):
+        return out
+    for k, v in raw.items():
+        if k not in out or v is None:
+            continue
+        if k in ("min_total_count", "ora_min_pathway_genes"):
+            out[k] = int(v)
+        elif k in ("padj_alpha", "min_abs_log2fc"):
+            out[k] = float(v)
+        elif k == "de_query_direction":
+            out[k] = str(v).lower().strip()
+        else:
+            out[k] = v
+    return out
+
+
+def filter_counts_by_minimum_total(
+    counts_df: pd.DataFrame,
+    min_total: int,
+) -> Tuple[pd.DataFrame, int, int]:
+    """
+    Remove genes with summed counts below ``min_total`` (DESeq2-style prefilter).
+
+    Returns:
+        (filtered_df, n_before, n_after)
+    """
+    if min_total <= 0:
+        return counts_df, counts_df.shape[1], counts_df.shape[1]
+    totals = counts_df.sum(axis=0)
+    keep = totals >= min_total
+    n_before = int(counts_df.shape[1])
+    filtered = counts_df.loc[:, keep]
+    n_after = int(filtered.shape[1])
+    return filtered, n_before, n_after
+
+
+def normalize_gene_ids(raw: Sequence[str]) -> List[str]:
+    """
+    Normalize gene identifiers for downstream gene set matching.
+
+    GEO count tables often use a combined key like ``ENSG...__TP53``.
+    We keep the symbol suffix when present.
+    """
+
+    out: List[str] = []
+    for g in raw:
+        s = str(g)
+        if "__" in s:
+            s = s.split("__", 1)[1]
+        out.append(s)
+    return out
+
+
+def load_counts_csv_as_samples_by_genes(
+    path: str | Path,
+    *,
+    sample_ids: Optional[Sequence[str]] = None,
+) -> pd.DataFrame:
+    """
+    Load a counts table from CSV/CSV.GZ and return **samples × genes** DataFrame.
+
+    Expected file layout:
+      - rows: genes
+      - columns: sample IDs
+      - first column: gene identifier (may be unnamed)
+    """
+
+    p = Path(path)
+    df = pd.read_csv(p, index_col=0)
+    if df.empty:
+        raise ValueError(f"Counts file is empty: {p}")
+
+    df.index = normalize_gene_ids(df.index.tolist())
+    df = df.apply(pd.to_numeric, errors="coerce").fillna(0).astype(int)
+
+    # Aggregate duplicate symbols (common when collapsing Ensembl->symbol).
+    if df.index.has_duplicates:
+        df = df.groupby(df.index).sum()
+
+    # genes × samples -> samples × genes
+    counts_df = df.T
+
+    if sample_ids is not None:
+        missing = [s for s in sample_ids if s not in counts_df.index]
+        if missing:
+            raise ValueError(
+                f"Counts file missing sample columns/rows for: {missing[:10]}"
+                + (" ..." if len(missing) > 10 else "")
+            )
+        counts_df = counts_df.loc[list(sample_ids)]
+
+    return counts_df
+
+
+def counts_dict_to_samples_by_genes(
+    counts: Dict[str, Sequence[int]],
+    sample_ids: Sequence[str],
+) -> pd.DataFrame:
+    """Build a samples × genes count matrix from gene → per-sample counts."""
+    sid_to_i = {sid: i for i, sid in enumerate(sample_ids)}
+    rows = []
+    for sid in sample_ids:
+        j = sid_to_i[sid]
+        rows.append([int(counts[g][j]) for g in counts])
+    return pd.DataFrame(rows, index=list(sample_ids), columns=list(counts.keys()))
+
+
+def build_sample_metadata(
+    sample_ids: Sequence[str],
+    condition_by_sample: Dict[str, str],
+) -> pd.DataFrame:
+    missing = [s for s in sample_ids if s not in condition_by_sample]
+    if missing:
+        raise ValueError(
+            f"sample_metadata missing entries for sample_ids: {missing[:10]}"
+            + (" ..." if len(missing) > 10 else "")
+        )
+    conds = [condition_by_sample[s] for s in sample_ids]
+    return pd.DataFrame({"condition": conds}, index=list(sample_ids))
+
+
+def validate_counts_case(case: Dict[str, Any]) -> Optional[str]:
+    """Return an error message if pipeline case JSON is inconsistent, else None."""
+    counts = case.get("counts")
+    sample_ids = case.get("sample_ids")
+    if not isinstance(counts, dict) or not sample_ids:
+        return None
+    n = len(sample_ids)
+    for gene, vals in counts.items():
+        if len(vals) != n:
+            return (
+                f"Gene {gene!r} has {len(vals)} count values but "
+                f"sample_ids has length {n}."
+            )
+    return None
+
+
+def load_author_de_table_csv(
+    path: str | Path,
+    *,
+    gene_column: str | None = None,
+    log2fc_column: str = "log2FoldChange",
+    pvalue_column: str = "pvalue",
+    padj_column: str = "padj",
+) -> List[Dict[str, Any]]:
+    """
+    Load a precomputed differential expression (DE) table (author-provided).
+
+    Supports the common GEO supplement format used in GSE227102:
+      - semicolon-delimited
+      - decimal comma in numeric columns (e.g. ``0,12``) and scientific like ``1,47E-18``
+      - gene symbol in a column like ``Gene,name`` and/or an Ensembl ``ID``
+
+    Returns:
+        DE rows in the same schema as ``run_deseq2_contrast`` output, sorted by ascending padj.
+    """
+
+    p = Path(path)
+    if not p.is_file():
+        raise ValueError(f"DE table file not found: {p}")
+
+    df = pd.read_csv(p, sep=";")
+    if df.empty:
+        raise ValueError(f"DE table is empty: {p}")
+
+    # Pick gene column.
+    if gene_column is None:
+        for cand in ("Gene,name", "gene", "symbol", "Gene", "gene_name"):
+            if cand in df.columns:
+                gene_column = cand
+                break
+    if gene_column is None or gene_column not in df.columns:
+        raise ValueError(
+            "Could not infer gene column. Available columns: "
+            + ", ".join(map(str, df.columns.tolist()))
+        )
+
+    # Normalize numeric strings (decimal commas).
+    for c in (log2fc_column, pvalue_column, padj_column):
+        if c not in df.columns:
+            raise ValueError(f"Missing required column {c!r} in DE table: {p}")
+        df[c] = df[c].astype(str).str.replace(",", ".", regex=False)
+        df[c] = pd.to_numeric(df[c], errors="coerce")
+
+    df[gene_column] = df[gene_column].astype(str)
+
+    rows: List[Dict[str, Any]] = []
+    for _, r in df.iterrows():
+        gene = str(r.get(gene_column, "")).strip()
+        if not gene or gene.lower() in ("nan", "none"):
+            continue
+        padj = float(r.get(padj_column)) if pd.notna(r.get(padj_column)) else 1.0
+        rows.append(
+            {
+                "gene": gene,
+                "baseMean": float("nan"),  # unknown for author tables; kept for schema compat
+                "log2FoldChange": float(r.get(log2fc_column, 0.0))
+                if pd.notna(r.get(log2fc_column))
+                else 0.0,
+                "lfcSE": None,
+                "pvalue": float(r.get(pvalue_column, 1.0))
+                if pd.notna(r.get(pvalue_column))
+                else 1.0,
+                "padj": padj,
+                "significant": False,  # filled by caller using chosen alpha
+            }
+        )
+
+    rows.sort(
+        key=lambda x: (
+            _safe_padj_value(x.get("padj")),
+            -abs(float(x.get("log2FoldChange") or 0.0)),
+        )
+    )
+    return rows
+
+
+def run_deseq2_contrast(
+    counts_df: pd.DataFrame,
+    metadata_df: pd.DataFrame,
+    alt_level: str,
+    ref_level: str,
+    *,
+    padj_alpha: float = 0.05,
+    min_replicates: int = 2,
+) -> Tuple[List[Dict[str, Any]], Optional[str]]:
+    """
+    Run PyDESeq2 Wald test for ``alt_level`` vs ``ref_level`` on column ``condition``.
+
+    Returns:
+        (de_rows, error_message). ``de_rows`` are sorted by ascending adjusted p-value.
+    """
+    if not _PYDESQ2_AVAILABLE:
+        return [], "PyDESeq2 is not installed."
+
+    levels = set(metadata_df["condition"].tolist())
+    if ref_level not in levels or alt_level not in levels:
+        return [], (
+            f"Contrast invalid: need both reference {ref_level!r} and "
+            f"alternate {alt_level!r} in sample metadata; got {sorted(levels)}."
+        )
+
+    try:
+        dds = DeseqDataSet(
+            counts=counts_df,
+            metadata=metadata_df,
+            design="~condition",
+            refit_cooks=True,
+            min_replicates=min_replicates,
+            quiet=True,
+        )
+        buf_out, buf_err = io.StringIO(), io.StringIO()
+        with redirect_stdout(buf_out), redirect_stderr(buf_err):
+            dds.deseq2()
+            stat_res = DeseqStats(dds, contrast=["condition", alt_level, ref_level])
+            stat_res.summary()
+        res = stat_res.results_df
+    except Exception as exc:  # pragma: no cover - fitting failures
+        return [], f"DESeq2 failed: {exc}"
+
+    de_rows: List[Dict[str, Any]] = []
+    for gene, row in res.iterrows():
+        padj = float(row["padj"]) if pd.notna(row["padj"]) else 1.0
+        de_rows.append(
+            {
+                "gene": str(gene),
+                "baseMean": float(row.get("baseMean", 0.0)),
+                "log2FoldChange": float(row.get("log2FoldChange", 0.0)),
+                "lfcSE": float(row.get("lfcSE", 0.0))
+                if pd.notna(row.get("lfcSE"))
+                else None,
+                "pvalue": float(row.get("pvalue", 1.0))
+                if pd.notna(row.get("pvalue"))
+                else 1.0,
+                "padj": padj,
+                "significant": padj <= padj_alpha,
+            }
+        )
+    de_rows.sort(key=lambda r: (r["padj"], -abs(r["log2FoldChange"])))
+    return de_rows, None
+
+
+def benjamini_hochberg(p_values: Sequence[float]) -> List[float]:
+    """Benjamini–Hochberg FDR; returns q-values in original order (fallback)."""
+    m = len(p_values)
+    if m == 0:
+        return []
+    p_arr = np.nan_to_num(np.asarray(p_values, dtype=float), nan=1.0)
+    order = np.argsort(p_arr)
+    sorted_p = p_arr[order]
+    adj_sorted = np.empty(m)
+    running = 1.0
+    for i in range(m - 1, -1, -1):
+        running = min(sorted_p[i] * m / (i + 1), running)
+        adj_sorted[i] = running
+    out = np.empty(m)
+    out[order] = adj_sorted
+    return np.clip(out, 0.0, 1.0).tolist()
+
+
+def adjust_pvalues_bh(p_values: Sequence[float]) -> List[float]:
+    """Benjamini–Hochberg adjusted p-values using SciPy (preferred)."""
+    m = len(p_values)
+    if m == 0:
+        return []
+    p_arr = np.clip(
+        np.nan_to_num(np.asarray(p_values, dtype=float), nan=1.0), 1e-300, 1.0
+    )
+    try:
+        adj = false_discovery_control(p_arr, method="bh")
+        return np.clip(adj, 0.0, 1.0).tolist()
+    except Exception:
+        return benjamini_hochberg(p_values)
+
+
+def ora_fisher(
+    de_genes: Sequence[str],
+    pathway_genes: Dict[str, Sequence[str]],
+    universe_genes: Sequence[str],
+    *,
+    min_pathway_genes: int = 3,
+) -> List[Dict[str, Any]]:
+    """
+    Over-representation analysis (one-sided Fisher exact, greater overlap).
+
+    ``universe_genes`` should be the **same gene set** used for DESeq2 (prefiltered).
+
+    Pathways smaller than ``min_pathway_genes`` in the universe are skipped (reduces
+    noise from tiny sets).
+    """
+    u: Set[str] = set(universe_genes)
+    de: Set[str] = {g for g in de_genes if g in u}
+    results: List[Dict[str, Any]] = []
+    de_n = len(de)
+
+    for pname, pgenes in pathway_genes.items():
+        pset = {g for g in pgenes if g in u}
+        if len(pset) < min_pathway_genes:
+            continue
+        overlap = sorted(de & pset)
+        a = len(overlap)
+        b = len(de - pset)
+        c = len(pset - de)
+        d = len(u) - a - b - c
+        if d < 0:
+            d = 0
+        oddsr, p_raw = fisher_exact([[a, b], [c, d]], alternative="greater")
+        p_f = float(p_raw) if math.isfinite(float(p_raw)) else 1.0
+        results.append(
+            {
+                "pathway": pname,
+                "p_value": p_f,
+                "odds_ratio": float(oddsr) if np.isfinite(oddsr) else None,
+                "overlap_genes": overlap,
+                "overlap_count": a,
+                "pathway_size": len(pset),
+                "de_in_universe": de_n,
+                "gene_ratio": f"{a}/{len(pset)}",
+            }
+        )
+
+    qvals = adjust_pvalues_bh([r["p_value"] for r in results])
+    for r, q in zip(results, qvals):
+        r["q_value"] = q
+    results.sort(key=lambda x: (x["p_value"], -x["overlap_count"]))
+    return results
+
+
+def enrichr_ora(
+    query_genes: Sequence[str],
+    *,
+    libraries: Sequence[str],
+    background: Optional[Sequence[str]] = None,
+    top_k: int = 50,
+) -> tuple[List[Dict[str, Any]], Optional[str]]:
+    """
+    Enrichr-based ORA using gseapy (requires network for most libraries).
+
+    Returns:
+        (rows, error_message)
+    """
+
+    if not _GSEAPY_AVAILABLE:
+        return [], "gseapy is not installed."
+    q = [str(g) for g in query_genes if g]
+    if not q:
+        return [], "Empty query gene list."
+    libs = [str(x) for x in libraries if x]
+    if not libs:
+        return [], "No Enrichr libraries configured."
+
+    rows: List[Dict[str, Any]] = []
+    try:
+        for lib in libs:
+            enr = gp.enrichr(  # type: ignore[union-attr]
+                gene_list=q,
+                gene_sets=lib,
+                background=list(background) if background is not None else None,
+                outdir=None,
+                no_plot=True,
+            )
+            res = getattr(enr, "results", None)
+            if res is None or res.empty:
+                continue
+            for _, r in res.head(top_k).iterrows():
+                genes = []
+                raw = r.get("Genes")
+                if isinstance(raw, str):
+                    genes = [g.strip() for g in raw.replace(";", ",").split(",") if g.strip()]
+                rows.append(
+                    {
+                        "pathway": f"{lib}: {r.get('Term')}",
+                        "p_value": float(r.get("P-value", 1.0)),
+                        "q_value": float(r.get("Adjusted P-value", 1.0)),
+                        "odds_ratio": float(r.get("Odds Ratio"))
+                        if pd.notna(r.get("Odds Ratio"))
+                        else None,
+                        "overlap_genes": genes,
+                        "overlap_count": int(r.get("Overlap", "0/0").split("/")[0])
+                        if isinstance(r.get("Overlap"), str)
+                        else None,
+                        "pathway_size": int(r.get("Overlap", "0/0").split("/")[1])
+                        if isinstance(r.get("Overlap"), str)
+                        else None,
+                    }
+                )
+    except Exception as exc:  # pragma: no cover
+        return [], f"Enrichr failed: {exc}"
+
+    rows.sort(key=lambda x: (x.get("q_value", 1.0), x.get("p_value", 1.0)))
+    return rows, None
+
+
+def _safe_padj_value(v: Any) -> float:
+    try:
+        x = float(v)
+    except (TypeError, ValueError):
+        return 1.0
+    return 1.0 if math.isnan(x) else x
+
+
+def pick_de_query_genes(
+    de_rows: Sequence[Dict[str, Any]],
+    *,
+    padj_alpha: float = 0.05,
+    max_genes: int = 200,
+    direction: str = "both",
+    min_abs_log2fc: float = 0.0,
+) -> List[str]:
+    """
+    Genes for ORA query: significant by ``padj`` and optional **direction** (activation).
+
+    ``direction``: ``\"up\"`` (alt > ref), ``\"down\"`` (alt < ref), or ``\"both\"``.
+    """
+    dir_norm = direction.lower().strip()
+    if dir_norm not in ("up", "down", "both"):
+        dir_norm = "both"
+
+    def lfc_ok(r: Dict[str, Any]) -> bool:
+        try:
+            lfc = float(r.get("log2FoldChange", 0.0))
+        except (TypeError, ValueError):
+            return False
+        if math.isnan(lfc):
+            return False
+        if dir_norm == "both":
+            return abs(lfc) >= min_abs_log2fc
+        if dir_norm == "up":
+            return lfc >= min_abs_log2fc
+        return lfc <= -min_abs_log2fc
+
+    sig: List[str] = []
+    for r in de_rows:
+        if _safe_padj_value(r.get("padj", 1.0)) > padj_alpha:
+            continue
+        if not lfc_ok(r):
+            continue
+        sig.append(r["gene"])
+
+    if not sig:
+        for r in de_rows[:max_genes]:
+            if lfc_ok(r):
+                sig.append(r["gene"])
+    if not sig:
+        sig = [r["gene"] for r in de_rows[:max_genes]]
+    return sig[:max_genes]
+
+
+def compare_pathways_detail(
+    pathway_a: str,
+    pathway_b: str,
+    pathway_genes: Dict[str, Sequence[str]],
+    de_genes: Sequence[str],
+) -> Dict[str, Any]:
+    """Exclusive vs shared DE support between two pathways."""
+    pa = set(pathway_genes.get(pathway_a, []))
+    pb = set(pathway_genes.get(pathway_b, []))
+    de = set(de_genes)
+    only_a = sorted((pa - pb) & de)
+    only_b = sorted((pb - pa) & de)
+    shared = sorted((pa & pb) & de)
+    return {
+        "pathway_a": pathway_a,
+        "pathway_b": pathway_b,
+        "exclusive_to_a": only_a,
+        "exclusive_to_b": only_b,
+        "shared_de_support": shared,
+        "pathway_a_size": len(pa),
+        "pathway_b_size": len(pb),
+        "overlap_pathway_genes": sorted(pa & pb),
+    }
+
+
+def overlap_genes_across_top_pathways(
+    ora_rows: Sequence[Dict[str, Any]],
+    top_k: int = 5,
+) -> Dict[str, Any]:
+    """DE genes that appear in more than one of the top-k pathways by p-value."""
+    top = [r for r in ora_rows[:top_k] if r.get("overlap_genes")]
+    gene_to_paths: Dict[str, List[str]] = {}
+    for row in top:
+        p = row["pathway"]
+        for g in row.get("overlap_genes", []):
+            gene_to_paths.setdefault(g, []).append(p)
+    multi = {g: paths for g, paths in gene_to_paths.items() if len(paths) > 1}
+    return {
+        "genes_supporting_multiple_top_pathways": sorted(multi.keys()),
+        "gene_to_pathways": {g: multi[g] for g in sorted(multi)},
+    }
+
+
+def top_hits_statistically_close(
+    ora_rows: Sequence[Dict[str, Any]],
+    *,
+    ratio_threshold: float = 10.0,
+    top_k: int = 3,
+) -> Dict[str, Any]:
+    """Flag when the top two enriched pathways have similar p-values (ratio bound)."""
+    if len(ora_rows) < 2:
+        return {
+            "close_top_hits": False,
+            "p_ratio": None,
+            "note": "fewer than 2 pathways",
+        }
+    p1 = ora_rows[0]["p_value"]
+    p2 = ora_rows[1]["p_value"]
+    if p1 <= 0 or p2 <= 0:
+        ratio = None
+        close = False
+    else:
+        ratio = max(p1, p2) / min(p1, p2)
+        close = ratio <= ratio_threshold
+    return {
+        "close_top_hits": close,
+        "p_ratio": ratio,
+        "p_top1": p1,
+        "p_top2": p2,
+    }

envs/pathway_analysis_env/server/app.py

@@ -0,0 +1,128 @@
+# 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.
+
+"""FastAPI application for the Pathway Analysis Environment."""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# Pathway lab is meant to be used at /web; OpenEnv defaults web off unless set.
+if "ENABLE_WEB_INTERFACE" not in os.environ:
+    os.environ["ENABLE_WEB_INTERFACE"] = "true"
+
+# Some dependencies (e.g. gseapy) import matplotlib, which tries to write a font/cache
+# directory under the user's home. In sandboxed / CI contexts this can be unwritable.
+if "MPLCONFIGDIR" not in os.environ:
+    cache_dir = Path(__file__).resolve().parent.parent / "outputs" / ".mplcache"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    os.environ["MPLCONFIGDIR"] = str(cache_dir)
+
+from openenv.core.env_server.http_server import create_app
+
+from ..models import PathwayAction, PathwayObservation
+from .gradio_ui import build_pathway_gradio_app
+from .pathway_environment import PathwayEnvironment
+
+_logger = logging.getLogger(__name__)
+
+# Populated when the Gradio / web UI is built (single shared env instance).
+_WEB_MANAGER: Dict[str, Any] = {}
+
+
+def _pathway_env_factory() -> PathwayEnvironment:
+    return PathwayEnvironment()
+
+
+def _gradio_builder_with_manager(web_manager, *args, **kwargs):
+    _WEB_MANAGER["manager"] = web_manager
+    return build_pathway_gradio_app(web_manager, *args, **kwargs)
+
+
+_sig = inspect.signature(create_app)
+_kw: dict = {
+    "env": _pathway_env_factory,
+    "action_cls": PathwayAction,
+    "observation_cls": PathwayObservation,
+    "env_name": "pathway_analysis_env",
+}
+if "gradio_builder" in _sig.parameters:
+    _kw["gradio_builder"] = _gradio_builder_with_manager
+else:
+    _logger.warning(
+        "openenv-core does not support gradio_builder; Pathway lab tab will be unavailable."
+    )
+
+app = create_app(**_kw)
+
+
+def _active_pathway_env() -> Optional[PathwayEnvironment]:
+    mgr = _WEB_MANAGER.get("manager")
+    if mgr is None:
+        return None
+    env = getattr(mgr, "env", None)
+    return env if isinstance(env, PathwayEnvironment) else None
+
+
+@app.get(
+    "/orchestrator/episode_outcome",
+    tags=["Orchestrator"],
+    summary="Episode score (orchestrator only)",
+)
+async def orchestrator_episode_outcome() -> Dict[str, Any]:
+    """
+    Return ``episode_outcome`` for the active web-session environment.
+
+    Not for untrusted agents — use after ``submit_answer`` when running benchmarks
+    against the local server. Returns ``{}`` if no episode has been scored yet.
+    """
+    env = _active_pathway_env()
+    if env is None:
+        return {"error": "web_interface_not_initialized"}
+    return dict(env.episode_outcome or {})
+
+
+@app.get(
+    "/orchestrator/eval_protocol",
+    tags=["Orchestrator"],
+    summary="Eval protocol summary",
+)
+async def orchestrator_eval_protocol() -> Dict[str, Any]:
+    """Describe eval-mode guarantees for the active environment instance."""
+    env = _active_pathway_env()
+    if env is None:
+        return {"error": "web_interface_not_initialized"}
+    st = env.state
+    return {
+        "eval_mode": st.eval_mode,
+        "max_steps": st.max_steps,
+        "pipeline_mode": st.pipeline_mode,
+        "legacy_mode": st.legacy_mode,
+        "de_run": st.de_run,
+        "enrichment_run": st.enrichment_run,
+        "step_count": st.step_count,
+        "required_workflow": [
+            "understand_experiment_design or inspect_dataset",
+            "run_differential_expression",
+            "run_pathway_enrichment",
+            "submit_answer",
+        ],
+    }
+
+
+def main():
+    """Entry point for ``uv run --project . server``."""
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

envs/pathway_analysis_env/server/case_loader.py

@@ -0,0 +1,79 @@
+# 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.
+
+"""Load pathway cases with optional separation of agent-visible vs orchestrator secrets."""
+
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+# Keys that must not ship to untrusted agent runtimes (orchestrator keeps full case).
+CASE_SECRET_KEYS = frozenset(
+    {
+        "true_pathway",
+        "true_pathway_aliases",
+        "expected_keywords",
+        "expert_hint",
+        "expert_penalty",
+        "expert_budget",
+    }
+)
+
+
+def strip_case_secrets(case: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a copy of ``case`` without orchestrator-only fields."""
+    out = deepcopy(case)
+    for key in CASE_SECRET_KEYS:
+        out.pop(key, None)
+    return out
+
+
+def extract_case_secrets(case: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "true_pathway": str(case.get("true_pathway", "")),
+        "true_pathway_aliases": list(case.get("true_pathway_aliases") or []),
+        "expected_keywords": list(case.get("expected_keywords") or []),
+        "expert_hint": case.get("expert_hint"),
+        "expert_budget": case.get("expert_budget"),
+        "expert_penalty": case.get("expert_penalty"),
+    }
+
+
+def load_case_file(
+    data_dir: Path,
+    case_name: str,
+    *,
+    agent_safe: bool = False,
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    Load case JSON from ``data_dir``.
+
+    Returns ``(case_dict, secrets)``. When ``agent_safe`` is True, ``case_dict`` has
+    secret keys removed (for agent containers); secrets are still returned for the server.
+    """
+    path = data_dir / case_name
+    with open(path, "r", encoding="utf-8") as f:
+        raw: Dict[str, Any] = json.load(f)
+    secrets = extract_case_secrets(raw)
+    if agent_safe:
+        return strip_case_secrets(raw), secrets
+    return raw, secrets
+
+
+def export_agent_safe_case(
+    source: Path,
+    destination: Path,
+) -> None:
+    """Write an agent-safe case JSON (no ground-truth fields)."""
+    with open(source, "r", encoding="utf-8") as f:
+        raw = json.load(f)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with open(destination, "w", encoding="utf-8") as f:
+        json.dump(strip_case_secrets(raw), f, indent=2)
+        f.write("\n")

envs/pathway_analysis_env/server/eval_protocol.py

@@ -0,0 +1,102 @@
+# 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.
+
+"""Agent-safe evaluation protocol helpers for pathway_analysis_env."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+from ..models import PathwayObservation
+
+# Keys never sent to agents when eval_mode is on.
+_AGENT_METADATA_BLOCKLIST = frozenset(
+    {
+        "correct",
+        "static_top_genes",
+        "static_top_pathways",
+        "true_pathway",
+        "ground_truth",
+        "episode_score",
+    }
+)
+
+
+def default_max_steps(case: Dict[str, Any]) -> int:
+    return max(5, int(case.get("max_steps", 30)))
+
+
+def resolve_eval_mode(case: Dict[str, Any], reset_kwargs: Dict[str, Any]) -> bool:
+    """Eval mode is on unless reset(eval_mode=False) or case sets eval_mode: false."""
+    if "eval_mode" in reset_kwargs:
+        return bool(reset_kwargs["eval_mode"])
+    return bool(case.get("eval_mode", True))
+
+
+def resolve_orchestrator_mode(case: Dict[str, Any], reset_kwargs: Dict[str, Any]) -> bool:
+    """Expose scoring details in metadata (for in-repo harnesses only)."""
+    if "orchestrator_mode" in reset_kwargs:
+        return bool(reset_kwargs["orchestrator_mode"])
+    return bool(case.get("orchestrator_mode", False))
+
+
+def shaping_reward(eval_mode: bool, nominal: float) -> float:
+    """Zero intermediate shaping in eval mode; terminal scoring is separate."""
+    if eval_mode:
+        return 0.0
+    return nominal
+
+
+def sanitize_metadata_for_agent(
+    metadata: Optional[Dict[str, Any]], *, eval_mode: bool
+) -> Dict[str, Any]:
+    if not metadata:
+        return {}
+    if not eval_mode:
+        return dict(metadata)
+    out = {k: v for k, v in metadata.items() if k not in _AGENT_METADATA_BLOCKLIST}
+    return out
+
+
+def sanitize_observation_for_agent(
+    obs: PathwayObservation,
+    *,
+    eval_mode: bool,
+    orchestrator_mode: bool,
+    reward_override: Optional[float] = None,
+) -> PathwayObservation:
+    if not eval_mode:
+        return obs
+    meta = sanitize_metadata_for_agent(obs.metadata, eval_mode=True)
+    if orchestrator_mode and obs.metadata and "correct" in obs.metadata:
+        meta["correct"] = obs.metadata["correct"]
+    if orchestrator_mode and obs.metadata and "episode_score" in obs.metadata:
+        meta["episode_score"] = obs.metadata["episode_score"]
+    reward = obs.reward if reward_override is None else reward_override
+    if eval_mode and not orchestrator_mode:
+        # Hide reward signal except strict terminal failures (negative).
+        if obs.done and reward and reward > 0:
+            reward = 0.0
+        elif not obs.done:
+            reward = 0.0
+    return obs.model_copy(
+        update={
+            "metadata": meta,
+            "reward": reward,
+        }
+    )
+
+
+def strip_legacy_answer_leaks(
+    inspect_meta: Dict[str, Any], *, eval_mode: bool
+) -> Dict[str, Any]:
+    if not eval_mode:
+        return inspect_meta
+    out = dict(inspect_meta)
+    out.pop("static_top_genes", None)
+    out.pop("static_top_pathways", None)
+    return out

envs/pathway_analysis_env/server/failure_codes.py

@@ -0,0 +1,49 @@
+# 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.
+
+"""Stable ``failure_code`` strings for observation metadata (pathway_analysis_env v1)."""
+
+# Session / episode
+EPISODE_ALREADY_DONE = "episode_already_done"
+UNKNOWN_ACTION_TYPE = "unknown_action_type"
+MAX_STEPS_EXCEEDED = "max_steps_exceeded"
+
+# eval protocol
+SUBMIT_PREREQUISITE_DE = "submit_prerequisite_de"
+SUBMIT_PREREQUISITE_ORA = "submit_prerequisite_ora"
+ORA_GENE_LIST_BLOCKED = "ora_gene_list_blocked"
+COMPARE_REQUIRES_ORA = "compare_requires_ora"
+SUBMIT_EMPTY_HYPOTHESIS = "submit_empty_hypothesis"
+
+# understand_experiment_design
+DESIGN_PARTIAL_CONTRAST = "design_partial_contrast"
+DESIGN_INVALID_CONTRAST_NAMES = "design_invalid_contrast_names"
+DESIGN_INSUFFICIENT_SAMPLES_PER_ARM = "design_insufficient_samples_per_arm"
+
+# run_differential_expression
+DE_MISSING_CONTRAST = "de_missing_contrast"
+DE_PYDESeq2_UNAVAILABLE = "de_pydeseq2_unavailable"
+DE_DESEQ2_FAILED = "de_deseq2_failed"
+DE_INVALID_COUNTS_MATRIX = "de_invalid_counts_matrix"
+DE_TOO_FEW_GENES_AFTER_FILTER = "de_too_few_genes_after_filter"
+CASE_SAMPLE_METADATA_MISMATCH = "case_sample_metadata_mismatch"
+
+# run_pathway_enrichment
+ORA_DE_PREREQUISITE = "ora_de_prerequisite"
+ORA_NO_PATHWAY_DEFINITIONS = "ora_no_pathway_definitions"
+
+# compare_pathways
+COMPARE_MISSING_PATHWAY_NAMES = "compare_missing_pathway_names"
+
+# ask_expert
+EXPERT_DISABLED = "expert_disabled"
+EXPERT_BUDGET_EXHAUSTED = "expert_budget_exhausted"
+
+# submit (analytics)
+SUBMIT_INCORRECT_HYPOTHESIS = "submit_incorrect_hypothesis"
+
+# strict mode umbrella (specific code still preferred when set)
+STRICT_TERMINATION = "strict_termination"

envs/pathway_analysis_env/server/gradio_ui.py

@@ -0,0 +1,573 @@
+# 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.
+
+"""
+Gradio **Pathway lab** tab: case selection, guided RNA-seq / ORA workflow, tables.
+
+Mount when ``ENABLE_WEB_INTERFACE=true`` and ``create_app(..., gradio_builder=...)``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+import pandas as pd
+from openenv.core.env_server.types import EnvironmentMetadata
+
+_DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+_OUTPUTS_DIR = Path(__file__).resolve().parent.parent / "outputs"
+
+
+def _list_case_files() -> List[str]:
+    if not _DATA_DIR.is_dir():
+        return ["toy_case_001.json"]
+    names = sorted(p.name for p in _DATA_DIR.glob("*.json"))
+    return names if names else ["toy_case_001.json"]
+
+
+def _list_saved_runs() -> List[str]:
+    """Folders under outputs/ that contain summary.json."""
+    if not _OUTPUTS_DIR.is_dir():
+        return []
+    runs = []
+    for p in sorted(_OUTPUTS_DIR.iterdir()):
+        if not p.is_dir():
+            continue
+        if (p / "summary.json").is_file():
+            runs.append(p.name)
+    return runs
+
+
+def _load_saved_run(run_name: str) -> Dict[str, Any]:
+    base = _OUTPUTS_DIR / run_name
+    out: Dict[str, Any] = {"run": run_name}
+    try:
+        out["summary"] = json.loads((base / "summary.json").read_text(encoding="utf-8"))
+    except Exception as e:
+        out["summary_error"] = str(e)
+        out["summary"] = {}
+    try:
+        out["de"] = json.loads((base / "de_top200.json").read_text(encoding="utf-8"))
+    except Exception as e:
+        out["de_error"] = str(e)
+        out["de"] = []
+    try:
+        out["enrichment"] = json.loads(
+            (base / "enrichment_top50.json").read_text(encoding="utf-8")
+        )
+    except Exception as e:
+        out["enrichment_error"] = str(e)
+        out["enrichment"] = []
+    return out
+
+
+def _saved_run_to_tables(run: Dict[str, Any]) -> Tuple[str, pd.DataFrame, pd.DataFrame]:
+    s = run.get("summary") or {}
+    md_lines = [
+        f"**Run:** `{run.get('run','')}`",
+        f"**Case:** `{s.get('case_id','')}`",
+        f"**Contrast:** `{s.get('contrast')}`",
+        f"**Genes:** in matrix `{s.get('genes_in_matrix')}` → after prefilter `{s.get('genes_after_prefilter')}`",
+        f"**Trace:** `{s.get('trace_path','')}`",
+    ]
+    md = "\n\n".join(md_lines)
+
+    de = run.get("de") or []
+    df_de = pd.DataFrame(de) if isinstance(de, list) and de else pd.DataFrame({"info": ["No DE export found."]})
+
+    enr = run.get("enrichment") or []
+    if isinstance(enr, list) and enr:
+        df_enr = pd.DataFrame(
+            [
+                {
+                    "pathway": r.get("pathway"),
+                    "p_value": r.get("p_value"),
+                    "q_value": r.get("q_value"),
+                    "odds_ratio": r.get("odds_ratio"),
+                    "overlap_genes": ", ".join((r.get("overlap_genes") or [])[:40]),
+                }
+                for r in enr
+                if isinstance(r, dict)
+            ]
+        )
+    else:
+        df_enr = pd.DataFrame({"info": ["No enrichment export found."]})
+
+    return md, df_de, df_enr
+
+
+def _pathway_comparison_df(obs: Dict[str, Any]) -> pd.DataFrame:
+    pc = obs.get("pathway_comparison")
+    if not isinstance(pc, dict) or not pc:
+        return pd.DataFrame(
+            {
+                "": [
+                    "Run **Compare pathways** with two pathway names to see exclusive vs shared DE support."
+                ]
+            }
+        )
+    a = pc.get("pathway_a", "")
+    b = pc.get("pathway_b", "")
+    rows = [
+        {
+            "pathway": f"A only ({a})",
+            "count": len(pc.get("exclusive_to_a") or []),
+            "genes (preview)": ", ".join((pc.get("exclusive_to_a") or [])[:40]),
+        },
+        {
+            "pathway": f"B only ({b})",
+            "count": len(pc.get("exclusive_to_b") or []),
+            "genes (preview)": ", ".join((pc.get("exclusive_to_b") or [])[:40]),
+        },
+        {
+            "pathway": "Shared DE support",
+            "count": len(pc.get("shared_de_support") or []),
+            "genes (preview)": ", ".join((pc.get("shared_de_support") or [])[:40]),
+        },
+        {
+            "pathway": "Pathway gene-set sizes",
+            "count": pc.get("pathway_a_size", 0) + pc.get("pathway_b_size", 0),
+            "genes (preview)": f"A size={pc.get('pathway_a_size')} · B size={pc.get('pathway_b_size')}",
+        },
+    ]
+    return pd.DataFrame(rows)
+
+
+def _state_markdown(
+    st: Dict[str, Any], episode_outcome: Optional[Dict[str, Any]] = None
+) -> str:
+    """Episode banner from ``WebInterfaceManager.get_state()`` (PathwayState fields)."""
+    if not st:
+        return "*No state yet — reset an episode.*"
+    eid = str(st.get("episode_id") or "")
+    eid_short = f"`{eid[:10]}…`" if len(eid) > 10 else f"`{eid}`"
+    pipe = "counts + PyDESeq2" if st.get("pipeline_mode") else "legacy lists"
+    strict = "strict" if st.get("strict_mode") else "lenient"
+    de_ok = "✓" if st.get("de_run") else "○"
+    ora_ok = "✓" if st.get("enrichment_run") else "○"
+    done = "**Episode ended.** Reset to start over." if st.get("is_done") else ""
+    score_line = ""
+    if st.get("is_done") and episode_outcome:
+        score_line = (
+            f"\n\n**Episode score:** correct={episode_outcome.get('correct')} "
+            f"· mode={episode_outcome.get('match_mode')} "
+            f"· score={episode_outcome.get('score')}"
+        )
+    conds = st.get("conditions") or []
+    cond_line = ", ".join(f"`{c}`" for c in conds[:12]) if conds else "—"
+    vref = st.get("validated_reference")
+    valt = st.get("validated_alternate")
+    val_line = ""
+    if vref and valt:
+        val_line = f"\n\n**Validated contrast (for DE if fields empty):** `{vref}` → `{valt}`"
+    des = "✓" if st.get("design_understood") else "○"
+    eval_on = st.get("eval_mode", True)
+    max_s = st.get("max_steps", 30)
+    return (
+        f"**Episode** {eid_short} · step **{st.get('step_count', 0)}** / {max_s} · {pipe} · {strict}"
+        f" · eval **{'on' if eval_on else 'off'}**\n\n"
+        f"**Conditions in case:** {cond_line}\n\n"
+        f"**Pipeline:** Design {des} · DE {de_ok} · ORA {ora_ok}"
+        f"{val_line}\n\n"
+        f"{done}{score_line}"
+    ).strip()
+
+
+def _observation_to_tables(
+    data: Dict[str, Any],
+) -> Tuple[str, pd.DataFrame, pd.DataFrame, pd.DataFrame, str, str, str]:
+    """Markdown summary, DE df, ORA df, compare df, overlap/ambiguity, trace, raw JSON."""
+    obs = data.get("observation") or {}
+    if not isinstance(obs, dict):
+        obs = {}
+
+    msg = obs.get("message", "") or ""
+    reward = obs.get("reward")
+    done = obs.get("done")
+    lines = [
+        f"**Message:** {msg}",
+        f"**Reward:** `{reward}`  ·  **Done:** `{done}`",
+    ]
+    ac = obs.get("available_conditions") or []
+    if ac:
+        lines.append("**Conditions (from last step):** " + ", ".join(f"`{c}`" for c in ac[:20]))
+
+    ed = obs.get("experiment_design")
+    if isinstance(ed, dict) and ed:
+        lines.append(
+            "**Experiment design (structured):**\n```json\n"
+            + json.dumps(ed, indent=2, default=str)[:8000]
+            + "\n```"
+        )
+
+    md = "\n\n".join(lines)
+
+    de_rows = obs.get("de_genes") or []
+    if de_rows and isinstance(de_rows, list):
+        df_de = pd.DataFrame(de_rows[:200])
+    else:
+        top = obs.get("top_genes") or []
+        if top:
+            df_de = pd.DataFrame({"gene": top})
+        else:
+            df_de = pd.DataFrame(
+                {"info": ["No DE table yet — run differential expression."]}
+            )
+
+    pe = obs.get("pathway_enrichment") or []
+    if pe and isinstance(pe, list):
+        rows_flat = []
+        for r in pe[:80]:
+            if not isinstance(r, dict):
+                continue
+            rows_flat.append(
+                {
+                    "pathway": r.get("pathway", ""),
+                    "p_value": r.get("p_value"),
+                    "q_value": r.get("q_value"),
+                    "overlap_count": r.get("overlap_count"),
+                    "pathway_size": r.get("pathway_size"),
+                    "gene_ratio": r.get("gene_ratio", ""),
+                }
+            )
+        df_pe = (
+            pd.DataFrame(rows_flat)
+            if rows_flat
+            else pd.DataFrame({"info": ["No ORA results — run pathway enrichment."]})
+        )
+    else:
+        tp = obs.get("top_pathways") or []
+        if tp:
+            df_pe = pd.DataFrame({"pathway": tp})
+        else:
+            df_pe = pd.DataFrame(
+                {"info": ["No ORA table yet — run pathway enrichment."]}
+            )
+
+    df_cmp = _pathway_comparison_df(obs)
+
+    ov = obs.get("overlap_summary") or {}
+    amb = obs.get("statistical_ambiguity") or {}
+    extra = []
+    if ov:
+        extra.append(
+            "**Overlap across top pathways:**\n```json\n"
+            + json.dumps(ov, indent=2)[:4000]
+            + "\n```"
+        )
+    if amb:
+        extra.append(
+            "**Statistical ambiguity:**\n```json\n"
+            + json.dumps(amb, indent=2)[:2000]
+            + "\n```"
+        )
+    extra_txt = "\n\n".join(extra) if extra else "*No overlap / ambiguity data yet.*"
+
+    trace = obs.get("trace_path") or ""
+    trace_md = (
+        f"**HTML episode trace:** `{trace}`\n\n"
+        f"Open the file locally to audit each step in a browser."
+        if trace
+        else "*Trace file path appears after environment steps.*"
+    )
+
+    raw = json.dumps(data, indent=2, default=str)
+    return md, df_de, df_pe, df_cmp, extra_txt, trace_md, raw
+
+
+def _response(
+    data: Dict[str, Any],
+    web_manager: Any,
+    status: str,
+    update_contrast: bool,
+) -> Tuple[Any, ...]:
+    """Shared outputs for all steps; optionally refresh contrast textboxes from state."""
+    md, df_de, df_pe, df_cmp, extra, trace_md, raw = _observation_to_tables(data)
+    st = web_manager.get_state()
+    env = getattr(web_manager, "env", None)
+    outcome = getattr(env, "episode_outcome", None) if env is not None else None
+    state_md = _state_markdown(
+        st if isinstance(st, dict) else {},
+        outcome if isinstance(outcome, dict) else None,
+    )
+    conds = (st or {}).get("conditions") or []
+    if update_contrast and conds:
+        ref_v = str(conds[0])
+        alt_v = str(conds[1]) if len(conds) > 1 else ref_v
+        cref, calt = gr.update(value=ref_v), gr.update(value=alt_v)
+    else:
+        cref, calt = gr.update(), gr.update()
+    return (
+        md,
+        df_de,
+        df_pe,
+        df_cmp,
+        extra,
+        trace_md,
+        raw,
+        state_md,
+        status,
+        cref,
+        calt,
+    )
+
+
+def build_pathway_gradio_app(
+    web_manager: Any,
+    action_fields: List[Dict[str, Any]],
+    metadata: Optional[EnvironmentMetadata],
+    is_chat_env: bool,
+    title: str,
+    quick_start_md: str,
+) -> gr.Blocks:
+    """
+    Second tab (**Visualization**) for pathway_analysis_env: interactive pathway lab.
+
+    Uses ``web_manager.env.set_case_file`` before reset, and ``step_environment`` with
+    structured ``PathwayAction`` payloads.
+    """
+    case_choices = _list_case_files()
+    saved_runs = _list_saved_runs()
+    display = metadata.name if metadata else title
+
+    async def do_reset(case_file: str):
+        try:
+            if hasattr(web_manager.env, "set_case_file"):
+                web_manager.env.set_case_file(case_file)
+            data = await web_manager.reset_environment()
+            return _response(
+                data,
+                web_manager,
+                f"Loaded case `{case_file}` and reset.",
+                update_contrast=True,
+            )
+        except Exception as e:
+            empty = pd.DataFrame({"error": [str(e)]})
+            z = gr.update()
+            return (
+                "",
+                empty,
+                empty,
+                empty,
+                "",
+                "",
+                "",
+                f"*Error:* `{e}`",
+                str(e),
+                z,
+                z,
+            )
+
+    async def step_inspect():
+        data = await web_manager.step_environment({"action_type": "inspect_dataset"})
+        return _response(
+            data,
+            web_manager,
+            "Inspect complete.",
+            update_contrast=False,
+        )
+
+    async def step_understand(cond_a: str, cond_b: str):
+        payload: Dict[str, Any] = {
+            "action_type": "understand_experiment_design",
+            "condition_a": (cond_a or "").strip() or None,
+            "condition_b": (cond_b or "").strip() or None,
+        }
+        data = await web_manager.step_environment(payload)
+        return _response(
+            data,
+            web_manager,
+            "Understand experiment design complete.",
+            update_contrast=False,
+        )
+
+    async def step_de(cond_a: str, cond_b: str):
+        payload: Dict[str, Any] = {
+            "action_type": "run_differential_expression",
+            "condition_a": (cond_a or "").strip() or None,
+            "condition_b": (cond_b or "").strip() or None,
+        }
+        data = await web_manager.step_environment(payload)
+        return _response(
+            data,
+            web_manager,
+            "Differential expression complete.",
+            update_contrast=False,
+        )
+
+    async def step_ora():
+        data = await web_manager.step_environment(
+            {"action_type": "run_pathway_enrichment"}
+        )
+        return _response(
+            data,
+            web_manager,
+            "ORA complete.",
+            update_contrast=False,
+        )
+
+    async def step_compare(pa: str, pb: str):
+        data = await web_manager.step_environment(
+            {
+                "action_type": "compare_pathways",
+                "pathway_a": (pa or "").strip(),
+                "pathway_b": (pb or "").strip(),
+            }
+        )
+        return _response(
+            data,
+            web_manager,
+            "Compare complete.",
+            update_contrast=False,
+        )
+
+    async def step_submit(hyp: str):
+        data = await web_manager.step_environment(
+            {"action_type": "submit_answer", "hypothesis": (hyp or "").strip()}
+        )
+        return _response(
+            data,
+            web_manager,
+            "Answer submitted.",
+            update_contrast=False,
+        )
+
+    with gr.Blocks(title=f"{display} — Pathway lab") as blocks:
+        gr.Markdown(
+            f"# Pathway lab\n\n"
+            f"**Agent-style flow:** **(1) Groups & design** — how many conditions and samples per group. "
+            f"**(2) DGE** — pick reference vs alternate, then differential expression. "
+            f"**(3) Pathways** — ORA, compare, submit hypothesis. "
+            f"Buttons: Understand design → Inspect → Run DE → Run ORA → … Use **Playground** for raw actions.\n\n"
+            f"---"
+        )
+
+        with gr.Row(equal_height=True):
+            with gr.Column(scale=2):
+                gr.Markdown("**Case & episode**")
+                with gr.Row():
+                    case_dd = gr.Dropdown(
+                        choices=case_choices,
+                        value=case_choices[0] if case_choices else None,
+                        label="Case JSON (`data/`)",
+                        scale=2,
+                    )
+                    reset_btn = gr.Button("Reset episode", variant="primary", scale=1)
+            with gr.Column(scale=3):
+                out_state = gr.Markdown(label="Episode state")
+                out_status = gr.Textbox(label="Last action", max_lines=2)
+
+        gr.Markdown("### Contrast (PyDESeq2 pipeline cases)")
+        gr.Markdown(
+            "*Reference* = baseline condition, *alternate* = treatment. "
+            "Reset fills these from the case when possible; edit if needed. "
+            "**Understand design:** leave both empty for a structured summary only, or fill both to validate the contrast (used by **Run DE** when those fields are left empty)."
+        )
+        with gr.Row():
+            cond_ref = gr.Textbox(
+                label="Reference condition",
+                placeholder="e.g. control",
+                lines=1,
+            )
+            cond_alt = gr.Textbox(
+                label="Alternate condition",
+                placeholder="e.g. treated",
+                lines=1,
+            )
+
+        gr.Markdown("#### Workflow")
+        with gr.Row():
+            btn_ud = gr.Button("0 · Understand design", variant="secondary")
+            btn_ins = gr.Button("1 · Inspect", variant="secondary")
+            btn_de = gr.Button("2 · Run DE", variant="primary")
+            btn_ora = gr.Button("3 · Run ORA", variant="primary")
+        with gr.Row():
+            pw_a = gr.Textbox(label="Pathway A", placeholder="MAPK signaling", scale=1)
+            pw_b = gr.Textbox(label="Pathway B", placeholder="PI3K-Akt", scale=1)
+            btn_cmp = gr.Button("4 · Compare", scale=0, min_width=120)
+        with gr.Row():
+            hyp = gr.Textbox(
+                label="Hypothesis (pathway name)",
+                placeholder="True activated pathway",
+                scale=2,
+            )
+            btn_sub = gr.Button("5 · Submit", variant="stop", scale=0, min_width=120)
+
+        gr.Markdown("### Results")
+        out_md = gr.Markdown()
+        with gr.Tabs():
+            with gr.Tab("DE genes"):
+                out_de = gr.Dataframe(
+                    label="Differential expression",
+                    interactive=False,
+                    wrap=True,
+                )
+            with gr.Tab("ORA"):
+                out_ora = gr.Dataframe(
+                    label="Pathway enrichment",
+                    interactive=False,
+                    wrap=True,
+                )
+            with gr.Tab("Compare"):
+                out_cmp = gr.Dataframe(
+                    label="Pathway vs pathway",
+                    interactive=False,
+                    wrap=True,
+                )
+            with gr.Tab("Saved run (GSE235417)"):
+                gr.Markdown(
+                    "Browse exported run artifacts under `envs/pathway_analysis_env/outputs/<run>/` "
+                    "(e.g. `gse235417`). This view does **not** re-run DESeq2; it only loads saved JSON."
+                )
+                run_dd = gr.Dropdown(
+                    choices=saved_runs,
+                    value="gse235417" if "gse235417" in saved_runs else (saved_runs[0] if saved_runs else None),
+                    label="Saved run folder (`outputs/`)",
+                )
+                load_btn = gr.Button("Load saved results", variant="primary")
+                run_md = gr.Markdown()
+                run_de = gr.Dataframe(label="Saved DE (top 200)", interactive=False, wrap=True)
+                run_enr = gr.Dataframe(label="Saved enrichment (top 50)", interactive=False, wrap=True)
+            with gr.Tab("Overlap & ambiguity"):
+                out_extra = gr.Markdown()
+            with gr.Tab("Trace"):
+                out_trace = gr.Markdown()
+            with gr.Tab("Raw JSON"):
+                out_raw = gr.Code(label="Wire payload", language="json", interactive=False)
+
+        ui_outputs = [
+            out_md,
+            out_de,
+            out_ora,
+            out_cmp,
+            out_extra,
+            out_trace,
+            out_raw,
+            out_state,
+            out_status,
+            cond_ref,
+            cond_alt,
+        ]
+
+        reset_btn.click(fn=do_reset, inputs=[case_dd], outputs=ui_outputs)
+        btn_ud.click(fn=step_understand, inputs=[cond_ref, cond_alt], outputs=ui_outputs)
+        btn_ins.click(fn=step_inspect, outputs=ui_outputs)
+        btn_de.click(fn=step_de, inputs=[cond_ref, cond_alt], outputs=ui_outputs)
+        btn_ora.click(fn=step_ora, outputs=ui_outputs)
+        btn_cmp.click(fn=step_compare, inputs=[pw_a, pw_b], outputs=ui_outputs)
+        btn_sub.click(fn=step_submit, inputs=[hyp], outputs=ui_outputs)
+
+        def do_load_saved(run_name: str):
+            run = _load_saved_run(run_name or "")
+            md, df_de, df_enr = _saved_run_to_tables(run)
+            return md, df_de, df_enr
+
+        load_btn.click(fn=do_load_saved, inputs=[run_dd], outputs=[run_md, run_de, run_enr])
+
+    return blocks

envs/pathway_analysis_env/server/pathway_environment.py

@@ -0,0 +1,1112 @@
+# 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.
+
+"""
+Pathway analysis environment: PyDESeq2 DE, Fisher ORA, overlap-aware tools,
+HTML episode trace.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from openenv.core.env_server import Environment
+
+from ..models import PathwayAction, PathwayObservation, PathwayState
+from . import failure_codes as FC
+from .case_loader import load_case_file, strip_case_secrets
+from .eval_protocol import (
+    default_max_steps,
+    resolve_eval_mode,
+    resolve_orchestrator_mode,
+    sanitize_observation_for_agent,
+    shaping_reward,
+    strip_legacy_answer_leaks,
+)
+from .scoring import score_submission
+from .analysis import (
+    build_sample_metadata,
+    compare_pathways_detail,
+    counts_dict_to_samples_by_genes,
+    filter_counts_by_minimum_total,
+    gseapy_available,
+    load_counts_csv_as_samples_by_genes,
+    load_author_de_table_csv,
+    merge_analysis_options,
+    enrichr_ora,
+    ora_fisher,
+    overlap_genes_across_top_pathways,
+    pick_de_query_genes,
+    pydeseq2_available,
+    run_deseq2_contrast,
+    top_hits_statistically_close,
+    validate_counts_case,
+)
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+OUTPUT_TRACE_DIR = Path(__file__).resolve().parent.parent / "outputs" / "pathway_traces"
+
+
+def load_case(
+    case_name: str = "toy_case_001.json", *, agent_safe: bool = False
+) -> Dict[str, Any]:
+    """Load a case JSON. Set ``agent_safe=True`` to omit orchestrator secret fields."""
+    case, _secrets = load_case_file(DATA_DIR, case_name, agent_safe=agent_safe)
+    return case
+
+
+def _legacy_de_rows(top_names: List[str]) -> List[Dict[str, Any]]:
+    """Synthetic DE rows for legacy JSON-only cases."""
+    rows: List[Dict[str, Any]] = []
+    for i, name in enumerate(top_names):
+        rows.append(
+            {
+                "gene": name,
+                "baseMean": 500.0,
+                "log2FoldChange": 2.0 - i * 0.1,
+                "lfcSE": 0.2,
+                "pvalue": 1e-6,
+                "padj": 0.01,
+                "significant": True,
+            }
+        )
+    return rows
+
+
+def _write_html_trace(
+    episode_id: str,
+    steps: List[Dict[str, Any]],
+    case_id: str,
+) -> str:
+    OUTPUT_TRACE_DIR.mkdir(parents=True, exist_ok=True)
+    path = OUTPUT_TRACE_DIR / f"{episode_id}.html"
+    rows_html = []
+    for s in steps:
+        rows_html.append(
+            "<tr><td>{}</td><td><pre>{}</pre></td><td>{}</td></tr>".format(
+                html.escape(str(s.get("step", ""))),
+                html.escape(json.dumps(s.get("detail", {}), indent=2)[:8000]),
+                html.escape(str(s.get("message", ""))[:2000]),
+            )
+        )
+    body = f"""<!DOCTYPE html>
+<html><head><meta charset="utf-8"/><title>Pathway trace {html.escape(episode_id)}</title>
+<style>body{{font-family:system-ui,sans-serif;margin:1rem;}} table{{border-collapse:collapse;width:100%;}}
+td,th{{border:1px solid #ccc;padding:0.4rem;vertical-align:top;}} pre{{white-space:pre-wrap;}}</style>
+</head><body>
+<h1>Pathway analysis episode</h1>
+<p><b>case</b>: {html.escape(case_id)} &nbsp; <b>episode</b>: {html.escape(episode_id)}</p>
+<p>Generated {html.escape(datetime.now(timezone.utc).isoformat())}</p>
+<table><thead><tr><th>Step</th><th>Detail</th><th>Message</th></tr></thead>
+<tbody>{"".join(rows_html)}</tbody></table>
+</body></html>"""
+    path.write_text(body, encoding="utf-8")
+    return str(path)
+
+
+def _safe_case_id(case: Dict[str, Any]) -> str:
+    """Best-effort case identifier for trace rendering."""
+    try:
+        cid = case.get("case_id")
+    except Exception:
+        cid = None
+    return str(cid or "unknown_case")
+
+
+class PathwayEnvironment(Environment):
+    """
+    Pathway inference with optional **pipeline Mode A** (counts + metadata in JSON),
+    or **legacy** toy fixtures (static gene/pathway lists).
+    """
+
+    def __init__(
+        self,
+        case_file: str = "toy_case_001.json",
+        *,
+        agent_safe_cases: bool = False,
+    ):
+        super().__init__()
+        self._case_file = case_file
+        self._agent_safe_cases = agent_safe_cases
+        self._case: Dict[str, Any] = {}
+        self._state = PathwayState()
+        self._true_pathway: str = ""
+        self._true_pathway_aliases: List[str] = []
+        self._expected_keywords: List[str] = []
+        self._eval_mode: bool = True
+        self._orchestrator_mode: bool = False
+        self._max_steps: int = 30
+        self._episode_outcome: Optional[Dict[str, Any]] = None
+        self._de_rows: List[Dict[str, Any]] = []
+        self._ora_rows: List[Dict[str, Any]] = []
+        self._query_genes: List[str] = []
+        self._trace_steps: List[Dict[str, Any]] = []
+        self._universe_genes: List[str] = []
+        self.reset()
+
+    def set_case_file(self, case_file: str) -> None:
+        """Switch JSON case before ``reset()`` (used by the Gradio Pathway lab tab)."""
+        self._case_file = case_file
+
+    @property
+    def episode_outcome(self) -> Optional[Dict[str, Any]]:
+        """Orchestrator-only score after ``submit_answer`` (not exposed via agent state)."""
+        return self._episode_outcome
+
+    def _emit(self, obs: PathwayObservation) -> PathwayObservation:
+        if obs.trace_path is None and self._state.episode_id:
+            obs = obs.model_copy(update={"trace_path": self._refresh_trace_file()})
+        return sanitize_observation_for_agent(
+            obs,
+            eval_mode=self._eval_mode,
+            orchestrator_mode=self._orchestrator_mode,
+        )
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> PathwayObservation:
+        use_agent_safe = bool(
+            kwargs.get("agent_safe_cases", self._agent_safe_cases)
+        )
+        full_case, secrets = load_case_file(
+            DATA_DIR, self._case_file, agent_safe=False
+        )
+        self._eval_mode = resolve_eval_mode(full_case, kwargs)
+        self._orchestrator_mode = resolve_orchestrator_mode(full_case, kwargs)
+        if use_agent_safe or (
+            self._eval_mode and not self._orchestrator_mode
+        ):
+            self._case = strip_case_secrets(full_case)
+        else:
+            self._case = full_case
+        eid = episode_id or str(uuid.uuid4())
+        strict = bool(kwargs.get("strict", full_case.get("strict_mode", False)))
+        self._max_steps = default_max_steps(full_case)
+        self._true_pathway = str(secrets.get("true_pathway", ""))
+        self._true_pathway_aliases = list(secrets.get("true_pathway_aliases") or [])
+        self._expected_keywords = list(secrets.get("expected_keywords") or [])
+        self._episode_outcome = None
+        pipeline = (
+            (
+                "counts" in self._case
+                or "counts_file" in self._case
+                or "de_table_file" in self._case
+            )
+            and "sample_ids" in self._case
+            and "sample_metadata" in self._case
+        )
+        self._de_rows = []
+        self._ora_rows = []
+        self._query_genes = []
+        self._trace_steps = []
+        self._universe_genes = []
+        self._state = PathwayState(
+            episode_id=eid,
+            step_count=0,
+            conditions=list(self._case.get("conditions", [])),
+            pipeline_mode=pipeline,
+            strict_mode=strict,
+            legacy_mode=not pipeline,
+            eval_mode=self._eval_mode,
+            max_steps=self._max_steps,
+        )
+        mode = "legacy"
+        if pipeline:
+            if "de_table_file" in self._case:
+                mode = "author_de_table"
+            elif "counts_file" in self._case or "counts" in self._case:
+                mode = "counts_matrix"
+            else:
+                mode = "pipeline_unknown"
+        msg = (
+            "Dataset loaded (pipeline: counts/metadata)."
+            if mode == "counts_matrix"
+            else (
+                "Dataset loaded (pipeline: author DE table; enrichment only, not DESeq2-from-counts)."
+                if mode == "author_de_table"
+                else "Toy dataset loaded (legacy static lists)."
+            )
+        )
+        self._trace(
+            "reset",
+            {
+                "case_id": self._case.get("case_id"),
+                "pipeline": pipeline,
+                "mode": mode,
+                "strict": strict,
+            },
+            msg,
+        )
+        trace_path = _write_html_trace(
+            eid, self._trace_steps, _safe_case_id(self._case)
+        )
+        obs = PathwayObservation(
+            message=msg
+            + " Use understand_experiment_design, inspect, run DE, enrichment, compare, or submit.",
+            available_conditions=self._state.conditions,
+            metadata={
+                "case_id": self._case["case_id"],
+                "pipeline_mode": pipeline,
+                "pipeline_data_mode": mode,
+                "eval_mode": self._eval_mode,
+                "max_steps": self._max_steps,
+            },
+            trace_path=trace_path,
+        )
+        return self._emit(obs)
+
+    def _trace(self, kind: str, detail: Dict[str, Any], message: str) -> None:
+        s = self._state
+        self._trace_steps.append(
+            {
+                "step": s.step_count,
+                "kind": kind,
+                "detail": detail,
+                "message": message,
+            }
+        )
+
+    def _refresh_trace_file(self) -> str:
+        eid = self._state.episode_id or "unknown"
+        return _write_html_trace(
+            eid, self._trace_steps, _safe_case_id(self._case)
+        )
+
+    def _fail_strict(
+        self, reason: str, failure_code: str = FC.STRICT_TERMINATION
+    ) -> PathwayObservation:
+        self._state.is_done = True
+        self._trace(
+            "strict_failure",
+            {"reason": reason, "failure_code": failure_code},
+            reason,
+        )
+        tp = self._refresh_trace_file()
+        return PathwayObservation(
+            message=reason,
+            done=True,
+            reward=-3.0,
+            metadata={
+                "strict_failure": True,
+                "reason": reason,
+                "failure_code": failure_code,
+            },
+            trace_path=tp,
+        )
+
+    def step(
+        self,
+        action: PathwayAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> PathwayObservation:
+        return self._emit(self._step_inner(action))
+
+    def _step_inner(self, action: PathwayAction) -> PathwayObservation:
+        s = self._state
+
+        if s.is_done:
+            obs = PathwayObservation(
+                message="Episode already finished; call reset() for a new episode.",
+                done=True,
+                reward=0.0,
+                metadata={
+                    "error": "episode_done",
+                    "failure_code": FC.EPISODE_ALREADY_DONE,
+                    "step_count": s.step_count,
+                },
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        s.step_count += 1
+
+        if self._eval_mode and s.step_count > self._max_steps:
+            s.is_done = True
+            self._trace(
+                "max_steps",
+                {"max_steps": self._max_steps},
+                "Step budget exhausted.",
+            )
+            return PathwayObservation(
+                message="Maximum steps exceeded for this episode.",
+                done=True,
+                reward=-1.0 if not self._eval_mode else 0.0,
+                metadata={
+                    "failure_code": FC.MAX_STEPS_EXCEEDED,
+                    "max_steps": self._max_steps,
+                },
+                trace_path=self._refresh_trace_file(),
+            )
+
+        if action.action_type == "inspect_dataset":
+            meta = self._case.get("sample_metadata") or {}
+            sample_ids = list(self._case.get("sample_ids") or [])
+            sample_level = bool(sample_ids and meta)
+            if s.legacy_mode:
+                msg = (
+                    "Legacy fixture: conditions are listed; per-sample metadata and counts "
+                    "are not modeled. DE and ORA return static curated outputs."
+                )
+            elif sample_level:
+                msg = (
+                    "Sample metadata and conditions are available for contrast specification."
+                )
+            else:
+                msg = (
+                    "Conditions are available; sample_ids or sample_metadata are incomplete "
+                    "in this case."
+                )
+            inspect_meta: Dict[str, Any] = {
+                "step_count": s.step_count,
+                "legacy_mode": s.legacy_mode,
+                "pipeline_mode": s.pipeline_mode,
+                "sample_level_metadata_available": sample_level,
+                "sample_metadata": meta,
+                "sample_ids": sample_ids,
+                "pydeseq2_available": pydeseq2_available(),
+                "experiment_metadata": self._case.get("experiment_metadata"),
+            }
+            if s.legacy_mode and not self._eval_mode:
+                inspect_meta["static_top_genes"] = list(
+                    self._case.get("top_genes") or []
+                )
+                inspect_meta["static_top_pathways"] = list(
+                    self._case.get("top_pathways") or []
+                )
+            inspect_meta = strip_legacy_answer_leaks(
+                inspect_meta, eval_mode=self._eval_mode
+            )
+            obs = PathwayObservation(
+                message=msg,
+                available_conditions=s.conditions,
+                reward=shaping_reward(self._eval_mode, 0.05),
+                metadata=inspect_meta,
+            )
+            self._trace(
+                "inspect_dataset",
+                {"conditions": s.conditions, "legacy": s.legacy_mode},
+                obs.message,
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        if action.action_type == "understand_experiment_design":
+            return self._step_understand_experiment_design(action)
+
+        if action.action_type == "run_differential_expression":
+            return self._step_de(action)
+
+        if action.action_type == "run_pathway_enrichment":
+            return self._step_enrichment(action)
+
+        if action.action_type == "compare_pathways":
+            return self._step_compare(action)
+
+        if action.action_type == "submit_answer":
+            return self._step_submit(action)
+
+        obs = PathwayObservation(
+            message=f"Unknown action_type: {action.action_type}",
+            reward=shaping_reward(self._eval_mode, -0.2),
+            metadata={
+                "step_count": s.step_count,
+                "failure_code": FC.UNKNOWN_ACTION_TYPE,
+                "action_type": action.action_type,
+            },
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    def _experiment_design_dict(self) -> Dict[str, Any]:
+        case = self._case
+        s = self._state
+        sample_ids = list(case.get("sample_ids") or [])
+        smd = case.get("sample_metadata") or {}
+        per: Dict[str, int] = {}
+        for sid in sample_ids:
+            c = smd.get(sid)
+            if c is not None:
+                per[c] = per.get(c, 0) + 1
+        conds = list(s.conditions)
+        sample_level = bool(sample_ids and smd)
+        design: Dict[str, Any] = {
+            "case_id": case.get("case_id"),
+            "pipeline_mode": s.pipeline_mode,
+            "legacy_mode": s.legacy_mode,
+            "conditions": conds,
+            "n_groups": len(conds),
+            "n_samples": len(sample_ids) if sample_level else None,
+            "sample_ids": sample_ids,
+            "sample_level_metadata_available": sample_level,
+            "default_contrast": case.get("default_contrast"),
+            "experiment_metadata": case.get("experiment_metadata"),
+        }
+        if sample_level:
+            design["samples_per_condition"] = per
+            workflow = (
+                "(1) Groups: use conditions + samples_per_condition to see how many groups and "
+                "replicates exist. (2) DGE: pick reference vs alternate for DESeq2 "
+                "(validate via understand_experiment_design or pass to run_differential_expression). "
+                "(3) Pathways: run_pathway_enrichment then compare/submit."
+            )
+            note = (
+                "Reference = baseline (denominator of log2 fold change); alternate = comparison arm "
+                "for DGE. Optionally set condition_a / condition_b here to validate before "
+                "run_differential_expression."
+            )
+        elif s.legacy_mode:
+            design["samples_per_condition"] = None
+            design["legacy_fixture"] = True
+            workflow = (
+                "(1) Groups: conditions are named only (no per-sample counts in this legacy fixture). "
+                "(2) DGE / ORA return static curated gene and pathway lists. "
+                "(3) Submit the pathway hypothesis."
+            )
+            note = (
+                "Legacy mode does not run DESeq2 on counts. Contrast validation checks condition "
+                "names only. Use run_differential_expression and run_pathway_enrichment for "
+                "fixture outputs, then submit_answer."
+            )
+        else:
+            design["samples_per_condition"] = per if per else None
+            workflow = (
+                "(1) Groups: conditions are listed; sample-level metadata may be incomplete. "
+                "(2) DGE: pick reference vs alternate when counts/metadata are available. "
+                "(3) Pathways: enrichment then submit."
+            )
+            note = (
+                "Reference = baseline; alternate = comparison arm. Sample counts per condition "
+                "are unavailable until sample_ids and sample_metadata are present in the case."
+            )
+        design["agent_workflow"] = workflow
+        design["design_note"] = note
+        return design
+
+    def _validate_contrast_proposal(
+        self, ref: str, alt: str
+    ) -> Optional[Tuple[str, str]]:
+        """Return (error_message, failure_code) if invalid; None if valid for DESeq2."""
+        conds = set(self._state.conditions)
+        if ref not in conds or alt not in conds:
+            return (
+                "Reference and alternate must be among the case `conditions`.",
+                FC.DESIGN_INVALID_CONTRAST_NAMES,
+            )
+        if ref == alt:
+            return (
+                "Reference and alternate must be two different conditions.",
+                FC.DESIGN_INVALID_CONTRAST_NAMES,
+            )
+        sample_ids = list(self._case.get("sample_ids") or [])
+        smd = self._case.get("sample_metadata") or {}
+        if not sample_ids:
+            return None
+        per: Dict[str, int] = {}
+        for sid in sample_ids:
+            c = smd.get(sid)
+            if c is not None:
+                per[c] = per.get(c, 0) + 1
+        if per.get(ref, 0) < 1 or per.get(alt, 0) < 1:
+            return (
+                "Each contrast arm must have at least one sample in `sample_metadata`.",
+                FC.DESIGN_INSUFFICIENT_SAMPLES_PER_ARM,
+            )
+        return None
+
+    def _step_understand_experiment_design(
+        self, action: PathwayAction
+    ) -> PathwayObservation:
+        s = self._state
+        design = self._experiment_design_dict()
+        ref_in = (action.condition_a or "").strip()
+        alt_in = (action.condition_b or "").strip()
+        has_both = bool(ref_in and alt_in)
+        has_partial = bool(ref_in or alt_in) and not has_both
+
+        if has_partial:
+            obs = PathwayObservation(
+                message=(
+                    "Provide both reference (condition_a) and alternate (condition_b) to "
+                    "validate a contrast, or leave both empty for a design summary only."
+                ),
+                available_conditions=s.conditions,
+                experiment_design=design,
+                reward=shaping_reward(self._eval_mode, -0.02),
+                metadata={
+                    "step_count": s.step_count,
+                    "validation": "incomplete",
+                    "failure_code": FC.DESIGN_PARTIAL_CONTRAST,
+                },
+            )
+            self._trace(
+                "understand_experiment_design",
+                {"validation": "incomplete"},
+                obs.message,
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        if not has_both:
+            s.design_understood = True
+            if s.legacy_mode:
+                msg = (
+                    "Design summary (legacy fixture): condition names are available; per-sample "
+                    "replicate counts are not modeled. DE and ORA use static outputs. You may still "
+                    "validate a contrast by naming reference vs alternate, then run DE → ORA → submit."
+                )
+            elif design.get("sample_level_metadata_available"):
+                msg = (
+                    "Design summary: you have the groups (conditions) and sample counts per group. "
+                    "Next, choose reference vs alternate for DGE (differential expression), then "
+                    "pathway steps. Re-run this action with both conditions set to validate your "
+                    "contrast."
+                )
+            else:
+                msg = (
+                    "Design summary: condition names are listed; sample counts per group are not "
+                    "available in this case. Re-run with both conditions set to validate a contrast "
+                    "when supported, then run DGE and pathway steps."
+                )
+            obs = PathwayObservation(
+                message=msg,
+                available_conditions=s.conditions,
+                experiment_design=design,
+                reward=shaping_reward(self._eval_mode, 0.05),
+                metadata={"step_count": s.step_count, "validation": "summary_only"},
+            )
+            self._trace("understand_experiment_design", {"mode": "summary"}, msg)
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        invalid = self._validate_contrast_proposal(ref_in, alt_in)
+        if invalid:
+            err, fcode = invalid
+            s.validated_reference = None
+            s.validated_alternate = None
+            s.design_understood = True
+            obs = PathwayObservation(
+                message=err,
+                available_conditions=s.conditions,
+                experiment_design=design,
+                reward=shaping_reward(self._eval_mode, -0.05),
+                metadata={
+                    "step_count": s.step_count,
+                    "validation": "invalid",
+                    "failure_code": fcode,
+                },
+            )
+            self._trace(
+                "understand_experiment_design",
+                {"validation": "invalid", "proposal": [ref_in, alt_in]},
+                err,
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        s.validated_reference = ref_in
+        s.validated_alternate = alt_in
+        s.design_understood = True
+        design["validated_contrast"] = {"reference": ref_in, "alternate": alt_in}
+        msg = (
+            f"DGE contrast chosen: reference=`{ref_in}`, alternate=`{alt_in}` "
+            f"({len(s.conditions)} groups in study). "
+            "run_differential_expression will use this pair when DE omits conditions; "
+            "explicit DE fields override. Then run pathway enrichment."
+        )
+        obs = PathwayObservation(
+            message=msg,
+            available_conditions=s.conditions,
+            experiment_design=design,
+            reward=shaping_reward(self._eval_mode, 0.08),
+            metadata={"step_count": s.step_count, "validation": "valid"},
+        )
+        self._trace(
+            "understand_experiment_design",
+            {"validation": "valid", "contrast": [ref_in, alt_in]},
+            msg,
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    def _resolve_de_contrast(
+        self, action: PathwayAction
+    ) -> tuple[Optional[str], Optional[str]]:
+        """DESeq2 contrast: explicit action fields beat validated design, then default_contrast."""
+        dc = self._case.get("default_contrast") or {}
+        ar = (action.condition_a or "").strip()
+        ab = (action.condition_b or "").strip()
+        ref = ar or self._state.validated_reference or dc.get("reference")
+        alt = ab or self._state.validated_alternate or dc.get("alternate")
+        return ref, alt
+
+    def _step_de(self, action: PathwayAction) -> PathwayObservation:
+        s = self._state
+        if s.legacy_mode:
+            names = list(self._case.get("top_genes", []))
+            self._de_rows = _legacy_de_rows(names)
+            self._query_genes = names
+            s.de_run = True
+            self._trace("de", {"legacy": True, "genes": names}, "Legacy DE")
+            obs = PathwayObservation(
+                message="Differential expression complete (legacy fixture).",
+                top_genes=names,
+                de_genes=self._de_rows,
+                reward=shaping_reward(self._eval_mode, 0.25),
+                metadata={"step_count": s.step_count, "legacy": True},
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        if not pydeseq2_available():
+            if s.strict_mode:
+                return self._fail_strict(
+                    "PyDESeq2 is not installed; strict mode terminates.",
+                    FC.DE_PYDESeq2_UNAVAILABLE,
+                )
+            return PathwayObservation(
+                message="PyDESeq2 is not installed; cannot run DE on counts.",
+                reward=shaping_reward(self._eval_mode, -0.5),
+                metadata={
+                    "error": "missing_pydeseq2",
+                    "failure_code": FC.DE_PYDESeq2_UNAVAILABLE,
+                },
+            )
+
+        ref, alt = self._resolve_de_contrast(action)
+        if not ref or not alt:
+            msg = "Specify condition_a (reference) and condition_b (alternate) for DESeq2."
+            if s.strict_mode:
+                return self._fail_strict(msg, FC.DE_MISSING_CONTRAST)
+            return PathwayObservation(
+                message=msg,
+                reward=shaping_reward(self._eval_mode, -0.3),
+                metadata={"error": "contrast", "failure_code": FC.DE_MISSING_CONTRAST},
+            )
+
+        sample_ids = self._case["sample_ids"]
+        smd = self._case["sample_metadata"]
+        try:
+            if "de_table_file" in self._case:
+                # Author-provided DE (no counts available). We treat this as a precomputed DE run.
+                opts = merge_analysis_options(self._case)
+                de_rows = load_author_de_table_csv(
+                    DATA_DIR / str(self._case["de_table_file"]),
+                    gene_column=str(self._case.get("de_table_gene_column") or "Gene,name"),
+                    log2fc_column=str(self._case.get("de_table_log2fc_column") or "log2FoldChange"),
+                    pvalue_column=str(self._case.get("de_table_pvalue_column") or "pvalue"),
+                    padj_column=str(self._case.get("de_table_padj_column") or "padj"),
+                )
+                padj_alpha = float(opts["padj_alpha"])
+                for r in de_rows:
+                    try:
+                        pv = float(r.get("padj"))
+                    except (TypeError, ValueError):
+                        pv = 1.0
+                    r["significant"] = bool(pv <= padj_alpha)
+                self._de_rows = de_rows
+                self._query_genes = pick_de_query_genes(
+                    de_rows,
+                    padj_alpha=padj_alpha,
+                    direction=str(opts["de_query_direction"]),
+                    min_abs_log2fc=float(opts["min_abs_log2fc"]),
+                )
+                self._universe_genes = []  # unknown without counts
+                s.de_run = True
+                top_names = [r["gene"] for r in de_rows[:50]]
+                self._trace(
+                    "de",
+                    {
+                        "precomputed": True,
+                        "source": "author_de_table",
+                        "contrast": [ref, alt],
+                        "n_sig": sum(1 for r in de_rows if r.get("significant")),
+                        "n_rows": len(de_rows),
+                    },
+                    "Differential expression loaded (author-provided table).",
+                )
+                obs = PathwayObservation(
+                    message="Differential expression loaded from author table.",
+                    top_genes=top_names,
+                    de_genes=self._de_rows,
+                    reward=shaping_reward(self._eval_mode, 0.25),
+                    metadata={
+                        "step_count": s.step_count,
+                        "precomputed": True,
+                        "source": "author_de_table",
+                    },
+                )
+                obs.trace_path = self._refresh_trace_file()
+                return obs
+
+            if "counts_file" in self._case:
+                counts_df = load_counts_csv_as_samples_by_genes(
+                    DATA_DIR / str(self._case["counts_file"]),
+                    sample_ids=sample_ids,
+                )
+            else:
+                counts = self._case["counts"]
+                v_err = validate_counts_case(self._case)
+                if v_err:
+                    raise ValueError(v_err)
+                counts_df = counts_dict_to_samples_by_genes(counts, sample_ids)
+            meta_df = build_sample_metadata(sample_ids, smd)
+        except ValueError as exc:
+            if s.strict_mode:
+                return self._fail_strict(str(exc), FC.DE_INVALID_COUNTS_MATRIX)
+            return PathwayObservation(
+                message=str(exc),
+                reward=shaping_reward(self._eval_mode, -0.5),
+                metadata={
+                    "error": "counts_or_metadata_invalid",
+                    "failure_code": FC.DE_INVALID_COUNTS_MATRIX,
+                },
+            )
+
+        opts = merge_analysis_options(self._case)
+        counts_df, n_genes_in, n_genes_filt = filter_counts_by_minimum_total(
+            counts_df, int(opts["min_total_count"])
+        )
+        if n_genes_filt < 5:
+            msg = (
+                f"After min_total_count={opts['min_total_count']} prefilter, "
+                f"only {n_genes_filt} genes remain (need ≥5 for stable DESeq2)."
+            )
+            if s.strict_mode:
+                return self._fail_strict(msg, FC.DE_TOO_FEW_GENES_AFTER_FILTER)
+            return PathwayObservation(
+                message=msg,
+                reward=shaping_reward(self._eval_mode, -0.5),
+                metadata={
+                    "error": "too_few_genes_after_filter",
+                    "failure_code": FC.DE_TOO_FEW_GENES_AFTER_FILTER,
+                },
+            )
+
+        rows, err = run_deseq2_contrast(
+            counts_df,
+            meta_df,
+            alt,
+            ref,
+            padj_alpha=float(opts["padj_alpha"]),
+        )
+        if err:
+            if s.strict_mode:
+                return self._fail_strict(err, FC.DE_DESEQ2_FAILED)
+            return PathwayObservation(
+                message=err,
+                reward=shaping_reward(self._eval_mode, -0.5),
+                metadata={"error": err, "failure_code": FC.DE_DESEQ2_FAILED},
+            )
+
+        self._universe_genes = list(counts_df.columns)
+        self._de_rows = rows
+        self._query_genes = pick_de_query_genes(
+            rows,
+            padj_alpha=float(opts["padj_alpha"]),
+            direction=str(opts["de_query_direction"]),
+            min_abs_log2fc=float(opts["min_abs_log2fc"]),
+        )
+        s.de_run = True
+        top_names = [r["gene"] for r in rows[:50]]
+        self._trace(
+            "de",
+            {
+                "contrast": [ref, alt],
+                "n_sig": sum(1 for r in rows if r["significant"]),
+                "genes_in_matrix": n_genes_in,
+                "genes_after_prefilter": n_genes_filt,
+            },
+            "DESeq2 complete",
+        )
+        obs = PathwayObservation(
+            message="Differential expression complete (PyDESeq2).",
+            top_genes=top_names,
+            de_genes=rows[:200],
+            reward=shaping_reward(self._eval_mode, 0.35),
+            metadata={
+                "step_count": s.step_count,
+                "contrast": [ref, alt],
+                "genes_in_matrix": n_genes_in,
+                "genes_after_prefilter": n_genes_filt,
+                "analysis_options": {
+                    k: opts[k]
+                    for k in (
+                        "min_total_count",
+                        "padj_alpha",
+                        "de_query_direction",
+                        "min_abs_log2fc",
+                    )
+                },
+            },
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    def _step_enrichment(self, action: PathwayAction) -> PathwayObservation:
+        s = self._state
+        if self._eval_mode and action.gene_list:
+            return PathwayObservation(
+                message=(
+                    "Custom gene_list is disabled in eval mode; run differential "
+                    "expression and use the resulting DE gene set for ORA."
+                ),
+                reward=shaping_reward(self._eval_mode, -0.2),
+                metadata={"failure_code": FC.ORA_GENE_LIST_BLOCKED},
+            )
+        if not self._de_rows and not s.legacy_mode:
+            msg = "Run differential expression before enrichment."
+            return PathwayObservation(
+                message=msg,
+                reward=shaping_reward(self._eval_mode, -0.2),
+                metadata={"failure_code": FC.ORA_DE_PREREQUISITE},
+            )
+
+        pathways = self._case.get("pathway_genes") or {}
+        if s.legacy_mode:
+            names = list(self._case.get("top_pathways", []))
+            s.enrichment_run = True
+            fake = [
+                {
+                    "pathway": n,
+                    "p_value": 0.001,
+                    "q_value": 0.01,
+                    "overlap_genes": list(self._case.get("top_genes", []))[:2],
+                    "overlap_count": 2,
+                    "pathway_size": 10,
+                    "de_in_universe": len(self._query_genes),
+                    "gene_ratio": "2/10",
+                }
+                for n in names
+            ]
+            self._ora_rows = fake
+            amb = top_hits_statistically_close(fake)
+            ov = overlap_genes_across_top_pathways(fake)
+            self._trace("ora", {"legacy": True}, "Legacy ORA")
+            obs = PathwayObservation(
+                message="Pathway enrichment complete (legacy fixture).",
+                top_pathways=names,
+                pathway_enrichment=fake,
+                statistical_ambiguity=amb,
+                overlap_summary=ov,
+                reward=shaping_reward(self._eval_mode, 0.45),
+                metadata={"legacy": True},
+            )
+            obs.trace_path = self._refresh_trace_file()
+            return obs
+
+        opts = merge_analysis_options(self._case)
+        universe = self._universe_genes
+        if not universe:
+            if "counts" in self._case:
+                universe = list(self._case["counts"].keys())
+            else:
+                universe = []
+        query = action.gene_list if action.gene_list else self._query_genes
+        if not query:
+            query = pick_de_query_genes(
+                self._de_rows,
+                padj_alpha=float(opts["padj_alpha"]),
+                direction=str(opts["de_query_direction"]),
+                min_abs_log2fc=float(opts["min_abs_log2fc"]),
+            )
+        if not query and self._de_rows:
+            query = [r["gene"] for r in self._de_rows[:50]]
+
+        enrichr_libs = self._case.get("enrichr_libraries")
+        if enrichr_libs:
+            if not gseapy_available():
+                msg = "gseapy not installed; cannot run Enrichr enrichment."
+                if s.strict_mode:
+                    return self._fail_strict(msg, FC.ORA_NO_PATHWAY_DEFINITIONS)
+                return PathwayObservation(
+                    message=msg,
+                    reward=shaping_reward(self._eval_mode, -0.3),
+                    metadata={
+                        "error": "missing_gseapy",
+                        "failure_code": FC.ORA_NO_PATHWAY_DEFINITIONS,
+                    },
+                )
+            ora, err = enrichr_ora(
+                query,
+                libraries=list(enrichr_libs),
+                background=universe or None,
+                top_k=100,
+            )
+            if err:
+                if s.strict_mode:
+                    return self._fail_strict(err, FC.ORA_NO_PATHWAY_DEFINITIONS)
+                return PathwayObservation(
+                    message=err,
+                    reward=shaping_reward(self._eval_mode, -0.3),
+                    metadata={
+                        "error": "enrichr_failed",
+                        "failure_code": FC.ORA_NO_PATHWAY_DEFINITIONS,
+                    },
+                )
+        else:
+            if not pathways:
+                msg = "Case has no pathway_genes (and no enrichr_libraries); cannot run ORA."
+                if s.strict_mode:
+                    return self._fail_strict(msg, FC.ORA_NO_PATHWAY_DEFINITIONS)
+                return PathwayObservation(
+                    message=msg,
+                    reward=shaping_reward(self._eval_mode, -0.3),
+                    metadata={
+                        "error": "no_pathways",
+                        "failure_code": FC.ORA_NO_PATHWAY_DEFINITIONS,
+                    },
+                )
+            ora = ora_fisher(
+                query,
+                pathways,
+                universe,
+                min_pathway_genes=int(opts["ora_min_pathway_genes"]),
+            )
+        self._ora_rows = ora
+        s.enrichment_run = True
+        top_names = [r["pathway"] for r in ora[:20]]
+        amb = top_hits_statistically_close(ora)
+        ov = overlap_genes_across_top_pathways(ora)
+        self._trace("ora", {"n_pathways": len(ora)}, "ORA complete")
+        obs = PathwayObservation(
+            message="Over-representation analysis complete.",
+            top_pathways=top_names,
+            pathway_enrichment=ora[:50],
+            statistical_ambiguity=amb,
+            overlap_summary=ov,
+            reward=shaping_reward(self._eval_mode, 0.5),
+            metadata={
+                "query_genes": len(query),
+                "ora_universe_size": len(universe),
+                "ora_min_pathway_genes": int(opts["ora_min_pathway_genes"]),
+            },
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    def _step_compare(self, action: PathwayAction) -> PathwayObservation:
+        s = self._state
+        if self._eval_mode and not s.enrichment_run:
+            return PathwayObservation(
+                message="Run pathway enrichment before compare_pathways.",
+                reward=shaping_reward(self._eval_mode, -0.1),
+                metadata={"failure_code": FC.COMPARE_REQUIRES_ORA},
+            )
+        a = (action.pathway_a or "").strip()
+        b = (action.pathway_b or "").strip()
+        if not a or not b:
+            return PathwayObservation(
+                message="Provide pathway_a and pathway_b.",
+                reward=shaping_reward(self._eval_mode, -0.1),
+                metadata={
+                    "error": "missing_names",
+                    "failure_code": FC.COMPARE_MISSING_PATHWAY_NAMES,
+                },
+            )
+        pathways = self._case.get("pathway_genes") or {}
+        if s.legacy_mode:
+            # infer dummy pathways from top_pathways list
+            pathways = {
+                p: self._case.get("top_genes", [])
+                for p in self._case.get("top_pathways", [])
+            }
+        detail = compare_pathways_detail(
+            a, b, pathways, self._query_genes or list(self._case.get("top_genes", []))
+        )
+        self._trace("compare_pathways", detail, f"Compared {a} vs {b}")
+        obs = PathwayObservation(
+            message=f"Pathway comparison: {a} vs {b}.",
+            pathway_comparison=detail,
+            reward=shaping_reward(self._eval_mode, 0.15),
+            metadata={"step_count": s.step_count},
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    def _step_submit(self, action: PathwayAction) -> PathwayObservation:
+        s = self._state
+        hypothesis = (action.hypothesis or "").strip()
+        if not hypothesis:
+            return PathwayObservation(
+                message="Provide a non-empty pathway hypothesis.",
+                reward=shaping_reward(self._eval_mode, -0.1),
+                metadata={"failure_code": FC.SUBMIT_EMPTY_HYPOTHESIS},
+            )
+        if self._eval_mode:
+            if not s.de_run:
+                return PathwayObservation(
+                    message="Run differential expression before submitting.",
+                    reward=0.0,
+                    metadata={"failure_code": FC.SUBMIT_PREREQUISITE_DE},
+                )
+            if not s.enrichment_run:
+                return PathwayObservation(
+                    message="Run pathway enrichment before submitting.",
+                    reward=0.0,
+                    metadata={"failure_code": FC.SUBMIT_PREREQUISITE_ORA},
+                )
+
+        top_ora = [r.get("pathway", "") for r in self._ora_rows[:20] if r.get("pathway")]
+        outcome = score_submission(
+            hypothesis,
+            true_pathway=self._true_pathway,
+            expected_keywords=self._expected_keywords,
+            pathway_gene_set_names=list((self._case.get("pathway_genes") or {}).keys()),
+            true_pathway_aliases=self._true_pathway_aliases,
+            top_ora_pathways=top_ora,
+        )
+        correct = bool(outcome.get("correct"))
+        self._episode_outcome = {
+            **outcome,
+            "hypothesis": hypothesis,
+            "step_count": s.step_count,
+            "case_id": self._case.get("case_id"),
+        }
+        s.is_done = True
+        self._trace(
+            "submit",
+            {
+                "hypothesis": hypothesis,
+                "correct": correct,
+                "match_mode": outcome.get("match_mode"),
+            },
+            "Episode end",
+        )
+        meta: Dict[str, Any] = {
+            "correct": correct,
+            "episode_score": outcome,
+            "step_count": s.step_count,
+        }
+        if not correct:
+            meta["failure_code"] = FC.SUBMIT_INCORRECT_HYPOTHESIS
+        nominal_reward = 2.0 if correct else -1.0
+        obs = PathwayObservation(
+            message=(
+                "Answer submitted. Episode complete."
+                if self._eval_mode
+                else ("Correct pathway." if correct else "Incorrect pathway.")
+            ),
+            done=True,
+            reward=shaping_reward(self._eval_mode, nominal_reward)
+            if not self._eval_mode
+            else 0.0,
+            metadata=meta,
+        )
+        obs.trace_path = self._refresh_trace_file()
+        return obs
+
+    @property
+    def state(self) -> PathwayState:
+        return self._state

envs/pathway_analysis_env/server/scoring.py

@@ -0,0 +1,159 @@
+# 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.
+
+"""Ground-truth scoring for pathway submissions (orchestrator-only)."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Sequence
+
+
+def normalize_label(text: str) -> str:
+    """Lowercase alphanumeric tokens for fuzzy pathway / keyword matching."""
+    s = (text or "").strip().lower()
+    s = re.sub(r"[_\-/]+", " ", s)
+    s = re.sub(r"[^a-z0-9\s]+", " ", s)
+    return " ".join(s.split())
+
+
+def is_unknown_ground_truth(true_pathway: str) -> bool:
+    t = normalize_label(true_pathway)
+    return not t or t.startswith("unknown")
+
+
+def _token_set(text: str) -> set[str]:
+    return {t for t in normalize_label(text).split() if len(t) > 2}
+
+
+def labels_match(a: str, b: str) -> bool:
+    na, nb = normalize_label(a), normalize_label(b)
+    if not na or not nb:
+        return False
+    if na == nb:
+        return True
+    if na in nb or nb in na:
+        return True
+    ta, tb = _token_set(a), _token_set(b)
+    if not ta or not tb:
+        return False
+    overlap = len(ta & tb) / min(len(ta), len(tb))
+    return overlap >= 0.6
+
+
+def keyword_hits(text: str, keywords: Sequence[str]) -> List[str]:
+    joined = normalize_label(text)
+    hits: List[str] = []
+    for kw in keywords:
+        k = normalize_label(kw)
+        if k and k in joined:
+            hits.append(kw)
+    return hits
+
+
+# Base score awarded for a correct keyword-rubric (GEO) identification. The
+# remaining ``1 - KEYWORD_BASE_SCORE`` is distributed by how many expected
+# keywords the hypothesis hits. This keeps a correct GEO answer on a scale
+# comparable to a correct exact-label answer (1.0) instead of collapsing to a
+# small fraction such as 1/5 = 0.2, which otherwise biases leaderboards and
+# RL advantage estimates across heterogeneous cases.
+KEYWORD_BASE_SCORE = 0.7
+
+
+def score_submission(
+    hypothesis: str,
+    *,
+    true_pathway: str,
+    expected_keywords: Optional[Sequence[str]] = None,
+    pathway_gene_set_names: Optional[Sequence[str]] = None,
+    true_pathway_aliases: Optional[Sequence[str]] = None,
+    top_ora_pathways: Optional[Sequence[str]] = None,
+) -> Dict[str, Any]:
+    """
+    Score a submitted pathway hypothesis without exposing labels to agents.
+
+    Returns dict with ``correct``, ``score`` (0–1), ``match_mode``, and details.
+
+    Scoring is intentionally strict about *which* label earns full credit:
+
+    * With a known ``true_pathway``, only that label (and any explicit
+      ``true_pathway_aliases``) scores 1.0. Distractor pathways present in the
+      case (``pathway_gene_set_names``) and arbitrary top ORA hits do NOT earn
+      credit — naming a distractor that happens to be defined in the case is a
+      reward-hacking surface, not a correct answer.
+    * With keyword rubrics (GEO / theme-based cases), any keyword hit is
+      correct, scored on a normalized scale (see ``KEYWORD_BASE_SCORE``).
+    * Only when ground truth is genuinely unknown is the top ORA hit accepted.
+
+    ``pathway_gene_set_names`` is retained for telemetry/back-compat but no
+    longer grants credit on its own.
+    """
+    hyp = (hypothesis or "").strip()
+    if not hyp:
+        return {
+            "correct": False,
+            "score": 0.0,
+            "match_mode": "empty_hypothesis",
+            "matched_label": None,
+        }
+
+    keywords = list(expected_keywords or [])
+    ora_names = list(top_ora_pathways or [])
+
+    # Keyword rubric (GEO / theme-based cases).
+    if keywords:
+        hits = keyword_hits(hyp, keywords)
+        if hits:
+            extra_fraction = len(hits) / max(1, len(keywords))
+            score = KEYWORD_BASE_SCORE + (1.0 - KEYWORD_BASE_SCORE) * extra_fraction
+            return {
+                "correct": True,
+                "score": round(min(1.0, score), 4),
+                "match_mode": "expected_keywords",
+                "matched_label": hits[0],
+                "keyword_hits": hits,
+            }
+
+    # Known ground truth: credit only the true pathway (and explicit aliases).
+    if not is_unknown_ground_truth(true_pathway):
+        candidates = [true_pathway, *(true_pathway_aliases or [])]
+        seen: set[str] = set()
+        for label in candidates:
+            key = normalize_label(label)
+            if not key or key in seen:
+                continue
+            seen.add(key)
+            if labels_match(hyp, label):
+                return {
+                    "correct": True,
+                    "score": 1.0,
+                    "match_mode": "pathway_label",
+                    "matched_label": label,
+                }
+        # Known truth but no match: incorrect. Do not credit distractor
+        # pathways or top ORA hits.
+        return {
+            "correct": False,
+            "score": 0.0,
+            "match_mode": "no_match",
+            "matched_label": None,
+        }
+
+    # Unknown ground truth: accept top ORA hit if agent names it exactly.
+    if ora_names and labels_match(hyp, ora_names[0]):
+        return {
+            "correct": True,
+            "score": 0.85,
+            "match_mode": "top_ora_pathway",
+            "matched_label": ora_names[0],
+        }
+
+    return {
+        "correct": False,
+        "score": 0.0,
+        "match_mode": "no_match",
+        "matched_label": None,
+    }

examples/pathway_agent_loop.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# OpenAI tool-calling agent for pathway_analysis_env (in-process orchestrator).
+#
+# Usage:
+#   export OPENAI_API_KEY=...
+#   PYTHONPATH=src:envs uv run python examples/pathway_agent_loop.py \
+#       --case toy_case_001.json
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+
+from pathway_analysis_env.agent_openai_tools import (
+    OPENAI_TOOLS,
+    observation_to_tool_result_content,
+    tool_call_to_pathway_action,
+)
+from pathway_analysis_env.models import PathwayAction
+from pathway_analysis_env.server.pathway_environment import PathwayEnvironment
+
+
+SYSTEM_PROMPT = """You are a computational biologist agent operating a pathway analysis environment.
+
+Required workflow (eval mode):
+1. understand_experiment_design and/or inspect_dataset — learn groups and sample layout.
+2. run_differential_expression — set reference (baseline) vs alternate (treatment) conditions.
+3. run_pathway_enrichment — ORA on DE genes (do not pass a custom gene_list).
+4. Optionally compare_pathways between two top pathway names.
+5. submit_answer — one pathway hypothesis string supported by ORA.
+
+Rules:
+- Never guess without running DE and ORA first.
+- Use condition names exactly as returned in available_conditions.
+- For submit_answer, name a specific pathway (e.g. from top_pathways), not a long essay.
+"""
+
+
+async def run_episode(
+    case_file: str,
+    model: str,
+    max_turns: int,
+    *,
+    strict: bool,
+) -> dict:
+    try:
+        from openai import AsyncOpenAI
+    except ImportError as exc:
+        raise SystemExit("Install openai: uv add openai") from exc
+
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("Warning: OPENAI_API_KEY not set", file=sys.stderr)
+
+    client = AsyncOpenAI()
+    env = PathwayEnvironment(case_file=case_file)
+    obs = env.reset(orchestrator_mode=True, strict=strict)
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": (
+                f"Episode started for case {case_file}. "
+                f"Conditions: {obs.available_conditions}. "
+                f"{obs.message}"
+            ),
+        },
+    ]
+
+    for turn in range(max_turns):
+        response = await client.chat.completions.create(
+            model=model,
+            messages=messages,
+            tools=OPENAI_TOOLS,
+            tool_choice="auto",
+        )
+        msg = response.choices[0].message
+        if not msg.tool_calls:
+            messages.append({"role": "assistant", "content": msg.content or ""})
+            if env.state.is_done:
+                break
+            continue
+
+        messages.append(msg.model_dump())
+        for tc in msg.tool_calls:
+            action = tool_call_to_pathway_action(
+                name=tc.function.name,
+                arguments_json=tc.function.arguments,
+            )
+            step_obs = env.step(action)
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": observation_to_tool_result_content(step_obs),
+                }
+            )
+            if step_obs.done:
+                return {
+                    "turns": turn + 1,
+                    "done": True,
+                    "episode_outcome": env.episode_outcome,
+                    "last_message": step_obs.message,
+                    "steps": env.state.step_count,
+                }
+
+    return {
+        "turns": max_turns,
+        "done": env.state.is_done,
+        "episode_outcome": env.episode_outcome,
+        "steps": env.state.step_count,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="LLM agent on pathway_analysis_env")
+    parser.add_argument("--case", default="toy_case_001.json")
+    parser.add_argument("--model", default="gpt-4o-mini")
+    parser.add_argument("--max-turns", type=int, default=24)
+    parser.add_argument("--strict", action="store_true")
+    args = parser.parse_args()
+    result = asyncio.run(
+        run_episode(args.case, args.model, args.max_turns, strict=args.strict)
+    )
+    print(json.dumps(result, indent=2))
+    outcome = result.get("episode_outcome") or {}
+    if outcome.get("correct"):
+        sys.exit(0)
+    sys.exit(1 if result.get("done") else 2)
+
+
+if __name__ == "__main__":
+    main()

tests/envs/test_pathway_agent_tools.py

@@ -0,0 +1,77 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+import json
+
+from pathway_analysis_env.agent_openai_tools import (
+    observation_to_tool_result_content,
+    tool_call_to_pathway_action,
+    truncate_observation_payload,
+)
+
+
+def test_tool_call_with_null_arguments_does_not_crash():
+    """Models sometimes emit the JSON literal ``null`` for tool arguments.
+
+    ``json.loads("null")`` returns ``None``; the mapper must treat that as
+    empty args instead of raising ``AttributeError`` on ``args.get(...)``.
+    """
+    action = tool_call_to_pathway_action(
+        name="run_differential_expression", arguments_json="null"
+    )
+    assert action.action_type == "run_differential_expression"
+    assert action.condition_a is None
+    assert action.condition_b is None
+
+
+def test_tool_call_with_empty_arguments():
+    action = tool_call_to_pathway_action(name="inspect_dataset", arguments_json="")
+    assert action.action_type == "inspect_dataset"
+
+
+def test_tool_call_with_mapping_arguments():
+    action = tool_call_to_pathway_action(
+        name="submit_answer", arguments_json={"hypothesis": "MAPK signaling"}
+    )
+    assert action.action_type == "submit_answer"
+    assert action.hypothesis == "MAPK signaling"
+
+
+def test_tool_call_normal_json_arguments():
+    action = tool_call_to_pathway_action(
+        name="run_differential_expression",
+        arguments_json='{"condition_a": "control", "condition_b": "treated"}',
+    )
+    assert action.condition_a == "control"
+    assert action.condition_b == "treated"
+
+
+def test_truncate_observation_payload_caps_long_lists():
+    payload = {
+        "message": "ok",
+        "de_genes": [{"gene": f"G{i}"} for i in range(100)],
+        "pathway_enrichment": [{"pathway": f"P{i}"} for i in range(50)],
+        "trace_path": "/tmp/some/local/trace.html",
+    }
+    out = truncate_observation_payload(payload)
+    assert len(out["de_genes"]) == 30
+    assert len(out["pathway_enrichment"]) == 20
+    assert "trace_path" not in out
+    assert "_truncation_note" in out
+
+
+def test_truncate_observation_payload_keeps_short_lists():
+    payload = {"de_genes": [{"gene": "G1"}], "message": "ok"}
+    out = truncate_observation_payload(payload)
+    assert len(out["de_genes"]) == 1
+    assert "_truncation_note" not in out
+
+
+def test_observation_serialization_truncates_by_default():
+    payload = {"de_genes": [{"gene": f"G{i}"} for i in range(100)], "message": "ok"}
+    serialized = observation_to_tool_result_content(payload)
+    restored = json.loads(serialized)
+    assert len(restored["de_genes"]) == 30
+
+    full = observation_to_tool_result_content(payload, truncate=False)
+    assert len(json.loads(full)["de_genes"]) == 100

tests/envs/test_pathway_analysis_env.py

@@ -0,0 +1,335 @@
+# 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.
+
+"""Tests for pathway_analysis_env (DE, ORA, compare, expert, trace)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from pathway_analysis_env.models import PathwayAction
+from pathway_analysis_env.server.analysis import (
+    adjust_pvalues_bh,
+    build_sample_metadata,
+    ora_fisher,
+    overlap_genes_across_top_pathways,
+    pydeseq2_available,
+    run_deseq2_contrast,
+    validate_counts_case,
+)
+from pathway_analysis_env.server.pathway_environment import (
+    DATA_DIR,
+    PathwayEnvironment,
+    load_case,
+)
+
+requires_pydeseq2 = pytest.mark.skipif(
+    not pydeseq2_available(),
+    reason="PyDESeq2 required for pathway pipeline tests",
+)
+
+
+def test_set_case_file():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.set_case_file("toy_case_legacy.json")
+    assert env._case_file == "toy_case_legacy.json"
+
+
+def test_load_pipeline_case():
+    case = load_case("toy_case_001.json")
+    assert "counts" in case
+    assert "pathway_genes" in case
+    assert case["true_pathway"] == "MAPK signaling"
+
+
+def test_load_gse235417_case_is_pipeline_mode():
+    case = load_case("gse235417_case.json")
+    assert "counts_file" in case
+    assert "sample_ids" in case
+    assert "sample_metadata" in case
+    assert case["default_contrast"]["reference"] == "baseline"
+    assert case["default_contrast"]["alternate"] == "resistant"
+
+
+@requires_pydeseq2
+def test_deseq2_mapk_case():
+    case = json.loads((DATA_DIR / "toy_case_001.json").read_text(encoding="utf-8"))
+    from pathway_analysis_env.server.analysis import (
+        build_sample_metadata,
+        counts_dict_to_samples_by_genes,
+    )
+
+    cdf = counts_dict_to_samples_by_genes(case["counts"], case["sample_ids"])
+    meta = build_sample_metadata(case["sample_ids"], case["sample_metadata"])
+    rows, err = run_deseq2_contrast(
+        cdf,
+        meta,
+        case["default_contrast"]["alternate"],
+        case["default_contrast"]["reference"],
+    )
+    assert err is None
+    top = [r["gene"] for r in rows[:5]]
+    assert "DUSP6" in top or "FOS" in top
+
+
+def test_ora_fisher_structure():
+    universe = ["A", "B", "C", "D", "E", "F"]
+    pathways = {"P1": ["A", "B", "C"], "P2": ["C", "D"]}
+    de = ["A", "B", "C"]
+    ora = ora_fisher(de, pathways, universe, min_pathway_genes=2)
+    assert len(ora) == 2
+    assert ora[0]["pathway"] in ("P1", "P2")
+    assert "q_value" in ora[0]
+
+
+def test_adjust_pvalues_bh_matches_scipy():
+    ps = [0.01, 0.05, 0.1]
+    q = adjust_pvalues_bh(ps)
+    assert len(q) == 3
+    assert all(0.0 <= x <= 1.0 for x in q)
+
+
+def test_validate_counts_case():
+    assert validate_counts_case({}) is None
+    bad = {
+        "counts": {"G1": [1, 2], "G2": [1]},
+        "sample_ids": ["a", "b"],
+    }
+    assert validate_counts_case(bad) is not None
+
+
+def test_build_sample_metadata_missing_sample():
+    with pytest.raises(ValueError, match="missing"):
+        build_sample_metadata(["S1", "S2"], {"S1": "a"})
+
+
+def test_understand_experiment_design_summary():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset()
+    obs = env.step(PathwayAction(action_type="understand_experiment_design"))
+    assert obs.experiment_design
+    assert obs.experiment_design.get("samples_per_condition")
+    assert env.state.design_understood is True
+    assert env.state.validated_reference is None
+
+
+def test_understand_experiment_design_legacy_graceful():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset()
+    obs = env.step(PathwayAction(action_type="understand_experiment_design"))
+    design = obs.experiment_design or {}
+    assert design.get("legacy_mode") is True
+    assert design.get("sample_level_metadata_available") is False
+    assert design.get("samples_per_condition") is None
+    assert design.get("conditions") == ["control", "treated"]
+    assert "legacy" in obs.message.lower()
+
+
+def test_inspect_dataset_legacy_graceful():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset()
+    obs = env.step(PathwayAction(action_type="inspect_dataset"))
+    meta = obs.metadata or {}
+    assert meta.get("legacy_mode") is True
+    assert meta.get("sample_level_metadata_available") is False
+    assert meta.get("sample_ids") == []
+    assert "static_top_genes" not in meta
+    assert "static_top_pathways" not in meta
+    assert "legacy" in obs.message.lower()
+
+
+def test_inspect_legacy_debug_mode_shows_static_lists():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset(eval_mode=False)
+    obs = env.step(PathwayAction(action_type="inspect_dataset"))
+    meta = obs.metadata or {}
+    assert meta.get("static_top_genes")
+    assert meta.get("static_top_pathways")
+
+
+def test_state_never_exposes_true_pathway():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset()
+    assert "true_pathway" not in env.state.model_dump()
+
+
+def test_submit_blocked_without_de_in_eval_mode():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset()
+    obs = env.step(
+        PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling")
+    )
+    assert obs.metadata.get("failure_code") == "submit_prerequisite_de"
+    assert obs.done is False
+
+
+def test_gene_list_blocked_in_eval_mode():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset()
+    env.step(PathwayAction(action_type="run_differential_expression"))
+    obs = env.step(
+        PathwayAction(
+            action_type="run_pathway_enrichment",
+            gene_list=["DUSP6", "FOS"],
+        )
+    )
+    assert obs.metadata.get("failure_code") == "ora_gene_list_blocked"
+
+
+@requires_pydeseq2
+def test_understand_validated_contrast_matches_explicit_de():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset()
+    u = env.step(
+        PathwayAction(
+            action_type="understand_experiment_design",
+            condition_a="control",
+            condition_b="treated",
+        )
+    )
+    assert u.experiment_design and u.experiment_design.get("validated_contrast")
+    assert env.state.validated_reference == "control"
+    assert env.state.validated_alternate == "treated"
+    a = env.step(
+        PathwayAction(
+            action_type="run_differential_expression",
+            condition_a="control",
+            condition_b="treated",
+        )
+    )
+    env2 = PathwayEnvironment(case_file="toy_case_001.json")
+    env2.reset()
+    env2.step(
+        PathwayAction(
+            action_type="understand_experiment_design",
+            condition_a="control",
+            condition_b="treated",
+        )
+    )
+    b = env2.step(PathwayAction(action_type="run_differential_expression"))
+    assert a.de_genes and b.de_genes
+    assert [r.get("gene") for r in a.de_genes[:10]] == [r.get("gene") for r in b.de_genes[:10]]
+
+
+def test_no_step_after_episode_done():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset()
+    env.step(PathwayAction(action_type="run_differential_expression"))
+    env.step(PathwayAction(action_type="run_pathway_enrichment"))
+    env.step(PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling"))
+    late = env.step(PathwayAction(action_type="inspect_dataset"))
+    assert late.done
+    assert late.metadata.get("error") == "episode_done"
+    assert late.metadata.get("failure_code") == "episode_already_done"
+
+
+def test_overlap_summary():
+    ora = [
+        {
+            "pathway": "a",
+            "p_value": 0.01,
+            "overlap_genes": ["G1", "G2"],
+        },
+        {
+            "pathway": "b",
+            "p_value": 0.02,
+            "overlap_genes": ["G2", "G3"],
+        },
+    ]
+    ov = overlap_genes_across_top_pathways(ora, top_k=2)
+    assert "G2" in ov["genes_supporting_multiple_top_pathways"]
+
+
+@requires_pydeseq2
+def test_episode_pipeline_success():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    obs0 = env.reset(episode_id="ep-test-1")
+    assert obs0.metadata.get("pipeline_mode") is True
+    assert obs0.trace_path
+
+    a = PathwayAction(
+        action_type="run_differential_expression",
+        condition_a="control",
+        condition_b="treated",
+    )
+    obs1 = env.step(a)
+    assert obs1.de_genes
+    assert obs1.top_genes
+
+    b = PathwayAction(action_type="run_pathway_enrichment")
+    obs2 = env.step(b)
+    assert obs2.pathway_enrichment
+    assert "MAPK signaling" in obs2.top_pathways[:3]
+    assert obs2.overlap_summary is not None
+
+    c = PathwayAction(
+        action_type="compare_pathways",
+        pathway_a="MAPK signaling",
+        pathway_b="ERK cascade",
+    )
+    obs3 = env.step(c)
+    assert obs3.pathway_comparison
+    assert "shared_de_support" in obs3.pathway_comparison
+
+    obs4 = env.step(
+        PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling")
+    )
+    assert obs4.done
+    assert obs4.metadata.get("correct") is None
+    assert env.episode_outcome is not None
+    assert env.episode_outcome.get("correct") is True
+
+
+def test_legacy_fixture():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    obs0 = env.reset()
+    assert obs0.metadata.get("pipeline_mode") is False
+    env.step(PathwayAction(action_type="run_differential_expression"))
+    env.step(PathwayAction(action_type="run_pathway_enrichment"))
+    fin = env.step(
+        PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling")
+    )
+    assert fin.done
+    assert env.episode_outcome and env.episode_outcome.get("correct") is True
+
+
+def test_orchestrator_mode_exposes_correct_metadata():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset(orchestrator_mode=True)
+    env.step(PathwayAction(action_type="run_differential_expression"))
+    env.step(PathwayAction(action_type="run_pathway_enrichment"))
+    fin = env.step(
+        PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling")
+    )
+    assert fin.metadata.get("correct") is True
+
+
+@requires_pydeseq2
+def test_strict_invalid_counts_matrix():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset(strict=True)
+    env._case["counts"]["DUSP6"] = [1, 2]
+    obs = env.step(
+        PathwayAction(
+            action_type="run_differential_expression",
+            condition_a="control",
+            condition_b="treated",
+        )
+    )
+    assert obs.done and obs.metadata.get("strict_failure") is True
+    assert obs.metadata.get("failure_code") == "de_invalid_counts_matrix"
+
+
+@requires_pydeseq2
+def test_strict_mode_missing_contrast():
+    env = PathwayEnvironment(case_file="toy_case_no_default.json")
+    env.reset(strict=True)
+    obs = env.step(PathwayAction(action_type="run_differential_expression"))
+    assert obs.done is True
+    assert obs.metadata.get("strict_failure") is True
+    assert obs.metadata.get("failure_code") == "de_missing_contrast"

tests/envs/test_pathway_case_loader.py

@@ -0,0 +1,49 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import json
+
+from pathway_analysis_env.server.case_loader import (
+    CASE_SECRET_KEYS,
+    load_case_file,
+    strip_case_secrets,
+)
+from pathway_analysis_env.server.pathway_environment import DATA_DIR, PathwayEnvironment
+from pathway_analysis_env.models import PathwayAction
+
+
+def test_strip_case_secrets():
+    raw = {
+        "case_id": "x",
+        "true_pathway": "MAPK signaling",
+        "expected_keywords": ["mapk"],
+        "counts": {"G1": [1, 2]},
+    }
+    pub = strip_case_secrets(raw)
+    for k in CASE_SECRET_KEYS:
+        assert k not in pub
+    assert "counts" in pub
+
+
+def test_reset_agent_safe_case_has_no_secrets_in_memory():
+    env = PathwayEnvironment(case_file="toy_case_001.json")
+    env.reset(eval_mode=True, orchestrator_mode=False)
+    dumped = json.dumps(env._case)
+    assert "true_pathway" not in dumped
+
+
+def test_episode_observation_no_correct_without_orchestrator():
+    env = PathwayEnvironment(case_file="toy_case_legacy.json")
+    env.reset()
+    env.step(PathwayAction(action_type="run_differential_expression"))
+    env.step(PathwayAction(action_type="run_pathway_enrichment"))
+    fin = env.step(
+        PathwayAction(action_type="submit_answer", hypothesis="MAPK signaling")
+    )
+    assert fin.metadata.get("correct") is None
+    assert env.episode_outcome.get("correct") is True
+
+
+def test_load_case_file_roundtrip():
+    case, secrets = load_case_file(DATA_DIR, "toy_case_001.json", agent_safe=False)
+    assert secrets["true_pathway"] == "MAPK signaling"
+    assert case["case_id"]

tests/envs/test_pathway_scoring.py

@@ -0,0 +1,100 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+from pathway_analysis_env.server.scoring import (
+    is_unknown_ground_truth,
+    KEYWORD_BASE_SCORE,
+    labels_match,
+    score_submission,
+)
+
+
+def test_labels_match_fuzzy():
+    assert labels_match("MAPK signaling", "mapk signaling")
+    assert labels_match(
+        "Estrogen Response Early",
+        "MSigDB_Hallmark_2020: Estrogen Response Early",
+    )
+
+
+def test_score_exact_pathway():
+    out = score_submission(
+        "MAPK signaling",
+        true_pathway="MAPK signaling",
+        pathway_gene_set_names=["MAPK signaling", "PI3K-Akt signaling"],
+        top_ora_pathways=["ERK cascade"],
+    )
+    assert out["correct"] is True
+    assert out["match_mode"] == "pathway_label"
+
+
+def test_score_keywords_geo():
+    out = score_submission(
+        "Strong estrogen response hallmark",
+        true_pathway="Unknown (GEO benchmark)",
+        expected_keywords=["estrogen", "ESR1"],
+        top_ora_pathways=[],
+    )
+    assert out["correct"] is True
+    assert out["match_mode"] == "expected_keywords"
+
+
+def test_unknown_ground_truth():
+    assert is_unknown_ground_truth("Unknown (GEO benchmark)")
+
+
+def test_distractor_pathway_label_not_credited():
+    """Naming a distractor pathway defined in the case must not score 1.0.
+
+    Regression guard for a reward-hacking surface: previously any pathway
+    gene-set name present in the case (or any top ORA hit) matched as a
+    ``pathway_label`` and earned full credit.
+    """
+    out = score_submission(
+        "PI3K-Akt signaling",
+        true_pathway="MAPK signaling",
+        pathway_gene_set_names=["MAPK signaling", "ERK cascade", "PI3K-Akt signaling"],
+        top_ora_pathways=["MAPK signaling", "ERK cascade", "PI3K-Akt signaling"],
+    )
+    assert out["correct"] is False
+    assert out["score"] == 0.0
+    assert out["match_mode"] == "no_match"
+
+
+def test_top_ora_hit_not_credited_when_truth_known():
+    """A top ORA hit that is not the true pathway must not earn credit."""
+    out = score_submission(
+        "ERK cascade",
+        true_pathway="MAPK signaling",
+        top_ora_pathways=["ERK cascade", "MAPK signaling"],
+    )
+    assert out["correct"] is False
+    assert out["score"] == 0.0
+
+
+def test_true_pathway_alias_credited():
+    """Explicit aliases of the true pathway earn full credit."""
+    out = score_submission(
+        "MAPK/ERK pathway",
+        true_pathway="MAPK signaling",
+        true_pathway_aliases=["MAPK/ERK pathway", "RAS-MAPK"],
+    )
+    assert out["correct"] is True
+    assert out["score"] == 1.0
+    assert out["match_mode"] == "pathway_label"
+
+
+def test_keyword_score_normalized_above_base():
+    """A correct GEO answer scores on a scale comparable to exact matches.
+
+    A single keyword hit out of several should land at or above the base
+    score, not collapse to a small fraction like 1/5 = 0.2.
+    """
+    out = score_submission(
+        "estrogen response",
+        true_pathway="Unknown (GEO benchmark)",
+        expected_keywords=["estrogen", "ESR1", "fulvestrant", "ER", "hormone"],
+    )
+    assert out["correct"] is True
+    assert out["score"] >= KEYWORD_BASE_SCORE
+    assert out["match_mode"] == "expected_keywords"