local-update

README.md

@@ -43,13 +43,3 @@ openenv validate http://127.0.0.1:8000
 - `task_buffer`: pending tasks with estimated duration and hidden complexity
 - `flow_score`, `social_debt`, `calendar_churn`: core scoring metrics
 - `current_slot`, `current_time`, `recovery_state`, `mute_comms`: live execution state
-
-## Built-in benchmark tasks
-
-Set `TASK_NAME` to select a deterministic scenario before reset. Available tasks:
-
-- `quiet-morning`: high-noise start where muting comms early and protecting focus is rewarded
-- `meeting-surgery`: fragmented calendar where selective meeting moves should improve flow
-- `delivery-triage`: constrained delivery day with hidden task complexity and tighter tradeoffs
-
-Each task has a grader in [benchmark_tasks.py](/C:/Users/arshi/OneDrive/Desktop/idk/engineer-manager/benchmark_tasks.py:1). The environment also exposes task metadata and the current grader score in `observation.metadata.episode_metrics.grader_score`.

benchmark_tasks.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass
-from typing import Any, Callable
-
-from focus_resource_env import DEEP_WORK, EMPTY, MEETING, FocusResourceEnv, Task
-
-
-StepRecord = dict[str, Any]
-TaskSetup = Callable[[FocusResourceEnv], None]
-TaskGrader = Callable[[list[StepRecord]], float]
-
-
-def _reset_state(env: FocusResourceEnv) -> None:
-    env.timeline[:] = EMPTY
-    env.meeting_meta = {}
-    env.task_buffer = []
-    env.current_slot = 0
-    env.current_work_streak_slots = 0
-    env.recovery_remaining = 0
-    env.mute_comms = False
-    env.social_debt = 0.0
-    env.calendar_churn = 0
-    env.flow_score = 0.0
-    env.last_executed_kind = EMPTY
-    env.interruptions = 0
-    env.invalid_actions = 0
-
-
-def _set_meeting(
-    env: FocusResourceEnv,
-    *,
-    start: int,
-    length: int,
-    priority: int,
-    meeting_id: int,
-) -> None:
-    env._place_meeting(start, length, priority, meeting_id)
-
-
-def _normalized_total_score(env: FocusResourceEnv) -> float:
-    max_score = max(1.0, (env.timeline_length * 0.5) ** 2)
-    return min(1.0, max(0.0, env._total_score() / max_score))
-
-
-def setup_quiet_morning(env: FocusResourceEnv) -> None:
-    _reset_state(env)
-    env.distraction_risk = 0.65
-    env.task_buffer = [
-        Task(duration=2, hidden_complexity=1.0),
-        Task(duration=3, hidden_complexity=1.0),
-        Task(duration=2, hidden_complexity=1.25),
-    ]
-    _set_meeting(env, start=5, length=1, priority=4, meeting_id=1)
-    _set_meeting(env, start=7, length=1, priority=3, meeting_id=2)
-
-
-def setup_meeting_surgery(env: FocusResourceEnv) -> None:
-    _reset_state(env)
-    env.distraction_risk = 0.10
-    env.task_buffer = [
-        Task(duration=2, hidden_complexity=1.0),
-        Task(duration=2, hidden_complexity=1.25),
-        Task(duration=1, hidden_complexity=1.0),
-    ]
-    _set_meeting(env, start=1, length=1, priority=2, meeting_id=1)
-    _set_meeting(env, start=3, length=1, priority=2, meeting_id=2)
-    _set_meeting(env, start=6, length=2, priority=8, meeting_id=3)
-
-
-def setup_delivery_triage(env: FocusResourceEnv) -> None:
-    _reset_state(env)
-    env.distraction_risk = 0.25
-    env.task_buffer = [
-        Task(duration=3, hidden_complexity=1.5),
-        Task(duration=2, hidden_complexity=1.0),
-        Task(duration=1, hidden_complexity=1.0),
-    ]
-    _set_meeting(env, start=4, length=1, priority=9, meeting_id=1)
-    _set_meeting(env, start=8, length=2, priority=7, meeting_id=2)
-
-
-def grade_quiet_morning(trajectory: list[StepRecord]) -> float:
-    if not trajectory:
-        return 0.0
-    first_action = int(trajectory[0]["action"]["operation"])
-    final = trajectory[-1]["observation"]
-    final_score = float(final["flow_score"])
-    transition_count = sum(1 for step in trajectory if step["info"]["transition_info"]["interrupted"])
-    scheduled = sum(1 for slot in final["timeline"] if int(slot) == DEEP_WORK)
-
-    score = 0.0
-    score += 0.25 if first_action == 3 else 0.0
-    score += min(0.45, final_score / 6.0)
-    score += 0.15 if transition_count == 0 else 0.0
-    score += min(0.15, scheduled / 6.0)
-    return min(1.0, round(score, 4))
-
-
-def grade_meeting_surgery(trajectory: list[StepRecord]) -> float:
-    if not trajectory:
-        return 0.0
-    final = trajectory[-1]["observation"]
-    flow = float(final["flow_score"])
-    debt = float(final["social_debt"])
-    churn = int(final["calendar_churn"])
-    reschedules = sum(
-        1
-        for step in trajectory
-        if step["info"].get("action_info", {}).get("status") == "meeting_rescheduled"
-    )
-
-    score = 0.0
-    score += min(0.40, flow / 5.0)
-    score += 0.20 if reschedules >= 1 else 0.0
-    score += 0.20 if 1 <= churn <= 2 else max(0.0, 0.20 - (0.10 * abs(churn - 1)))
-    score += max(0.0, 0.20 - (debt / 8.0))
-    return min(1.0, round(score, 4))
-
-
-def grade_delivery_triage(trajectory: list[StepRecord]) -> float:
-    if not trajectory:
-        return 0.0
-    final = trajectory[-1]["observation"]
-    total = float(final["flow_score"]) - float(final["social_debt"]) - float(final["calendar_churn"])
-    invalid_actions = sum(
-        1
-        for step in trajectory
-        if str(step["info"].get("action_info", {}).get("status", "")).startswith("invalid")
-    )
-    remaining_tasks = len(final["task_buffer"])
-    scheduled = sum(1 for slot in final["timeline"] if int(slot) == DEEP_WORK)
-
-    score = 0.0
-    score += min(0.45, max(0.0, total) / 6.0)
-    score += min(0.25, scheduled / 8.0)
-    score += 0.20 if remaining_tasks <= 1 else 0.10 if remaining_tasks == 2 else 0.0
-    score += max(0.0, 0.10 - (0.05 * invalid_actions))
-    return min(1.0, round(score, 4))
-
-
-@dataclass(frozen=True)
-class TaskSpec:
-    name: str
-    description: str
-    setup: TaskSetup
-    grader: TaskGrader
-
-
-TASK_SPECS: dict[str, TaskSpec] = {
-    "quiet-morning": TaskSpec(
-        name="quiet-morning",
-        description="High-noise morning where the agent should mute comms early and protect an uninterrupted work block.",
-        setup=setup_quiet_morning,
-        grader=grade_quiet_morning,
-    ),
-    "meeting-surgery": TaskSpec(
-        name="meeting-surgery",
-        description="A fragmented calendar where the agent should improve flow with limited, selective meeting moves.",
-        setup=setup_meeting_surgery,
-        grader=grade_meeting_surgery,
-    ),
-    "delivery-triage": TaskSpec(
-        name="delivery-triage",
-        description="A constrained day with hidden task complexity where the agent must schedule useful work without spiraling debt.",
-        setup=setup_delivery_triage,
-        grader=grade_delivery_triage,
-    ),
-}
-
-
-DEFAULT_TASK_NAME = "quiet-morning"
-
-
-def get_task_spec(task_name: str | None) -> TaskSpec:
-    normalized = (task_name or os.getenv("TASK_NAME") or DEFAULT_TASK_NAME).strip()
-    return TASK_SPECS.get(normalized, TASK_SPECS[DEFAULT_TASK_NAME])
-
-
-def apply_task(env: FocusResourceEnv, task_name: str | None) -> TaskSpec:
-    spec = get_task_spec(task_name)
-    spec.setup(env)
-    return spec
-
-
-def grade_trajectory(task_name: str, trajectory: list[StepRecord]) -> float:
-    spec = get_task_spec(task_name)
-    return spec.grader(trajectory)

