Prepare OpenEnv Space submission

Dockerfile

@@ -2,16 +2,20 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-RUN pip install --no-cache-dir \
-    fastapi \
-    numpy \
-    "openenv-core[core]" \
-    pydantic \
-    streamlit \
-    uvicorn
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PIP_NO_CACHE_DIR=1
+ENV ENABLE_WEB_INTERFACE=true
+
+COPY pyproject.toml README.md /app/
+COPY server /app/server
+COPY models.py __init__.py /app/
+
+RUN pip install --upgrade pip && \
+    pip install .
 
 COPY . /app
 
 EXPOSE 8000
 
-CMD ["python", "-m", "server.app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -6,7 +6,6 @@ colorTo: yellow
 sdk: docker
 pinned: false
 app_port: 8000
-base_path: /web
 tags:
   - openenv
   - scheduling

client.py

@@ -8,7 +8,10 @@ from openenv.core import EnvClient
 from openenv.core.client_types import StepResult
 from openenv.core.env_server.types import State
 
-from .models import EngineerManagerAction, EngineerManagerObservation
+try:
+    from .models import EngineerManagerAction, EngineerManagerObservation
+except ImportError:
+    from models import EngineerManagerAction, EngineerManagerObservation
 
 
 class EngineerManagerEnv(

inference.py

@@ -0,0 +1,277 @@
+import asyncio
+import json
+import math
+import os
+import textwrap
+from typing import Any
+
+from openai import OpenAI
+from openenv.core.generic_client import GenericEnvClient
+
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+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")
+BENCHMARK = os.getenv("BENCHMARK", "openenv")
+MAX_STEPS = int(os.getenv("MAX_STEPS", "32"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0.1"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "120"))
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are selecting actions for an environment that simulates an engineer-manager workday.
+    Return exactly one compact JSON object with integer keys:
+    {"target_slot": <int>, "operation": <int>}
+
+    Operations:
+    0 = idle
+    1 = schedule work at target_slot
+    2 = reschedule a meeting at target_slot
+    3 = toggle mute comms
+
+    Goals:
+    - Maximize sustained deep work flow_score.
+    - Avoid unnecessary social_debt and calendar_churn.
+    - Prefer scheduling work into future empty slots.
+    - Use reschedule_meeting only when it clearly helps.
+    - Toggle mute comms early if distractions are high and it is currently off.
+
+    Rules:
+    - target_slot must be within the timeline bounds.
+    - Return JSON only. No markdown. No explanation.
+    """
+).strip()
+
+
+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:
+    text = str(value)
+    return text.replace("\r", " ").replace("\n", " ").strip()
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(
+        f"[START] task={_sanitize_field(task)} env={_sanitize_field(env)} model={_sanitize_field(model)}",
+        flush=True,
+    )
+
+
+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={error_text}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
+    rewards_text = ",".join(f"{reward:.2f}" for reward in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.2f} rewards={rewards_text}",
+        flush=True,
+    )
+
+
+def estimate_max_flow_score(timeline: list[int]) -> float:
+    slot_count = len(timeline)
+    if slot_count <= 0:
+        return 1.0
+    hours = slot_count * 0.5
+    return max(1.0, hours * hours)
+
+
+def normalize_score(total_reward: float, observation: dict[str, Any]) -> float:
+    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:
+    timeline = observation.get("timeline") or []
+    current_slot = int(observation.get("current_slot", 0))
+    for index in range(current_slot, len(timeline)):
+        if int(timeline[index]) == kind:
+            return index
+    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"""
+        step={step}
+        current_slot={int(observation.get("current_slot", 0))}
+        current_time={observation.get("current_time", "unknown")}
+        mute_comms={bool(observation.get("mute_comms", False))}
+        distraction_risk={float(observation.get("distraction_risk", 0.0))}
+        flow_score={float(observation.get("flow_score", 0.0)):.2f}
+        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={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:])}
+        last_metadata={json.dumps(metadata, separators=(",", ":"))}
+        Choose the single next action.
+        """
+    ).strip()
+
+
+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))
+    if distraction_risk >= 0.2 and not mute_comms:
+        return {"target_slot": current_slot, "operation": 3}
+
+    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 and current_slot <= meeting_slot:
+        return {"target_slot": meeting_slot, "operation": 2}
+
+    return {"target_slot": current_slot, "operation": 0}
+
+
+def coerce_action(raw_text: str, observation: dict[str, Any]) -> dict[str, int]:
+    timeline = observation.get("timeline") or []
+    max_slot = max(0, len(timeline) - 1)
+    fallback = choose_fallback_action(observation)
+    try:
+        data = json.loads(raw_text)
+        target_slot = int(data["target_slot"])
+        operation = int(data["operation"])
+    except Exception:
+        return fallback
+
+    if operation not in {0, 1, 2, 3}:
+        return fallback
+    target_slot = min(max(target_slot, 0), max_slot)
+    return {"target_slot": target_slot, "operation": operation}
+
+
+def get_model_action(
+    client: OpenAI,
+    step: int,
+    observation: dict[str, Any],
+    rewards: list[float],
+    history: list[str],
+) -> dict[str, int]:
+    user_prompt = build_user_prompt(step, observation, rewards, history)
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+        )
+        content = (completion.choices[0].message.content or "").strip()
+        return coerce_action(content, observation)
+    except Exception:
+        return choose_fallback_action(observation)
+
+
+async def create_env() -> GenericEnvClient:
+    if OPENENV_BASE_URL:
+        env = GenericEnvClient(base_url=OPENENV_BASE_URL)
+        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
+
+    log_start(TASK_NAME, BENCHMARK, MODEL_NAME)
+
+    try:
+        env = await create_env()
+        result = await env.reset()
+        observation = dict(result.observation)
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            action = get_model_action(client, step, observation, rewards, history)
+            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 {}
+            error = metadata.get("last_action_error")
+
+            rewards.append(reward)
+            steps_taken = step
+
+            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} "
+                f"flow={float(observation.get('flow_score', 0.0)):.2f} "
+                f"debt={float(observation.get('social_debt', 0.0)):.2f}"
+            )
+
+            if done:
+                break
+
+        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:
+                await env.close()
+            except Exception:
+                pass
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyproject.toml

@@ -11,6 +11,7 @@ requires-python = ">=3.11"
 dependencies = [
     "fastapi>=0.135.0",
     "numpy>=2.0.0",
+    "openai>=1.0.0",
     "openenv-core[core]>=0.2.0",
     "pydantic>=2.0.0",
     "streamlit>=1.40.0",

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.135.0
+numpy>=2.0.0
+openai>=1.0.0
+openenv-core[core]>=0.2.0
+pydantic>=2.0.0
+streamlit>=1.40.0
+uvicorn>=0.30.0

server/app.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from textwrap import dedent
+
 import uvicorn
-from openenv.core import create_app
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse
+from openenv.core.env_server.http_server import create_fastapi_app
 
 try:
     from ..models import EngineerManagerAction, EngineerManagerObservation
@@ -19,14 +22,430 @@ except ImportError:
     from server.engineer_manager_environment import EngineerManagerEnvironment
 
 
-app = create_app(
+app = create_fastapi_app(
     EngineerManagerEnvironment,
     EngineerManagerAction,
     EngineerManagerObservation,
-    env_name="engineer-manager",
     max_concurrent_envs=2,
 )
 
+WEB_CSS = dedent(
+    """\
+    :root {
+      color-scheme: dark;
+      --bg: #07111f;
+      --panel: rgba(10, 21, 38, 0.88);
+      --panel-2: rgba(14, 28, 48, 0.96);
+      --line: rgba(124, 231, 255, 0.18);
+      --text: #eaf4ff;
+      --muted: #99abc7;
+      --accent: #7ce7ff;
+      --accent-2: #86f0ca;
+      --meeting: #f5c76a;
+      --empty: rgba(255, 255, 255, 0.06);
+      --danger: #ff8d8d;
+      --shell-max: 1180px;
+      --sidebar-width: 300px;
+      --content-min: 620px;
+    }
+    * { box-sizing: border-box; }
+    html {
+      min-height: 100%;
+      background: #07111f;
+    }
+    body {
+      margin: 0;
+      min-height: 100%;
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      color: var(--text);
+      background:
+        radial-gradient(circle at top, rgba(124, 231, 255, 0.12), transparent 30rem),
+        linear-gradient(180deg, #09111d 0%, #07111f 100%);
+    }
+    .shell {
+      width: min(100%, var(--shell-max));
+      margin: 0 auto;
+      padding: 32px 20px 40px;
+    }
+    .hero {
+      padding: 24px;
+      border: 1px solid var(--line);
+      border-radius: 24px;
+      background: linear-gradient(135deg, rgba(9, 20, 38, 0.95), rgba(12, 31, 54, 0.92));
+      box-shadow: 0 18px 48px rgba(0, 0, 0, 0.28);
+    }
+    .eyebrow {
+      color: var(--accent);
+      font-size: 12px;
+      letter-spacing: 0.18em;
+      text-transform: uppercase;
+      margin-bottom: 10px;
+    }
+    h1 {
+      margin: 0 0 10px;
+      font-size: clamp(2rem, 5vw, 3.8rem);
+      line-height: 0.95;
+    }
+    .sub {
+      margin: 0;
+      color: var(--muted);
+      max-width: 62ch;
+      line-height: 1.5;
+    }
+    .grid {
+      display: grid;
+      grid-template-columns: minmax(260px, var(--sidebar-width)) minmax(var(--content-min), 1fr);
+      align-items: start;
+      gap: 18px;
+      margin-top: 18px;
+    }
+    .panel {
+      border: 1px solid var(--line);
+      border-radius: 22px;
+      background: var(--panel);
+      box-shadow: 0 12px 36px rgba(0, 0, 0, 0.22);
+      backdrop-filter: blur(10px);
+    }
+    .panel-inner { padding: 18px; }
+    .section-title {
+      margin: 0 0 14px;
+      font-size: 0.92rem;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      color: var(--accent);
+    }
+    .metrics {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 12px;
+      margin-bottom: 16px;
+    }
+    .metric {
+      padding: 14px;
+      border-radius: 18px;
+      border: 1px solid var(--line);
+      background: var(--panel-2);
+    }
+    .metric small {
+      display: block;
+      color: var(--muted);
+      margin-bottom: 8px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      font-size: 0.7rem;
+    }
+    .metric strong {
+      font-size: 1.35rem;
+    }
+    label {
+      display: block;
+      margin-bottom: 10px;
+      color: var(--muted);
+      font-size: 0.92rem;
+    }
+    input, select, button {
+      width: 100%;
+      border-radius: 14px;
+      border: 1px solid var(--line);
+      background: rgba(255, 255, 255, 0.04);
+      color: var(--text);
+      padding: 12px 14px;
+      font: inherit;
+    }
+    button {
+      cursor: pointer;
+      transition: transform 120ms ease, background 120ms ease;
+      background: linear-gradient(135deg, rgba(124, 231, 255, 0.22), rgba(134, 240, 202, 0.16));
+    }
+    button:hover { transform: translateY(-1px); }
+    .actions {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 10px;
+      margin-top: 12px;
+    }
+    .actions button[data-op="0"] { grid-column: span 2; }
+    .timeline {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(58px, 1fr));
+      gap: 8px;
+    }
+    .slot {
+      border-radius: 16px;
+      min-height: 84px;
+      padding: 10px 8px;
+      border: 1px solid transparent;
+      background: var(--empty);
+      display: flex;
+      flex-direction: column;
+      justify-content: space-between;
+    }
+    .slot.current { border-color: var(--accent); box-shadow: 0 0 0 1px rgba(124, 231, 255, 0.25) inset; }
+    .slot.work { background: linear-gradient(180deg, rgba(124, 240, 202, 0.22), rgba(124, 240, 202, 0.10)); }
+    .slot.meeting { background: linear-gradient(180deg, rgba(245, 199, 106, 0.28), rgba(245, 199, 106, 0.10)); }
+    .slot small { color: var(--muted); }
+    .slot strong { font-size: 0.82rem; }
+    .task-list, pre {
+      margin: 0;
+      padding: 14px;
+      border-radius: 18px;
+      border: 1px solid var(--line);
+      background: rgba(255, 255, 255, 0.03);
+    }
+    .task-list li { margin: 0 0 8px; color: var(--muted); }
+    .task-list li:last-child { margin-bottom: 0; }
+    pre {
+      overflow: auto;
+      max-height: 260px;
+      color: #d7e6ff;
+    }
+    .details-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 16px;
+      margin-top: 16px;
+    }
+    .status {
+      margin-top: 12px;
+      min-height: 24px;
+      color: var(--muted);
+    }
+    .status.error { color: var(--danger); }
+    @media (max-width: 1040px) {
+      :root {
+        --content-min: 0px;
+      }
+      .metrics {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+      }
+    }
+    @media (max-width: 760px) {
+      .grid,
+      .metrics,
+      .details-grid {
+        grid-template-columns: 1fr;
+      }
+      .actions { grid-template-columns: 1fr; }
+      .actions button[data-op="0"] { grid-column: span 1; }
+    }
+    """
+)
+
+WEB_JS = dedent(
+    """\
+    const statusEl = document.getElementById("status");
+    const targetSlotEl = document.getElementById("targetSlot");
+    const timelineEl = document.getElementById("timeline");
+    const tasksEl = document.getElementById("tasks");
+    const payloadEl = document.getElementById("payload");
+    const metrics = {
+      time: document.getElementById("m-time"),
+      slot: document.getElementById("m-slot"),
+      flow: document.getElementById("m-flow"),
+      debt: document.getElementById("m-debt"),
+    };
+
+    function setStatus(message, isError = false) {
+      statusEl.textContent = message;
+      statusEl.className = isError ? "status error" : "status";
+    }
+
+    function kindLabel(value) {
+      if (value === 1) return "Deep Work";
+      if (value === 2) return "Meeting";
+      return "Open";
+    }
+
+    function renderObservation(response) {
+      const obs = response.observation || {};
+      metrics.time.textContent = obs.current_time ?? "-";
+      metrics.slot.textContent = String(obs.current_slot ?? "-");
+      metrics.flow.textContent = Number(obs.flow_score ?? 0).toFixed(2);
+      metrics.debt.textContent = Number(obs.social_debt ?? 0).toFixed(2);
+      targetSlotEl.max = Math.max(0, (obs.timeline || []).length - 1);
+
+      timelineEl.innerHTML = "";
+      (obs.timeline || []).forEach((value, index) => {
+        const slot = document.createElement("div");
+        slot.className = "slot " + (value === 1 ? "work" : value === 2 ? "meeting" : "");
+        if (index === obs.current_slot) slot.classList.add("current");
+        slot.innerHTML = "<small>Slot " + index + "</small><strong>" + kindLabel(value) + "</strong>";
+        timelineEl.appendChild(slot);
+      });
+
+      tasksEl.innerHTML = "";
+      const tasks = obs.task_buffer || [];
+      if (!tasks.length) {
+        const empty = document.createElement("li");
+        empty.textContent = "No queued tasks.";
+        tasksEl.appendChild(empty);
+      } else {
+        tasks.forEach((task, index) => {
+          const item = document.createElement("li");
+          item.textContent = "Task " + (index + 1) + ": " + task.duration + " slots, complexity " + task.hidden_complexity;
+          tasksEl.appendChild(item);
+        });
+      }
+
+      payloadEl.textContent = JSON.stringify(response, null, 2);
+    }
+
+    async function callJson(url, body) {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      const data = await response.json();
+      if (!response.ok) throw new Error(JSON.stringify(data));
+      return data;
+    }
+
+    async function resetEnv() {
+      setStatus("Resetting environment...");
+      try {
+        const data = await callJson("/reset", {});
+        renderObservation(data);
+        setStatus("Environment reset.");
+      } catch (error) {
+        setStatus("Reset failed: " + error.message, true);
+      }
+    }
+
+    async function stepEnv(operation) {
+      setStatus("Applying action...");
+      try {
+        const payload = {
+          action: {
+            target_slot: Number(targetSlotEl.value || 0),
+            operation: Number(operation),
+          },
+        };
+        const data = await callJson("/step", payload);
+        renderObservation(data);
+        setStatus("Action applied.");
+      } catch (error) {
+        setStatus("Action failed: " + error.message, true);
+      }
+    }
+
+    document.getElementById("resetBtn").addEventListener("click", resetEnv);
+    document.querySelectorAll("[data-op]").forEach((button) => {
+      button.addEventListener("click", () => stepEnv(button.dataset.op));
+    });
+
+    resetEnv();
+    """
+)
+
+WEB_PAGE = dedent(
+    """\
+    <!doctype html>
+    <html lang="en">
+    <head>
+      <meta charset="utf-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1">
+      <title>Engineer Manager</title>
+      <link rel="stylesheet" href="/assets/app.css">
+    </head>
+    <body>
+      <div class="shell">
+        <section class="hero">
+          <div class="eyebrow">Engineer Manager Simulator</div>
+          <h1>Run the day before the day runs you.</h1>
+          <p class="sub">This is a direct native UI for the Space. It talks to the environment API without the Gradio bridge, so it avoids the Hugging Face wrapper errors that were breaking the previous page.</p>
+        </section>
+
+        <div class="grid">
+          <aside class="panel">
+            <div class="panel-inner">
+              <h2 class="section-title">Controls</h2>
+              <label>Target slot
+                <input id="targetSlot" type="number" min="0" value="0">
+              </label>
+              <button id="resetBtn">Reset Environment</button>
+              <div class="actions">
+                <button data-op="0">Advance Time</button>
+                <button data-op="1">Schedule Work</button>
+                <button data-op="2">Move Meeting</button>
+                <button data-op="3">Mute Comms</button>
+              </div>
+              <div id="status" class="status">Ready.</div>
+            </div>
+          </aside>
+
+          <main class="panel">
+            <div class="panel-inner">
+              <div class="metrics">
+                <div class="metric"><small>Current Time</small><strong id="m-time">-</strong></div>
+                <div class="metric"><small>Current Slot</small><strong id="m-slot">-</strong></div>
+                <div class="metric"><small>Flow Score</small><strong id="m-flow">-</strong></div>
+                <div class="metric"><small>Social Debt</small><strong id="m-debt">-</strong></div>
+              </div>
+
+              <h2 class="section-title">Timeline</h2>
+              <div id="timeline" class="timeline"></div>
+
+              <div class="details-grid">
+                <section>
+                  <h2 class="section-title">Task Buffer</h2>
+                  <ul id="tasks" class="task-list"></ul>
+                </section>
+                <section>
+                  <h2 class="section-title">Last Response</h2>
+                  <pre id="payload">{}</pre>
+                </section>
+              </div>
+            </div>
+          </main>
+        </div>
+      </div>
+      <script src="/assets/app.js" defer></script>
+    </body>
+    </html>
+    """
+)
+
+
+@app.get("/", include_in_schema=False)
+def root() -> RedirectResponse:
+    return RedirectResponse(url="/web/")
+
+
+@app.get("/web", include_in_schema=False)
+def web_root() -> RedirectResponse:
+    return RedirectResponse(url="/web/")
+
+
+@app.get("/web/", include_in_schema=False)
+def web_ui() -> HTMLResponse:
+    return HTMLResponse(WEB_PAGE)
+
+
+@app.get("/assets/app.css", include_in_schema=False)
+def web_css() -> PlainTextResponse:
+    return PlainTextResponse(WEB_CSS, media_type="text/css")
+
+
+@app.get("/assets/app.js", include_in_schema=False)
+def web_js() -> PlainTextResponse:
+    return PlainTextResponse(WEB_JS, media_type="application/javascript")
+
+
+@app.get("/manifest.json", include_in_schema=False)
+def manifest() -> JSONResponse:
+    return JSONResponse(
+        {
+            "name": "Engineer Manager",
+            "short_name": "Engineer Manager",
+            "start_url": "/web/",
+            "display": "standalone",
+            "background_color": "#0b1224",
+            "theme_color": "#0b1224",
+            "icons": [],
+        }
+    )
+
 
 def run(host: str = "0.0.0.0", port: int = 8000) -> None:
     """Run the OpenEnv HTTP server."""