engineer-manager

@@ -1 +0,0 @@
-Subproject commit 40c10a7795c79e546608c011d3aff8820e1e479c

graders.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-
-TASK_NAMES = {
-    0: "quiet-morning",
-    1: "meeting-surgery",
-    2: "delivery-triage",
-}
-
-
-def _normalize_reward(reward: float) -> float:
-    return min(max(float(reward), 0.0), 1.0)
-
-
-def _state_task_id(state: Any) -> int | None:
-    if not isinstance(state, dict):
-        return None
-    task_id = state.get("task_id")
-    if isinstance(task_id, int):
-        return task_id
-    task_name = state.get("task_name")
-    if isinstance(task_name, str):
-        for index, name in TASK_NAMES.items():
-            if name == task_name:
-                return index
-    metadata = state.get("metadata")
-    if isinstance(metadata, dict):
-        nested_task_id = metadata.get("task_id")
-        if isinstance(nested_task_id, int):
-            return nested_task_id
-    return None
-
-
-def grade_task_0(state: dict, reward: float) -> float:
-    return _normalize_reward(reward if _state_task_id(state) == 0 else 0.0)
-
-
-def grade_task_1(state: dict, reward: float) -> float:
-    return _normalize_reward(reward if _state_task_id(state) == 1 else 0.0)
-
-
-def grade_task_2(state: dict, reward: float) -> float:
-    return _normalize_reward(reward if _state_task_id(state) == 2 else 0.0)
-
-
-GRADERS = {
-    "engineer_manager_task_0": grade_task_0,
-    "engineer_manager_task_1": grade_task_1,
-    "engineer_manager_task_2": grade_task_2,
-}
-
-
-TASK_GRADER_PAIRS = [
-    ("engineer_manager_task_0", grade_task_0),
-    ("engineer_manager_task_1", grade_task_1),
-    ("engineer_manager_task_2", grade_task_2),
-]
-
-
-__all__ = [
-    "grade_task_0",
-    "grade_task_1",
-    "grade_task_2",
-    "GRADERS",
-    "TASK_GRADER_PAIRS",
-]

inference.py

@@ -3,21 +3,15 @@ import json
 import math
 import os
 import textwrap
-from dataclasses import dataclass
 from typing import Any
 
 from openai import OpenAI
 from openenv.core.generic_client import GenericEnvClient
 
-try:
-    from server.engineer_manager_environment import EngineerManagerEnvironment
-except ImportError:
-    EngineerManagerEnvironment = None  # type: ignore[assignment]
-
 
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")
 LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 OPENENV_BASE_URL = os.getenv("OPENENV_BASE_URL")
 TASK_NAME = os.getenv("TASK_NAME", "engineer-manager")
@@ -52,52 +46,15 @@ SYSTEM_PROMPT = textwrap.dedent(
 ).strip()
 
 
-@dataclass
-class _EnvResult:
-    observation: dict[str, Any]
-    reward: float | None
-    done: bool
-
-
-class _InProcessEnvClient:
-    def __init__(self) -> None:
-        if EngineerManagerEnvironment is None:
-            raise RuntimeError("Bundled EngineerManagerEnvironment is unavailable")
-        self._env = EngineerManagerEnvironment()
-
-    async def connect(self) -> None:
-        return None
-
-    async def reset(self) -> _EnvResult:
-        observation = self._env.reset().model_dump()
-        return _EnvResult(
-            observation=dict(observation),
-            reward=float(observation.get("reward") or 0.0),
-            done=bool(observation.get("done")),
-        )
-
-    async def step(self, action: dict[str, int]) -> _EnvResult:
-        observation = self._env.step(type("Action", (), action)()).model_dump()
-        return _EnvResult(
-            observation=dict(observation),
-            reward=float(observation.get("reward") or 0.0),
-            done=bool(observation.get("done")),
-        )
-
-    async def close(self) -> None:
-        return None
+def _require_env(name: str, value: str | None) -> str:
+    if value:
+        return value
+    raise RuntimeError(f"Missing required environment variable: {name}")
 
 
 def _sanitize_field(value: Any) -> str:
-    return str(value).replace("\r", " ").replace("\n", " ").strip()
-
-
-def _format_error(error: str | None) -> str:
-    return "null" if error in (None, "") else _sanitize_field(error)
-
-
-def _action_to_text(action: dict[str, int]) -> str:
-    return f'{{"target_slot":{int(action["target_slot"])},"operation":{int(action["operation"])}}}'
+    text = str(value)
+    return text.replace("\r", " ").replace("\n", " ").strip()
 
 
 def log_start(task: str, env: str, model: str) -> None:
@@ -107,10 +64,17 @@ def log_start(task: str, env: str, model: str) -> None:
     )
 
 
-def log_step(step: int, action: str, reward: float, done: bool, error: str | None) -> None:
+def log_step(
+    step: int,
+    action: str,
+    reward: float,
+    done: bool,
+    error: str | None,
+) -> None:
+    error_text = "null" if error in (None, "") else _sanitize_field(error)
     print(
         f"[STEP] step={step} action={_sanitize_field(action)} reward={reward:.2f} "
-        f"done={str(done).lower()} error={_format_error(error)}",
+        f"done={str(done).lower()} error={error_text}",
         flush=True,
     )
 
@@ -127,12 +91,15 @@ def estimate_max_flow_score(timeline: list[int]) -> float:
     slot_count = len(timeline)
     if slot_count <= 0:
         return 1.0
-    return max(1.0, (slot_count * 0.5) ** 2)
+    hours = slot_count * 0.5
+    return max(1.0, hours * hours)
 
 
 def normalize_score(total_reward: float, observation: dict[str, Any]) -> float:
-    max_score = estimate_max_flow_score(observation.get("timeline") or [])
-    return min(1.0, max(0.0, total_reward / max_score))
+    timeline = observation.get("timeline") or []
+    max_score = estimate_max_flow_score(timeline)
+    normalized = total_reward / max_score
+    return min(1.0, max(0.0, normalized))
 
 
 def first_future_slot(observation: dict[str, Any], kind: int) -> int | None:
@@ -144,12 +111,17 @@ def first_future_slot(observation: dict[str, Any], kind: int) -> int | None:
     return None
 
 
+def first_future_empty_slot(observation: dict[str, Any]) -> int | None:
+    return first_future_slot(observation, 0)
+
+
 def build_user_prompt(
     step: int,
     observation: dict[str, Any],
     rewards: list[float],
     history: list[str],
 ) -> str:
+    timeline = observation.get("timeline") or []
     metadata = observation.get("metadata") or {}
     return textwrap.dedent(
         f"""
@@ -162,10 +134,10 @@ def build_user_prompt(
         social_debt={float(observation.get("social_debt", 0.0)):.2f}
         calendar_churn={int(observation.get("calendar_churn", 0))}
         recovery_state={int(observation.get("recovery_state", 0))}
-        timeline={json.dumps(observation.get("timeline", []), separators=(",", ":"))}
+        timeline={timeline}
         task_buffer={json.dumps(observation.get("task_buffer", []), separators=(",", ":"))}
         last_rewards={",".join(f"{reward:.2f}" for reward in rewards[-5:]) or "none"}
-        recent_history={json.dumps(history[-5:], separators=(",", ":"))}
+        recent_history={json.dumps(history[-5:])}
         last_metadata={json.dumps(metadata, separators=(",", ":"))}
         Choose the single next action.
         """
@@ -176,24 +148,15 @@ def choose_fallback_action(observation: dict[str, Any]) -> dict[str, int]:
     current_slot = int(observation.get("current_slot", 0))
     distraction_risk = float(observation.get("distraction_risk", 0.0))
     mute_comms = bool(observation.get("mute_comms", False))
-    recovery_state = int(observation.get("recovery_state", 0))
-    timeline = observation.get("timeline") or []
-
-    if current_slot == 0 and distraction_risk > 0.0 and not mute_comms:
+    if distraction_risk >= 0.2 and not mute_comms:
         return {"target_slot": current_slot, "operation": 3}
 
-    if recovery_state > 0:
-        return {"target_slot": current_slot, "operation": 0}
-
-    if current_slot < len(timeline) and int(timeline[current_slot]) == 0 and observation.get("task_buffer"):
-        return {"target_slot": current_slot, "operation": 1}
-
-    empty_slot = first_future_slot(observation, 0)
+    empty_slot = first_future_empty_slot(observation)
     if empty_slot is not None and observation.get("task_buffer"):
         return {"target_slot": empty_slot, "operation": 1}
 
     meeting_slot = first_future_slot(observation, 2)
-    if meeting_slot is not None:
+    if meeting_slot is not None and current_slot <= meeting_slot:
         return {"target_slot": meeting_slot, "operation": 2}
 
     return {"target_slot": current_slot, "operation": 0}
@@ -201,8 +164,8 @@ def choose_fallback_action(observation: dict[str, Any]) -> dict[str, int]:
 
 def coerce_action(raw_text: str, observation: dict[str, Any]) -> dict[str, int]:
     timeline = observation.get("timeline") or []
-    fallback = choose_fallback_action(observation)
     max_slot = max(0, len(timeline) - 1)
+    fallback = choose_fallback_action(observation)
     try:
         data = json.loads(raw_text)
         target_slot = int(data["target_slot"])
@@ -212,7 +175,8 @@ def coerce_action(raw_text: str, observation: dict[str, Any]) -> dict[str, int]:
 
     if operation not in {0, 1, 2, 3}:
         return fallback
-    return {"target_slot": min(max(target_slot, 0), max_slot), "operation": operation}
+    target_slot = min(max(target_slot, 0), max_slot)
+    return {"target_slot": target_slot, "operation": operation}
 
 
 def get_model_action(
@@ -239,81 +203,67 @@ def get_model_action(
         return choose_fallback_action(observation)
 
 
-async def create_env() -> Any:
+async def create_env() -> GenericEnvClient:
     if OPENENV_BASE_URL:
         env = GenericEnvClient(base_url=OPENENV_BASE_URL)
         await env.connect()
         return env
 
-    if LOCAL_IMAGE_NAME:
-        try:
-            return await GenericEnvClient.from_docker_image(LOCAL_IMAGE_NAME)
-        except Exception:
-            pass
-
-    env = _InProcessEnvClient()
-    await env.connect()
-    return env
+    image_name = _require_env("LOCAL_IMAGE_NAME", LOCAL_IMAGE_NAME)
+    return await GenericEnvClient.from_docker_image(image_name)
 
 
 async def main() -> None:
+    api_key = _require_env("HF_TOKEN", HF_TOKEN)
+    client = OpenAI(base_url=API_BASE_URL, api_key=api_key)
     env = None
     rewards: list[float] = []
     history: list[str] = []
     steps_taken = 0
     success = False
     score = 0.0
-    observation: dict[str, Any] = {}
-    completed = False
 
     log_start(TASK_NAME, BENCHMARK, MODEL_NAME)
 
     try:
-        client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY) if API_KEY else None
         env = await create_env()
         result = await env.reset()
         observation = dict(result.observation)
 
         for step in range(1, MAX_STEPS + 1):
             if result.done:
-                completed = True
                 break
 
-            if client is None:
-                action = choose_fallback_action(observation)
-            else:
-                action = get_model_action(client, step, observation, rewards, history)
-            action_text = _action_to_text(action)
-            step_error: str | None = None
+            action = get_model_action(client, step, observation, rewards, history)
+            result = await env.step(action)
+            observation = dict(result.observation)
 
-            try:
-                result = await env.step(action)
-                observation = dict(result.observation)
-                reward = float(result.reward or 0.0)
-                done = bool(result.done)
-                metadata = observation.get("metadata") or {}
-                step_error = metadata.get("last_action_error")
-            except Exception as exc:
-                reward = 0.0
-                done = True
-                step_error = str(exc)
+            reward = float(result.reward or 0.0)
+            done = bool(result.done)
+            metadata = observation.get("metadata") or {}
+            error = metadata.get("last_action_error")
 
             rewards.append(reward)
             steps_taken = step
-            log_step(step, action_text, reward, done, step_error)
+
+            action_text = (
+                f"target_slot={int(action['target_slot'])},operation={int(action['operation'])}"
+            )
+            log_step(step, action_text, reward, done, error)
+
             history.append(
-                f"step={step} action={action_text} reward={reward:.2f} error={_format_error(step_error)}"
+                f"step={step} action={action_text} reward={reward:.2f} "
+                f"flow={float(observation.get('flow_score', 0.0)):.2f} "
+                f"debt={float(observation.get('social_debt', 0.0)):.2f}"
             )
 
             if done:
-                completed = True
                 break
 
-        score = round(normalize_score(math.fsum(rewards), observation), 2)
-        success = completed and score >= 0.0
-    except Exception:
-        success = False
-        score = 0.0
+        total_reward = math.fsum(rewards)
+        score = normalize_score(total_reward, observation if "observation" in locals() else {})
+        score = round(score, 2)
+        success = score > 0.0
     finally:
         if env is not None:
             try:

openenv.yaml

@@ -4,82 +4,3 @@ type: space
 runtime: fastapi
 app: server.app:app
 port: 8000
-version: 0.1.0
-entry_point: server.engineer_manager_environment:EngineerManagerEnvironment
-api:
-  base_url: /
-  endpoints:
-    reset:
-      method: POST
-      path: /reset
-    step:
-      method: POST
-      path: /step
-    state:
-      method: GET
-      path: /state
-    tasks:
-      method: GET
-      path: /tasks
-    grader:
-      method: POST
-      path: /grader
-tasks:
-  - id: engineer_manager_task_0
-    task_id: quiet-morning
-    name: quiet-morning
-    difficulty: easy
-    description: High-noise morning where the agent should mute comms early and protect an uninterrupted work block.
-    max_steps: 32
-    reset_params:
-      task_id: 0
-    action_schema:
-      target_slot: integer slot index within the workday
-      operation: 0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms
-      task_id: quiet-morning
-    grader: graders:grade_task_0
-    graders:
-      - graders:grade_task_0
-    reward_range:
-      - 0.0
-      - 1.0
-  - id: engineer_manager_task_1
-    task_id: meeting-surgery
-    name: meeting-surgery
-    difficulty: medium
-    description: Fragmented calendar where selective meeting moves should improve flow.
-    max_steps: 32
-    reset_params:
-      task_id: 1
-    action_schema:
-      target_slot: integer slot index within the workday
-      operation: 0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms
-      task_id: meeting-surgery
-    grader: graders:grade_task_1
-    graders:
-      - graders:grade_task_1
-    reward_range:
-      - 0.0
-      - 1.0
-  - id: engineer_manager_task_2
-    task_id: delivery-triage
-    name: delivery-triage
-    difficulty: hard
-    description: Constrained delivery day with hidden task complexity and tighter tradeoffs.
-    max_steps: 32
-    reset_params:
-      task_id: 2
-    action_schema:
-      target_slot: integer slot index within the workday
-      operation: 0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms
-      task_id: delivery-triage
-    grader: graders:grade_task_2
-    graders:
-      - graders:grade_task_2
-    reward_range:
-      - 0.0
-      - 1.0
-graders:
-  - graders:grade_task_0
-  - graders:grade_task_1
-  - graders:grade_task_2

server/app.py

@@ -7,10 +7,6 @@ from textwrap import dedent
 import uvicorn
 from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse, Response
 from openenv.core.env_server.http_server import create_fastapi_app
-from pydantic import BaseModel
-
-from graders import grade_task_0, grade_task_1, grade_task_2
-from tasks import TASKS
 
 try:
     from ..models import EngineerManagerAction, EngineerManagerObservation
@@ -33,12 +29,6 @@ app = create_fastapi_app(
     max_concurrent_envs=2,
 )
 
-
-class GraderRequest(BaseModel):
-    task_id: str
-    state: dict
-    reward: float
-
 WEB_CSS = dedent(
     """\
     :root {
@@ -446,8 +436,6 @@ def web_js() -> PlainTextResponse:
 @app.get("/favicon.ico", include_in_schema=False)
 def favicon() -> Response:
     return Response(status_code=204)
-
-
 @app.get("/manifest.json", include_in_schema=False)
 def manifest() -> JSONResponse:
     return JSONResponse(
@@ -463,42 +451,6 @@ def manifest() -> JSONResponse:
     )
 
 
-@app.get("/tasks", include_in_schema=False)
-def tasks() -> list[dict]:
-    return TASKS
-
-
-@app.post("/grader", include_in_schema=False)
-def grader(request: GraderRequest) -> JSONResponse:
-    task_index_map = {
-        "quiet-morning": 0,
-        "engineer_manager_task_0": 0,
-        "meeting-surgery": 1,
-        "engineer_manager_task_1": 1,
-        "delivery-triage": 2,
-        "engineer_manager_task_2": 2,
-    }
-    grader_fn_map = {
-        "quiet-morning": grade_task_0,
-        "meeting-surgery": grade_task_1,
-        "delivery-triage": grade_task_2,
-        "engineer_manager_task_0": grade_task_0,
-        "engineer_manager_task_1": grade_task_1,
-        "engineer_manager_task_2": grade_task_2,
-    }
-    grader_fn = grader_fn_map.get(request.task_id)
-    if grader_fn is None:
-        return JSONResponse(
-            {"error": f"Unknown task_id: {request.task_id}", "score": 0.0, "passed": False},
-            status_code=400,
-        )
-    state = dict(request.state)
-    if "task_id" not in state or state["task_id"] is None:
-        state["task_id"] = task_index_map[request.task_id]
-    score = float(grader_fn(state, request.reward))
-    return JSONResponse({"task_id": request.task_id, "score": score, "passed": score >= 0.0, "reward": score})
-
-
 def run(host: str = "0.0.0.0", port: int = 8000) -> None:
     """Run the OpenEnv HTTP server."""
     uvicorn.run(app, host=host, port=port)

server/engineer_manager_environment.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 from uuid import uuid4
-import os
 
 from openenv.core.env_server.interfaces import Environment, EnvironmentMetadata
 from openenv.core.env_server.types import State
 
-from benchmark_tasks import TASK_SPECS, apply_task
 from focus_resource_env import FocusResourceEnv
 
 try:
@@ -30,18 +28,14 @@ class EngineerManagerEnvironment(
         end_hour: str = "17:00",
         distraction_risk: float = 0.15,
         seed: int | None = 7,
-        task_name: str | None = None,
     ) -> None:
         super().__init__()
         self._start_hour = start_hour
         self._end_hour = end_hour
         self._distraction_risk = distraction_risk
         self._seed = seed
-        self._task_name = task_name or os.getenv("TASK_NAME")
-        self._task_id = 0
         self._step_count = 0
         self._episode_id = str(uuid4())
-        self._trajectory: list[dict[str, object]] = []
         self._env = FocusResourceEnv(
             start_hour=start_hour,
             end_hour=end_hour,
@@ -53,30 +47,18 @@ class EngineerManagerEnvironment(
         self,
         seed: int | None = None,
         episode_id: str | None = None,
-        task_name: str | None = None,
-        task_id: int | None = None,
         **_: object,
     ) -> EngineerManagerObservation:
         self._seed = self._seed if seed is None else seed
-        task_names = ["quiet-morning", "meeting-surgery", "delivery-triage"]
-        if task_id is not None and 0 <= int(task_id) < len(task_names):
-            self._task_id = int(task_id)
-            self._task_name = task_names[self._task_id]
-        else:
-            self._task_name = task_name or self._task_name or os.getenv("TASK_NAME")
-            self._task_id = task_names.index(self._task_name) if self._task_name in task_names else 0
         self._episode_id = episode_id or str(uuid4())
         self._step_count = 0
-        self._trajectory = []
         self._env = FocusResourceEnv(
             start_hour=self._start_hour,
             end_hour=self._end_hour,
             distraction_risk=self._distraction_risk,
             seed=self._seed,
         )
-        self._env.reset()
-        apply_task(self._env, self._task_name)
-        return self._to_observation(self._env._observation(), reward=0.0, done=False)
+        return self._to_observation(self._env.reset(), reward=0.0, done=False)
 
     def step(
         self,
@@ -89,15 +71,6 @@ class EngineerManagerEnvironment(
             (action.target_slot, action.operation)
         )
         self._step_count += 1
-        self._trajectory.append(
-            {
-                "action": {"target_slot": int(action.target_slot), "operation": int(action.operation)},
-                "observation": observation,
-                "reward": float(reward),
-                "done": bool(done),
-                "info": info,
-            }
-        )
         return self._to_observation(observation, reward=reward, done=done, info=info)
 
     @property
@@ -114,8 +87,7 @@ class EngineerManagerEnvironment(
             name="Engineer Manager",
             description=(
                 "Manage a workday by scheduling deep work, rescheduling meetings, "
-                "and controlling communication noise. "
-                f"Available tasks: {', '.join(sorted(TASK_SPECS))}."
+                "and controlling communication noise."
             ),
             version="0.1.0",
         )
@@ -131,21 +103,5 @@ class EngineerManagerEnvironment(
         payload = dict(observation)
         payload["reward"] = reward
         payload["done"] = done
-        metadata = dict(info or {})
-        metadata["task_name"] = self._task_name
-        metadata["task_id"] = self._task_id
-        metadata["episode_metrics"] = {
-            "interruptions": int(self._env.interruptions),
-            "invalid_actions": int(self._env.invalid_actions),
-            "remaining_tasks": len(self._env.task_buffer),
-            "scheduled_work_slots": sum(1 for slot in self._env.timeline if int(slot) == 1),
-            "successful_reschedules": sum(
-                1
-                for step in self._trajectory
-                if step["info"].get("action_info", {}).get("status") == "meeting_rescheduled"
-            ),
-            "total_score": float(self._env._total_score()),
-            "grader_score": min(max(float(reward or 0.0), 0.0), 1.0),
-        }
-        payload["metadata"] = metadata
+        payload["metadata"] = info or {}
         return EngineerManagerObservation.model_validate(payload)

tasks.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from benchmark_tasks import TASK_SPECS
-
-
-TASKS = [
-    {
-        "id": "engineer_manager_task_0",
-        "task_id": "quiet-morning",
-        "name": "quiet-morning",
-        "difficulty": "easy",
-        "description": TASK_SPECS["quiet-morning"].description,
-        "max_steps": 32,
-        "reset_params": {"task_id": 0},
-        "action_schema": {
-            "target_slot": "integer slot index within the workday",
-            "operation": "0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms",
-            "task_id": "quiet-morning",
-        },
-        "grader": "graders:grade_task_0",
-        "graders": ["graders:grade_task_0"],
-        "reward_range": [0.0, 1.0],
-    },
-    {
-        "id": "engineer_manager_task_1",
-        "task_id": "meeting-surgery",
-        "name": "meeting-surgery",
-        "difficulty": "medium",
-        "description": TASK_SPECS["meeting-surgery"].description,
-        "max_steps": 32,
-        "reset_params": {"task_id": 1},
-        "action_schema": {
-            "target_slot": "integer slot index within the workday",
-            "operation": "0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms",
-            "task_id": "meeting-surgery",
-        },
-        "grader": "graders:grade_task_1",
-        "graders": ["graders:grade_task_1"],
-        "reward_range": [0.0, 1.0],
-    },
-    {
-        "id": "engineer_manager_task_2",
-        "task_id": "delivery-triage",
-        "name": "delivery-triage",
-        "difficulty": "hard",
-        "description": TASK_SPECS["delivery-triage"].description,
-        "max_steps": 32,
-        "reset_params": {"task_id": 2},
-        "action_schema": {
-            "target_slot": "integer slot index within the workday",
-            "operation": "0=idle, 1=schedule work, 2=reschedule meeting, 3=toggle mute comms",
-            "task_id": "delivery-triage",
-        },
-        "grader": "graders:grade_task_2",
-        "graders": ["graders:grade_task_2"],
-        "reward_range": [0.0, 1.0],
-    },
-]
-
-
-TASK_ID_TO_INDEX = {task["task_id"]: index for index, task in enumerate(TASKS)}
-
-
-TASK_GRADER_PAIRS = [
-    ("engineer_manager_task_0", "graders:grade_task_0"),
-    ("engineer_manager_task_1", "graders:grade_task_1"),
-    ("engineer_manager_task_2", "graders:grade_task_2"),
-]
-
-
-__all__ = ["TASKS", "TASK_ID_TO_INDEX", "TASK_GRADER_PAIRS"]

validate-submission.sh

@@ -19,6 +19,13 @@ else
   RED='' GREEN='' YELLOW='' BLUE='' BOLD='' NC=''
 fi
 
+CURL_ARGS=(-s)
+case "$(uname -s 2>/dev/null || printf unknown)" in
+  MINGW*|MSYS*|CYGWIN*)
+    CURL_ARGS+=(--ssl-no-revoke)
+    ;;
+esac
+
 log()  { printf "[%s] %b\n" "$(date +%H:%M:%S)" "$*"; }
 pass() { log "${GREEN}${BOLD}PASS${NC} -- $1"; }
 fail() { log "${RED}${BOLD}FAIL${NC} -- $1"; }
@@ -84,7 +91,7 @@ fi
 pass "Environment is ready."
 
 log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
-HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
+HTTP_CODE=$(curl "${CURL_ARGS[@]}" -o /dev/null -w "%{http_code}" -X POST \
   -H "Content-Type: application/json" -d '{}' \
   "$PING_URL/reset" --max-time 20 || echo "000")