Add engineer manager app

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN pip install --no-cache-dir \
+    fastapi \
+    numpy \
+    "openenv-core[core]" \
+    pydantic \
+    streamlit \
+    uvicorn
+
+COPY . /app
+
+EXPOSE 8000
+
+CMD ["python", "-m", "server.app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,46 @@
+---
+title: Engineer Manager Environment Server
+emoji: "🗂️"
+colorFrom: yellow
+colorTo: yellow
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - scheduling
+  - reinforcement-learning
+---
+
+# Engineer Manager Environment
+
+`Engineer Manager` is an OpenEnv-compatible scheduling simulator for balancing deep work, meetings, and communication load across a workday.
+
+## What it exposes
+
+- `POST /reset` to start a fresh episode
+- `POST /step` to apply a scheduling action
+- `GET /state` for the current session state
+- `GET /schema` for the action and observation schemas
+- `GET /web` for the built-in OpenEnv web UI
+
+## Local usage
+
+```bash
+python -m server.app --port 8000
+openenv validate .
+openenv validate http://127.0.0.1:8000
+```
+
+## Action model
+
+- `target_slot`: target half-hour slot
+- `operation`: `0` idle, `1` schedule work, `2` reschedule meeting, `3` mute comms
+
+## Observation highlights
+
+- `timeline`: day plan encoded as empty/work/meeting slots
+- `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

__init__.py

@@ -0,0 +1,10 @@
+"""Engineer Manager OpenEnv package."""
+
+from .client import EngineerManagerEnv
+from .models import EngineerManagerAction, EngineerManagerObservation
+
+__all__ = [
+    "EngineerManagerAction",
+    "EngineerManagerEnv",
+    "EngineerManagerObservation",
+]

app.py

@@ -0,0 +1,606 @@
+from __future__ import annotations
+
+import time
+from typing import Dict, List, Optional
+
+import streamlit as st
+
+from focus_resource_env import (
+    DEEP_WORK,
+    EMPTY,
+    OP_IDLE,
+    OP_MUTE_COMMS,
+    OP_RESCHEDULE_MEETING,
+    FocusResourceEnv,
+    Task,
+)
+
+BLOCK_TYPES = ["Focus", "Meeting"]
+COMPLEXITY_OPTIONS = [1.0, 1.25, 1.5, 1.75]
+DEFAULT_TASK_NAMES = ["Architecture", "Review", "Execution"]
+
+
+def inject_styles() -> None:
+    theme_tokens = {
+        "__BG0__": "#050816",
+        "__BG1__": "#0b1224",
+        "__LINE__": "rgba(159, 184, 255, 0.16)",
+        "__TEXT__": "#edf3ff",
+        "__MUTED__": "#96a7cb",
+        "__ACCENT__": "#7ce7ff",
+        "__ACCENT2__": "#7cf0c5",
+        "__BUTTON_TEXT__": "#06131c",
+        "__METRIC_BG__": "linear-gradient(180deg, rgba(255,255,255,0.04), rgba(255,255,255,0.02))",
+        "__SHADOW__": "0 14px 40px rgba(0, 0, 0, 0.22)",
+        "__INPUT_BG__": "rgba(255,255,255,0.04)",
+        "__HERO_BG__": "linear-gradient(135deg, rgba(16, 26, 52, 0.94), rgba(11, 20, 38, 0.94))",
+    }
+    with open("styles.css", encoding="utf-8") as css_file:
+        css = css_file.read()
+    for key, value in theme_tokens.items():
+        css = css.replace(key, value)
+    st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+
+
+def friendly_error(exc: Exception) -> str:
+    if "end_hour must be after start_hour" in str(exc):
+        return "End time must be later than start time."
+    return "Those control panel settings do not fit together yet. Try adjusting the workday range and resetting the studio."
+
+
+def create_env(start_hour: str, end_hour: str, distraction_risk: float, seed: int) -> FocusResourceEnv:
+    return FocusResourceEnv(
+        start_hour=start_hour,
+        end_hour=end_hour,
+        distraction_risk=distraction_risk,
+        seed=seed,
+    )
+
+
+def default_task_name(index: int) -> str:
+    return DEFAULT_TASK_NAMES[index] if index < len(DEFAULT_TASK_NAMES) else f"Task {index + 1}"
+
+
+def init_state() -> None:
+    st.session_state.setdefault("ui_error", "")
+    st.session_state.setdefault("ui_error_until", 0.0)
+    st.session_state.setdefault("start_hour", "09:00")
+    st.session_state.setdefault("end_hour", "17:00")
+    st.session_state.setdefault("distraction_risk", 0.15)
+    st.session_state.setdefault("seed", 7)
+    st.session_state.setdefault("selection_start", None)
+    st.session_state.setdefault("selected_range", None)
+    st.session_state.setdefault("selected_block_id", None)
+    st.session_state.setdefault("move_block_id", None)
+    st.session_state.setdefault("armed_task_index", None)
+    st.session_state.setdefault("next_block_id", 1)
+
+
+def build_initial_blocks(env: FocusResourceEnv) -> List[dict]:
+    blocks: List[dict] = []
+    seen_meetings = set()
+    for _, meta in sorted(env.meeting_meta.items()):
+        meeting_id = meta["meeting_id"]
+        if meeting_id in seen_meetings:
+            continue
+        seen_meetings.add(meeting_id)
+        blocks.append(
+            {
+                "id": f"meeting-{meeting_id}",
+                "start": int(meta["start"]),
+                "end": int(meta["start"] + meta["length"] - 1),
+                "type": "Meeting",
+                "label": "Meeting",
+                "priority": int(meta["priority"]),
+            }
+        )
+    return sorted(blocks, key=lambda block: block["start"])
+
+
+def ensure_task_names(env: FocusResourceEnv) -> None:
+    names = st.session_state.get("task_names", [])
+    st.session_state.task_names = [names[i] if i < len(names) else default_task_name(i) for i in range(len(env.task_buffer))]
+
+
+def sync_from_env(env: FocusResourceEnv) -> None:
+    st.session_state.env = env
+    st.session_state.observation = env._observation()
+    st.session_state.done = env.current_slot >= env.timeline_length
+    st.session_state.setdefault("last_reward", 0.0)
+    st.session_state.setdefault("last_info", {})
+    ensure_task_names(env)
+
+
+def get_env() -> FocusResourceEnv | None:
+    if "env" not in st.session_state:
+        try:
+            env = create_env(
+                st.session_state.get("start_hour", "09:00"),
+                st.session_state.get("end_hour", "17:00"),
+                float(st.session_state.get("distraction_risk", 0.15)),
+                int(st.session_state.get("seed", 7)),
+            )
+            env.reset()
+            sync_from_env(env)
+            st.session_state.blocks = build_initial_blocks(env)
+        except ValueError as exc:
+            set_ui_error(friendly_error(exc), seconds=6.0)
+            return None
+    return st.session_state.env
+
+
+def set_ui_error(message: str, seconds: float = 5.0) -> None:
+    st.session_state.ui_error = message
+    st.session_state.ui_error_until = time.time() + seconds
+
+
+def clear_ui_error() -> None:
+    st.session_state.ui_error = ""
+    st.session_state.ui_error_until = 0.0
+
+
+def render_flash_error() -> None:
+    message = st.session_state.get("ui_error", "")
+    until = float(st.session_state.get("ui_error_until", 0.0))
+    if not message or time.time() >= until:
+        if message:
+            clear_ui_error()
+        return
+    remaining_ms = max(0, int((until - time.time()) * 1000))
+    st.markdown(
+        f"""
+        <div id="focus-studio-error" style="
+            margin: 0.4rem 0 1rem 0;
+            padding: 0.9rem 1rem;
+            border-radius: 16px;
+            border: 1px solid rgba(255, 120, 145, 0.25);
+            background: linear-gradient(180deg, rgba(90, 19, 33, 0.88), rgba(60, 15, 25, 0.88));
+            color: #ffe8ed;
+            box-shadow: 0 14px 32px rgba(0, 0, 0, 0.22);
+        ">
+            <strong>Check the plan</strong><br>{message}
+        </div>
+        <script>
+        setTimeout(function() {{
+            const el = window.parent.document.getElementById("focus-studio-error");
+            if (el) {{
+                el.style.transition = "opacity 220ms ease";
+                el.style.opacity = "0";
+                setTimeout(function() {{ if (el) el.remove(); }}, 240);
+            }}
+        }}, {remaining_ms});
+        </script>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def reset_env(start_hour: str, end_hour: str, distraction_risk: float, seed: int) -> None:
+    env = create_env(start_hour, end_hour, distraction_risk, seed)
+    env.reset()
+    st.session_state.start_hour = start_hour
+    st.session_state.end_hour = end_hour
+    st.session_state.distraction_risk = float(distraction_risk)
+    st.session_state.seed = int(seed)
+    st.session_state.last_reward = 0.0
+    st.session_state.last_info = {}
+    clear_ui_error()
+    st.session_state.selection_start = None
+    st.session_state.selected_range = None
+    st.session_state.selected_block_id = None
+    st.session_state.move_block_id = None
+    st.session_state.armed_task_index = None
+    st.session_state.blocks = build_initial_blocks(env)
+    sync_from_env(env)
+    st.rerun()
+
+
+def sync_tasks_from_widgets() -> None:
+    env = st.session_state.env
+    new_buffer: List[Task] = []
+    new_names: List[str] = []
+    for i, task in enumerate(env.task_buffer):
+        name = str(st.session_state.get(f"task_name_{i}", default_task_name(i))).strip() or default_task_name(i)
+        slots = max(1, int(st.session_state.get(f"task_slots_{i}", task.duration)))
+        complexity = float(st.session_state.get(f"task_complexity_{i}", task.hidden_complexity))
+        new_buffer.append(Task(duration=slots, hidden_complexity=complexity))
+        new_names.append(name)
+    env.task_buffer = new_buffer
+    st.session_state.task_names = new_names
+
+
+def block_at_slot(slot: int) -> Optional[dict]:
+    for block in st.session_state.get("blocks", []):
+        if block["start"] <= slot <= block["end"]:
+            return block
+    return None
+
+
+def sort_blocks() -> None:
+    st.session_state.blocks = sorted(st.session_state.get("blocks", []), key=lambda item: item["start"])
+
+
+def remove_overlaps(start: int, end: int, ignore_id: Optional[str] = None) -> None:
+    kept = []
+    for block in st.session_state.get("blocks", []):
+        overlaps = not (block["end"] < start or block["start"] > end)
+        if overlaps and block["id"] != ignore_id:
+            continue
+        kept.append(block)
+    st.session_state.blocks = kept
+
+
+def apply_blocks_to_env() -> None:
+    env = st.session_state.env
+    env.timeline[:] = EMPTY
+    env.meeting_meta = {}
+    for block in st.session_state.get("blocks", []):
+        if block["type"] == "Focus":
+            env.timeline[block["start"] : block["end"] + 1] = DEEP_WORK
+        else:
+            env._place_meeting(
+                block["start"],
+                block["end"] - block["start"] + 1,
+                int(block.get("priority", 5)),
+                env._next_meeting_id(),
+            )
+    sync_from_env(env)
+
+
+def clear_selection() -> None:
+    st.session_state.selection_start = None
+    st.session_state.selected_range = None
+    st.session_state.selected_block_id = None
+    st.session_state.move_block_id = None
+
+
+def create_block(start: int, end: int, block_type: str, label: str, priority: int) -> None:
+    start, end = sorted((start, end))
+    remove_overlaps(start, end)
+    st.session_state.blocks.append(
+        {
+            "id": f"user-{st.session_state.get('next_block_id', 1)}",
+            "start": start,
+            "end": end,
+            "type": block_type,
+            "label": label.strip() or block_type,
+            "priority": int(priority),
+        }
+    )
+    st.session_state.next_block_id = int(st.session_state.get("next_block_id", 1)) + 1
+    sort_blocks()
+    apply_blocks_to_env()
+    clear_selection()
+    st.rerun()
+
+
+def update_block(block_id: str, block_type: str, label: str, priority: int) -> None:
+    for block in st.session_state.get("blocks", []):
+        if block["id"] == block_id:
+            block["type"] = block_type
+            block["label"] = label.strip() or block_type
+            block["priority"] = int(priority)
+            break
+    apply_blocks_to_env()
+    st.rerun()
+
+
+def delete_block(block_id: str) -> None:
+    st.session_state.blocks = [block for block in st.session_state.get("blocks", []) if block["id"] != block_id]
+    apply_blocks_to_env()
+    clear_selection()
+    st.rerun()
+
+
+def move_block(block_id: str, new_start: int) -> None:
+    block = next((item for item in st.session_state.get("blocks", []) if item["id"] == block_id), None)
+    if block is None:
+        return
+    duration = block["end"] - block["start"]
+    new_end = min(st.session_state.env.timeline_length - 1, new_start + duration)
+    new_start = max(0, new_end - duration)
+    remove_overlaps(new_start, new_end, ignore_id=block_id)
+    block["start"] = new_start
+    block["end"] = new_end
+    sort_blocks()
+    apply_blocks_to_env()
+    st.session_state.move_block_id = None
+    st.session_state.selected_block_id = block_id
+    st.rerun()
+
+
+def arm_task(index: int) -> None:
+    sync_tasks_from_widgets()
+    st.session_state.armed_task_index = index
+
+
+def place_armed_task(start: int, end: int) -> None:
+    env = st.session_state.env
+    sync_tasks_from_widgets()
+    task_index = st.session_state.get("armed_task_index")
+    if task_index is None or not (0 <= task_index < len(env.task_buffer)):
+        set_ui_error("Pick a task from the queue before placing it on the calendar.")
+        return
+    task = env.task_buffer.pop(task_index)
+    task_name = st.session_state.task_names.pop(task_index)
+    desired = max(1, int(round(task.duration * task.hidden_complexity)))
+    start, end = sorted((start, end))
+    end = min(env.timeline_length - 1, max(end, start + desired - 1))
+    st.session_state.armed_task_index = None
+    create_block(start, end, "Focus", task_name, 5)
+
+
+def run_simulation_step(operation: int) -> None:
+    env = st.session_state.env
+    sync_tasks_from_widgets()
+    apply_blocks_to_env()
+    current_slot = int(env.current_slot)
+    target_slot = current_slot
+    if operation == OP_RESCHEDULE_MEETING:
+        future_meetings = [block for block in st.session_state.get("blocks", []) if block["type"] == "Meeting" and block["start"] >= current_slot]
+        if not future_meetings:
+            set_ui_error("No future meeting is available to move right now.")
+            return
+        target_slot = future_meetings[0]["start"]
+    obs, reward, done, info = env.step((target_slot, operation))
+    st.session_state.observation = obs
+    st.session_state.last_reward = reward
+    st.session_state.last_info = info
+    st.session_state.done = done
+    if operation == OP_RESCHEDULE_MEETING and info.get("action_info", {}).get("status") == "meeting_rescheduled":
+        moved = next((block for block in st.session_state.get("blocks", []) if block["type"] == "Meeting" and block["start"] == int(info["action_info"]["from_slot"])), None)
+        if moved is not None:
+            duration = moved["end"] - moved["start"]
+            moved["start"] = int(info["action_info"]["to_slot"])
+            moved["end"] = moved["start"] + duration
+            sort_blocks()
+    st.rerun()
+
+
+def render_header(observation: Dict[str, object]) -> None:
+    st.markdown(
+        """
+        <div class="hero">
+            <div class="hero-kicker">Cognitive Resource Simulator</div>
+            <h1>engineer-manager</h1>
+            <p>Design the day directly on the calendar, lock in meaningful work blocks, and pressure-test the plan against interruption cost with a cleaner single-source workflow.</p>
+            <span class="help-chip">One interface, one truth</span>
+            <span class="help-chip">Blocks keep their own type and label</span>
+            <span class="help-chip">The task queue never rewrites scheduled work</span>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    a, b, c, d = st.columns(4)
+    a.metric("Current time", observation["current_time"])
+    b.metric("Current slot", str(observation["current_slot"]))
+    c.metric("Focus Fortress", "Active" if observation["mute_comms"] else "Inactive")
+    d.metric("Last reward", f"{st.session_state.get('last_reward', 0.0):.2f}")
+
+
+def render_setup() -> None:
+    st.markdown("### Control Panel")
+    start_hour = st.text_input("Start", value=st.session_state.get("start_hour", "09:00"), key="setup_start")
+    end_hour = st.text_input("End", value=st.session_state.get("end_hour", "17:00"), key="setup_end")
+    risk = st.slider(
+        "Distraction risk",
+        min_value=0.0,
+        max_value=1.0,
+        value=float(st.session_state.get("distraction_risk", 0.15)),
+        step=0.05,
+        help="Higher values create noisier days and lower uninterrupted focus potential.",
+        key="setup_risk",
+    )
+    seed = st.number_input(
+        "Seed",
+        min_value=0,
+        max_value=100000,
+        value=int(st.session_state.get("seed", 7)),
+        step=1,
+        help="? Scenario Consistency: Use a fixed Seed number to regenerate this exact daily challenge for comparison testing.",
+        key="setup_seed",
+    )
+    st.caption("Professional scheduling note: the end time must be later than the start time for the studio to build a valid workday.")
+    if st.button("Reset Studio", use_container_width=True):
+        try:
+            reset_env(start_hour, end_hour, float(risk), int(seed))
+        except ValueError as exc:
+            set_ui_error(friendly_error(exc), seconds=6.0)
+
+
+def render_calendar(env: FocusResourceEnv) -> None:
+    st.markdown("### Day Plan")
+    st.caption("Click one open slot to start a range. Click a second slot to finish it. Click an existing block to edit it or move it.")
+    current_slot = int(env.current_slot)
+    selection_start = st.session_state.get("selection_start")
+    selected_range = st.session_state.get("selected_range")
+    selected_block = next((block for block in st.session_state.get("blocks", []) if block["id"] == st.session_state.get("selected_block_id")), None)
+    move_block_id = st.session_state.get("move_block_id")
+
+    for slot in range(env.timeline_length):
+        block = block_at_slot(slot)
+        time_col, body_col, action_col = st.columns([1.0, 4.25, 1.95])
+        time_col.markdown(f"**{env._slot_label(slot)}**")
+        if block is None:
+            label = "Open"
+        else:
+            label = f"{block['type']} | {block['label']}"
+        if slot == current_slot:
+            body_col.markdown(f"`NOW` {label}")
+        elif selection_start is not None and min(selection_start, slot) <= slot <= max(selection_start, slot):
+            body_col.markdown(f"`SELECTED` {label}")
+        else:
+            body_col.markdown(label)
+        if move_block_id:
+            if action_col.button("Drop", key=f"slot_drop_{slot}", use_container_width=True, type="secondary"):
+                move_block(move_block_id, slot)
+        elif block is not None:
+            start_col, edit_col = action_col.columns([1, 1])
+            start_text = "Finish" if selection_start is not None else "Start"
+            if start_col.button(start_text, key=f"slot_start_{slot}", use_container_width=True, type="primary"):
+                if selection_start is None:
+                    st.session_state.selection_start = slot
+                else:
+                    st.session_state.selected_range = (selection_start, slot)
+                st.rerun()
+            if edit_col.button("Edit", key=f"slot_edit_{slot}", use_container_width=True, type="secondary"):
+                st.session_state.selected_block_id = block["id"]
+                st.session_state.selection_start = None
+                st.session_state.selected_range = None
+                st.rerun()
+        else:
+            button_text = "Start" if selection_start is None else "Finish"
+            if action_col.button(button_text, key=f"slot_open_{slot}", use_container_width=True, type="primary"):
+                if selection_start is None:
+                    st.session_state.selection_start = slot
+                else:
+                    st.session_state.selected_range = (selection_start, slot)
+                st.rerun()
+
+    if selected_range is not None:
+        start, end = sorted(selected_range)
+        st.markdown("#### New block")
+        block_type = st.radio("Type", options=BLOCK_TYPES, horizontal=True, key="new_block_type")
+        armed_task_index = st.session_state.get("armed_task_index")
+        if block_type == "Focus" and armed_task_index is not None and armed_task_index < len(st.session_state.get("task_names", [])):
+            default_label = st.session_state["task_names"][armed_task_index]
+        else:
+            default_label = ""
+        label = st.text_input("Label", value=default_label, key="new_block_label")
+        priority = st.slider("Meeting priority", 1, 10, 5, key="new_block_priority")
+        a, b, c = st.columns(3)
+        if a.button("Create block", use_container_width=True):
+            if block_type == "Focus" and armed_task_index is not None:
+                place_armed_task(start, end)
+            else:
+                create_block(start, end, block_type, label, int(priority))
+        if b.button("Clear to open", use_container_width=True):
+            remove_overlaps(start, end)
+            apply_blocks_to_env()
+            clear_selection()
+            st.rerun()
+        if c.button("Cancel selection", use_container_width=True):
+            clear_selection()
+            st.rerun()
+
+    if selected_block is not None:
+        st.markdown("#### Edit block")
+        block_type = st.radio("Block type", options=BLOCK_TYPES, index=BLOCK_TYPES.index(selected_block["type"]), horizontal=True, key="edit_block_type")
+        label = st.text_input("Block label", value=selected_block["label"], key="edit_block_label")
+        priority = st.slider("Meeting priority", 1, 10, int(selected_block.get("priority", 5)), key="edit_block_priority")
+        a, b, c = st.columns(3)
+        if a.button("Save block", use_container_width=True):
+            update_block(selected_block["id"], block_type, label, int(priority))
+        if b.button("Move block", use_container_width=True):
+            st.session_state.move_block_id = selected_block["id"]
+            st.rerun()
+        if c.button("Delete block", use_container_width=True):
+            delete_block(selected_block["id"])
+        if st.button("Close inspector", use_container_width=True):
+            clear_selection()
+            st.rerun()
+
+
+def render_task_queue(env: FocusResourceEnv) -> None:
+    st.markdown("### Task Queue")
+    sync_tasks_from_widgets()
+    if not env.task_buffer:
+        st.info("The queue is empty. Add a task to keep planning.")
+    for i, task in enumerate(env.task_buffer):
+        cols = st.columns([2.0, 0.78, 0.92, 1.38, 0.52])
+        cols[0].text_input("Task", value=st.session_state.get("task_names", [default_task_name(i)])[i], key=f"task_name_{i}", label_visibility="collapsed")
+        cols[1].number_input("Slots", min_value=1, max_value=12, value=int(task.duration), key=f"task_slots_{i}", label_visibility="collapsed")
+        current_complexity = float(task.hidden_complexity)
+        cols[2].selectbox("Complexity", COMPLEXITY_OPTIONS, index=COMPLEXITY_OPTIONS.index(current_complexity) if current_complexity in COMPLEXITY_OPTIONS else 0, key=f"task_complexity_{i}", label_visibility="collapsed")
+        armed = st.session_state.get("armed_task_index") == i
+        if cols[3].button("Selected" if armed else "Use", key=f"use_task_{i}", use_container_width=True):
+            arm_task(i)
+            st.rerun()
+        if cols[4].button("X", key=f"cancel_task_{i}", use_container_width=True):
+            sync_tasks_from_widgets()
+            env.task_buffer.pop(i)
+            st.session_state.task_names.pop(i)
+            st.session_state.armed_task_index = None
+            st.rerun()
+
+    st.markdown("#### Add task")
+    a, b, c, d = st.columns([2.2, 0.8, 1.0, 0.9])
+    task_name = a.text_input("Name", value="", placeholder="Execution block", key="add_task_name")
+    slots = b.number_input("Slots", min_value=1, max_value=12, value=2, key="add_task_slots")
+    complexity = c.selectbox("Complexity", COMPLEXITY_OPTIONS, index=1, key="add_task_complexity")
+    if d.button("Add", use_container_width=True):
+        sync_tasks_from_widgets()
+        env.task_buffer.append(Task(duration=int(slots), hidden_complexity=float(complexity)))
+        st.session_state.task_names.append(task_name.strip() or default_task_name(len(st.session_state.task_names)))
+        st.rerun()
+
+
+def render_status(observation: Dict[str, object]) -> None:
+    st.markdown("### Live Scoring")
+    scores = st.session_state.get("last_info", {}).get("score_breakdown", {})
+    current_block = block_at_slot(int(observation["current_slot"]))
+    a, b = st.columns(2)
+    a.metric("Flow efficiency", f"{scores.get('flow_score', observation.get('flow_score', 0.0)):.2f}")
+    recovery_state = int(observation.get("recovery_state", 0))
+    card_class = "status-card-warning" if recovery_state > 0 else "status-card-subtle"
+    current_flow_label = current_block["label"] if current_block and current_block["type"] == "Focus" else "Open"
+    current_flow_note = "Recovery is active. Focus output is temporarily reduced." if recovery_state > 0 else "Flow is live and ready to compound."
+    with b:
+        st.markdown(
+            f"""
+            <div class="status-card {card_class}">
+                <div class="status-card-label">Current Flow Block</div>
+                <div class="status-card-value">{current_flow_label}</div>
+                <div class="status-card-label" style="margin-top:0.4rem;text-transform:none;letter-spacing:0;color:var(--muted);">
+                    {current_flow_note}
+                </div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+    c, d = st.columns(2)
+    c.metric("Social Debt", f"{scores.get('social_debt', observation.get('social_debt', 0.0)):.2f}")
+    d.metric("Calendar Churn", int(scores.get('calendar_churn', observation.get('calendar_churn', 0))))
+
+
+def render_simulator(observation: Dict[str, object]) -> None:
+    st.markdown("### Simulation Command Center")
+    quiet_mode = bool(observation.get("mute_comms", False))
+    st.caption(
+        "?? Focus Fortress: Quiet Mode is active. Notifications are suppressed, boosting your continuous work potential."
+        if quiet_mode
+        else "?? Focus Fortress is standing by. Activate it when you want maximum uninterrupted focus potential."
+    )
+    a, b = st.columns(2)
+    if a.button("Deactivate Focus Fortress" if quiet_mode else "Activate Focus Fortress", use_container_width=True):
+        run_simulation_step(OP_MUTE_COMMS)
+    if b.button("Step Simulator", use_container_width=True):
+        run_simulation_step(OP_IDLE)
+    if st.button("Move next meeting", use_container_width=True):
+        run_simulation_step(OP_RESCHEDULE_MEETING)
+
+
+def main() -> None:
+    st.set_page_config(page_title="Focus Studio", layout="wide")
+    init_state()
+    inject_styles()
+    env = get_env()
+    if env is None:
+        render_flash_error()
+        st.stop()
+    observation = st.session_state.get("observation", env._observation())
+    render_flash_error()
+    render_header(observation)
+    col1, col2, col3 = st.columns([0.88, 1.5, 1.28], gap="large")
+    with col1:
+        render_setup()
+    with col2:
+        render_calendar(env)
+    with col3:
+        render_task_queue(env)
+        render_status(observation)
+        render_simulator(observation)
+
+
+if __name__ == "__main__":
+    main()

client.py

@@ -0,0 +1,35 @@
+"""OpenEnv client for the Engineer Manager environment."""
+
+from __future__ import annotations
+
+from typing import Any
+
+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
+
+
+class EngineerManagerEnv(
+    EnvClient[EngineerManagerAction, EngineerManagerObservation, State]
+):
+    """Persistent client for a running Engineer Manager OpenEnv server."""
+
+    def _step_payload(self, action: EngineerManagerAction) -> dict[str, Any]:
+        return action.model_dump()
+
+    def _parse_result(
+        self, payload: dict[str, Any]
+    ) -> StepResult[EngineerManagerObservation]:
+        observation = EngineerManagerObservation.model_validate(
+            payload.get("observation", {})
+        )
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", observation.done),
+        )
+
+    def _parse_state(self, payload: dict[str, Any]) -> State:
+        return State.model_validate(payload)

focus_resource_env.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+
+try:
+    from openenv.env import Env
+except ImportError:
+    class Env:  # type: ignore[override]
+        """Compatibility shim when only openenv-core is installed."""
+
+        def __init__(self, *_: object, **__: object) -> None:
+            pass
+
+
+EMPTY = 0
+DEEP_WORK = 1
+MEETING = 2
+
+OP_IDLE = 0
+OP_SCHEDULE_WORK = 1
+OP_RESCHEDULE_MEETING = 2
+OP_MUTE_COMMS = 3
+
+RECOVERY_STEPS = 2
+
+
+@dataclass
+class Task:
+    duration: int
+    hidden_complexity: float
+
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            "duration": int(self.duration),
+            "hidden_complexity": float(self.hidden_complexity),
+        }
+
+
+class FocusResourceEnv(Env):
+    def __init__(
+        self,
+        start_hour: str = "09:00",
+        end_hour: str = "17:00",
+        distraction_risk: float = 0.15,
+        seed: Optional[int] = None,
+    ) -> None:
+        self.start_hour = start_hour
+        self.end_hour = end_hour
+        self.distraction_risk = float(distraction_risk)
+        self.rng = np.random.default_rng(seed)
+        self.slot_minutes = 30
+
+        self.timeline_length = self._compute_timeline_length(start_hour, end_hour)
+        if self.timeline_length <= 0:
+            raise ValueError("end_hour must be after start_hour")
+
+        super().__init__(
+            name="FocusResourceEnv",
+            state_space={
+                "timeline": self.timeline_length,
+                "task_buffer": 3,
+                "distraction_risk": (0.0, 1.0),
+            },
+            action_space={
+                "target_slot": (0, self.timeline_length - 1),
+                "operation": {
+                    OP_IDLE: "Idle",
+                    OP_SCHEDULE_WORK: "Schedule Work",
+                    OP_RESCHEDULE_MEETING: "Reschedule Meeting",
+                    OP_MUTE_COMMS: "Mute Comms",
+                },
+            },
+            episode_max_length=self.timeline_length,
+        )
+
+        self.reset()
+
+    def reset(self) -> Dict[str, Any]:
+        self.current_slot = 0
+        self.timeline = np.zeros(self.timeline_length, dtype=np.int8)
+        self.meeting_meta: Dict[int, Dict[str, int]] = {}
+        self._meeting_id_counter = 0
+        self.task_buffer = self._generate_task_buffer()
+        self.current_work_streak_slots = 0
+        self.recovery_remaining = 0
+        self.mute_comms = False
+        self.social_debt = 0.0
+        self.calendar_churn = 0
+        self.flow_score = 0.0
+        self.last_executed_kind = EMPTY
+        self.interruptions = 0
+        self.invalid_actions = 0
+        self._scatter_initial_meetings()
+        return self._observation()
+
+    def step(self, action: Tuple[int, int]) -> Tuple[Dict[str, Any], float, bool, Dict[str, Any]]:
+        target_slot, operation = self._normalize_action(action)
+        action_info = self._apply_action(target_slot, operation)
+        previous_score = self._total_score()
+        transition_info = self._advance_execution()
+        done = self.current_slot >= self.timeline_length
+        reward = self._total_score() - previous_score
+
+        info = {
+            "slot_executed": self.current_slot - 1,
+            "action": {"target_slot": target_slot, "operation": operation},
+            "action_info": action_info,
+            "transition_info": transition_info,
+            "score_breakdown": {
+                "flow_score": self.flow_score,
+                "social_debt": self.social_debt,
+                "calendar_churn": self.calendar_churn,
+                "total_score": self._total_score(),
+            },
+        }
+        return self._observation(), reward, done, info
+
+    def render_text(self) -> str:
+        symbols = {EMPTY: ".", DEEP_WORK: "W", MEETING: "M"}
+        timeline = "".join(symbols[int(slot)] for slot in self.timeline)
+        return (
+            f"time={self._slot_label(self.current_slot)} "
+            f"muted={self.mute_comms} recovery={self.recovery_remaining} "
+            f"flow={self.flow_score:.2f} debt={self.social_debt:.2f} churn={self.calendar_churn} "
+            f"timeline={timeline}"
+        )
+
+    def _normalize_action(self, action: Tuple[int, int]) -> Tuple[int, int]:
+        if not isinstance(action, (tuple, list)) or len(action) != 2:
+            raise ValueError("action must be a (target_slot, operation) pair")
+
+        target_slot = int(action[0])
+        operation = int(action[1])
+        if target_slot < 0 or target_slot >= self.timeline_length:
+            raise ValueError("target_slot is outside the work day")
+        if operation not in {OP_IDLE, OP_SCHEDULE_WORK, OP_RESCHEDULE_MEETING, OP_MUTE_COMMS}:
+            raise ValueError("operation is invalid")
+        return target_slot, operation
+
+    def _apply_action(self, target_slot: int, operation: int) -> Dict[str, Any]:
+        if target_slot < self.current_slot:
+            self.invalid_actions += 1
+            self.social_debt += 0.25
+            return {"status": "invalid_past_slot"}
+
+        if operation == OP_IDLE:
+            return {"status": "idle"}
+        if operation == OP_MUTE_COMMS:
+            self.mute_comms = not self.mute_comms
+            return {"status": "mute_toggled", "muted": self.mute_comms}
+        if operation == OP_SCHEDULE_WORK:
+            return self._schedule_work(target_slot)
+        if operation == OP_RESCHEDULE_MEETING:
+            return self._reschedule_meeting(target_slot)
+        return {"status": "noop"}
+
+    def _schedule_work(self, target_slot: int) -> Dict[str, Any]:
+        if not self.task_buffer:
+            self.invalid_actions += 1
+            return {"status": "no_tasks_available"}
+        if self.timeline[target_slot] == MEETING:
+            self.invalid_actions += 1
+            self.calendar_churn += 1
+            return {"status": "meeting_blocks_target"}
+
+        task = self.task_buffer.pop(0)
+        true_slots = int(np.ceil(task.duration * task.hidden_complexity))
+        contiguous = self._contiguous_empty_slots_from(target_slot)
+        scheduled_slots = min(true_slots, contiguous)
+        if scheduled_slots == 0:
+            self.invalid_actions += 1
+            self.task_buffer.insert(0, task)
+            return {"status": "no_capacity"}
+
+        self.timeline[target_slot : target_slot + scheduled_slots] = DEEP_WORK
+        overflow = true_slots - scheduled_slots
+
+        if overflow > 0:
+            self.social_debt += 0.5
+            self.invalid_actions += 1
+
+        return {
+            "status": "work_scheduled",
+            "estimated_slots": task.duration,
+            "true_slots": true_slots,
+            "scheduled_slots": scheduled_slots,
+            "overflow_slots": overflow,
+        }
+
+    def _reschedule_meeting(self, target_slot: int) -> Dict[str, Any]:
+        if self.timeline[target_slot] != MEETING:
+            self.invalid_actions += 1
+            return {"status": "no_meeting_at_target"}
+
+        meeting = self.meeting_meta.get(target_slot)
+        if meeting is None:
+            self.invalid_actions += 1
+            return {"status": "missing_meeting_metadata"}
+
+        length = meeting["length"]
+        priority = meeting["priority"]
+        meeting_id = meeting["meeting_id"]
+        start = meeting["start"]
+
+        candidate = self._find_latest_empty_block(length, exclude=(start, start + length))
+        self._clear_meeting(start, length)
+        self.calendar_churn += 1
+        # High-priority meeting churn needs to outweigh the quadratic flow upside
+        # from deleting collaboration entirely, while still charging a smaller
+        # cost when a meeting is merely moved instead of cancelled.
+        reschedule_penalty = priority / 2.0
+        cancellation_penalty = (priority**2) / 5.0
+
+        if candidate is None:
+            self.social_debt += cancellation_penalty
+            return {"status": "meeting_cancelled", "meeting_id": meeting_id, "priority": priority}
+
+        self.social_debt += reschedule_penalty
+        self._place_meeting(candidate, length, priority, meeting_id)
+        return {
+            "status": "meeting_rescheduled",
+            "meeting_id": meeting_id,
+            "from_slot": start,
+            "to_slot": candidate,
+            "priority": priority,
+        }
+
+    def _advance_execution(self) -> Dict[str, Any]:
+        if self.current_slot >= self.timeline_length:
+            return {"status": "episode_complete"}
+
+        slot_kind = int(self.timeline[self.current_slot])
+        event = {
+            "slot_kind": slot_kind,
+            "recovery_triggered": False,
+            "interrupted": False,
+            "productive": False,
+        }
+
+        if self._is_context_switch(self.last_executed_kind, slot_kind):
+            self.recovery_remaining = RECOVERY_STEPS
+            self.current_work_streak_slots = 0
+            event["recovery_triggered"] = True
+
+        if self.recovery_remaining > 0:
+            self.recovery_remaining -= 1
+            self.current_work_streak_slots = 0
+        elif slot_kind == DEEP_WORK:
+            if not self.mute_comms and self.rng.random() < self.distraction_risk:
+                self.current_work_streak_slots = 0
+                self.interruptions += 1
+                event["interrupted"] = True
+            else:
+                previous_streak = self.current_work_streak_slots
+                self.current_work_streak_slots += 1
+                self.flow_score += self._power_law_delta(previous_streak, self.current_work_streak_slots)
+                event["productive"] = True
+        else:
+            self.current_work_streak_slots = 0
+
+        self.last_executed_kind = slot_kind
+        self.current_slot += 1
+        return event
+
+    def _observation(self) -> Dict[str, Any]:
+        return {
+            "timeline": self.timeline.astype(int).tolist(),
+            "task_buffer": [task.to_dict() for task in self.task_buffer],
+            "distraction_risk": float(self.distraction_risk),
+            "current_slot": int(self.current_slot),
+            "current_time": self._slot_label(self.current_slot),
+            "recovery_state": int(self.recovery_remaining),
+            "mute_comms": bool(self.mute_comms),
+            "social_debt": float(self.social_debt),
+            "calendar_churn": int(self.calendar_churn),
+            "flow_score": float(self.flow_score),
+        }
+
+    def _generate_task_buffer(self) -> List[Task]:
+        return [self._make_task() for _ in range(3)]
+
+    def _make_task(self) -> Task:
+        return Task(
+            duration=int(self.rng.integers(1, 5)),
+            hidden_complexity=float(self.rng.choice([1.0, 1.25, 1.5, 1.75])),
+        )
+
+    def _scatter_initial_meetings(self) -> None:
+        meeting_count = int(self.rng.integers(3, 6))
+        attempts = 0
+        while meeting_count > 0 and attempts < 100:
+            attempts += 1
+            length = int(self.rng.integers(1, 3))
+            latest_start = self.timeline_length - length
+            if latest_start < 0:
+                break
+
+            start = int(self.rng.integers(0, latest_start + 1))
+            if np.any(self.timeline[start : start + length] != EMPTY):
+                continue
+
+            priority = int(self.rng.integers(1, 11))
+            meeting_id = self._next_meeting_id()
+            self._place_meeting(start, length, priority, meeting_id)
+            meeting_count -= 1
+
+    def _place_meeting(self, start: int, length: int, priority: int, meeting_id: int) -> None:
+        self.timeline[start : start + length] = MEETING
+        for slot in range(start, start + length):
+            self.meeting_meta[slot] = {
+                "meeting_id": meeting_id,
+                "start": start,
+                "length": length,
+                "priority": priority,
+            }
+
+    def _clear_meeting(self, start: int, length: int) -> None:
+        self.timeline[start : start + length] = EMPTY
+        for slot in range(start, start + length):
+            self.meeting_meta.pop(slot, None)
+
+    def _find_latest_empty_block(
+        self,
+        length: int,
+        exclude: Optional[Tuple[int, int]] = None,
+    ) -> Optional[int]:
+        for start in range(self.timeline_length - length, -1, -1):
+            end = start + length
+            if exclude is not None and not (end <= exclude[0] or start >= exclude[1]):
+                continue
+            if np.all(self.timeline[start:end] == EMPTY):
+                return start
+        return None
+
+    def _contiguous_empty_slots_from(self, start: int) -> int:
+        count = 0
+        for slot in range(start, self.timeline_length):
+            if self.timeline[slot] != EMPTY:
+                break
+            count += 1
+        return count
+
+    def _compute_timeline_length(self, start_hour: str, end_hour: str) -> int:
+        return int((self._to_minutes(end_hour) - self._to_minutes(start_hour)) / self.slot_minutes)
+
+    def _slot_label(self, slot_index: int) -> str:
+        minute_value = self._to_minutes(self.start_hour) + slot_index * self.slot_minutes
+        hours = (minute_value // 60) % 24
+        minutes = minute_value % 60
+        return f"{hours:02d}:{minutes:02d}"
+
+    def _to_minutes(self, hhmm: str) -> int:
+        hours, minutes = hhmm.split(":")
+        return int(hours) * 60 + int(minutes)
+
+    def _power_law_delta(self, previous_streak_slots: int, current_streak_slots: int) -> float:
+        prev_hours = previous_streak_slots * 0.5
+        curr_hours = current_streak_slots * 0.5
+        return curr_hours ** 2 - prev_hours ** 2
+
+    def _is_context_switch(self, previous_kind: int, current_kind: int) -> bool:
+        work_meeting = {DEEP_WORK, MEETING}
+        return previous_kind in work_meeting and current_kind in work_meeting and previous_kind != current_kind
+
+    def _total_score(self) -> float:
+        return self.flow_score - self.social_debt - self.calendar_churn
+
+    def _next_meeting_id(self) -> int:
+        self._meeting_id_counter += 1
+        return self._meeting_id_counter

models.py

@@ -0,0 +1,35 @@
+"""Pydantic models for the Engineer Manager environment."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class EngineerManagerAction(Action):
+    """Scheduling action applied to the focus-planning environment."""
+
+    target_slot: int = Field(..., ge=0, description="Target half-hour slot index.")
+    operation: int = Field(
+        ...,
+        ge=0,
+        le=3,
+        description="Operation id: 0 idle, 1 schedule work, 2 reschedule meeting, 3 mute comms.",
+    )
+
+
+class EngineerManagerObservation(Observation):
+    """Serializable observation returned by the environment server."""
+
+    timeline: list[int] = Field(default_factory=list)
+    task_buffer: list[dict[str, Any]] = Field(default_factory=list)
+    distraction_risk: float = Field(default=0.15)
+    current_slot: int = Field(default=0)
+    current_time: str = Field(default="09:00")
+    recovery_state: int = Field(default=0)
+    mute_comms: bool = Field(default=False)
+    social_debt: float = Field(default=0.0)
+    calendar_churn: int = Field(default=0)
+    flow_score: float = Field(default=0.0)

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "engineer-manager-openenv"
+version = "0.1.0"
+description = "OpenEnv server for the Engineer Manager scheduling simulator"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.135.0",
+    "numpy>=2.0.0",
+    "openenv-core[core]>=0.2.0",
+    "pydantic>=2.0.0",
+    "streamlit>=1.40.0",
+    "uvicorn>=0.30.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["server"]

run_sim.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import argparse
+from typing import Tuple
+
+import numpy as np
+
+from focus_resource_env import (
+    DEEP_WORK,
+    EMPTY,
+    MEETING,
+    OP_IDLE,
+    OP_MUTE_COMMS,
+    OP_RESCHEDULE_MEETING,
+    OP_SCHEDULE_WORK,
+    FocusResourceEnv,
+)
+
+
+def choose_action(env: FocusResourceEnv) -> Tuple[int, int]:
+    current = env.current_slot
+
+    if env.current_slot == 0 and not env.mute_comms and env.distraction_risk > 0.0:
+        return current, OP_MUTE_COMMS
+
+    if env.recovery_remaining > 0:
+        return current, OP_IDLE
+
+    if current < env.timeline_length and env.timeline[current] == EMPTY:
+        return current, OP_SCHEDULE_WORK
+
+    empty_slots = np.where(env.timeline[current:] == EMPTY)[0]
+    if empty_slots.size > 0:
+        target = current + int(empty_slots[0])
+        return target, OP_SCHEDULE_WORK
+
+    fragmented_meetings = future_meeting_starts(env, current)
+    if fragmented_meetings:
+        _, largest_empty_len = largest_empty_block(env.timeline, current)
+        if largest_empty_len < 8:
+            return fragmented_meetings[0], OP_RESCHEDULE_MEETING
+
+    return current, OP_IDLE
+
+
+def largest_empty_block(timeline: np.ndarray, start_index: int) -> Tuple[int, int]:
+    best_start = start_index
+    best_len = 0
+    idx = start_index
+    while idx < len(timeline):
+        if timeline[idx] != EMPTY:
+            idx += 1
+            continue
+        run_start = idx
+        while idx < len(timeline) and timeline[idx] == EMPTY:
+            idx += 1
+        run_len = idx - run_start
+        if run_len > best_len:
+            best_start = run_start
+            best_len = run_len
+    return best_start, best_len
+
+
+def future_meeting_starts(env: FocusResourceEnv, current: int) -> list[int]:
+    starts = []
+    seen = set()
+    for slot in range(current, env.timeline_length):
+        if env.timeline[slot] != MEETING:
+            continue
+        meta = env.meeting_meta.get(slot)
+        if meta is None:
+            continue
+        start = meta["start"]
+        if start in seen or start < current:
+            continue
+        seen.add(start)
+        starts.append(start)
+    return starts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the FocusResourceEnv simulation.")
+    parser.add_argument("--start-hour", default="09:00")
+    parser.add_argument("--end-hour", default="17:00")
+    parser.add_argument("--distraction-risk", type=float, default=0.15)
+    parser.add_argument("--seed", type=int, default=7)
+    args = parser.parse_args()
+
+    env = FocusResourceEnv(
+        start_hour=args.start_hour,
+        end_hour=args.end_hour,
+        distraction_risk=args.distraction_risk,
+        seed=args.seed,
+    )
+
+    observation = env.reset()
+    total_reward = 0.0
+    print("Initial observation:")
+    print(observation)
+    print(env.render_text())
+
+    done = False
+    while not done:
+        action = choose_action(env)
+        observation, reward, done, info = env.step(action)
+        total_reward += reward
+        print(f"action={action} reward={reward:.2f}")
+        print(info)
+        print(env.render_text())
+
+    print("\nFinal Flow Efficiency score")
+    print(f"episode_reward={total_reward:.2f}")
+    print(f"flow_score={env.flow_score:.2f}")
+    print(f"social_debt={env.social_debt:.2f}")
+    print(f"calendar_churn={env.calendar_churn}")
+    print(f"interruptions={env.interruptions}")
+    print(f"invalid_actions={env.invalid_actions}")
+
+
+if __name__ == "__main__":
+    main()

server/__init__.py

@@ -0,0 +1 @@
+"""Server package for the Engineer Manager OpenEnv app."""

server/app.py

@@ -0,0 +1,48 @@
+"""FastAPI application for the Engineer Manager OpenEnv server."""
+
+from __future__ import annotations
+
+import uvicorn
+from openenv.core import create_app
+
+try:
+    from ..models import EngineerManagerAction, EngineerManagerObservation
+    from .engineer_manager_environment import EngineerManagerEnvironment
+except ImportError:
+    import sys
+    from pathlib import Path
+
+    repo_root = Path(__file__).resolve().parents[1]
+    if str(repo_root) not in sys.path:
+        sys.path.insert(0, str(repo_root))
+    from models import EngineerManagerAction, EngineerManagerObservation
+    from server.engineer_manager_environment import EngineerManagerEnvironment
+
+
+app = create_app(
+    EngineerManagerEnvironment,
+    EngineerManagerAction,
+    EngineerManagerObservation,
+    env_name="engineer-manager",
+    max_concurrent_envs=2,
+)
+
+
+def run(host: str = "0.0.0.0", port: int = 8000) -> None:
+    """Run the OpenEnv HTTP server."""
+    uvicorn.run(app, host=host, port=port)
+
+
+def main() -> None:
+    """CLI entrypoint expected by the OpenEnv validator."""
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    run(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

server/engineer_manager_environment.py

@@ -0,0 +1,107 @@
+"""OpenEnv server wrapper for the focus scheduling simulator."""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment, EnvironmentMetadata
+from openenv.core.env_server.types import State
+
+from focus_resource_env import FocusResourceEnv
+
+try:
+    from ..models import EngineerManagerAction, EngineerManagerObservation
+except ImportError:
+    from models import EngineerManagerAction, EngineerManagerObservation
+
+
+class EngineerManagerEnvironment(
+    Environment[EngineerManagerAction, EngineerManagerObservation, State]
+):
+    """Expose the scheduling simulator through the OpenEnv HTTP contract."""
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(
+        self,
+        start_hour: str = "09:00",
+        end_hour: str = "17:00",
+        distraction_risk: float = 0.15,
+        seed: int | None = 7,
+    ) -> None:
+        super().__init__()
+        self._start_hour = start_hour
+        self._end_hour = end_hour
+        self._distraction_risk = distraction_risk
+        self._seed = seed
+        self._step_count = 0
+        self._episode_id = str(uuid4())
+        self._env = FocusResourceEnv(
+            start_hour=start_hour,
+            end_hour=end_hour,
+            distraction_risk=distraction_risk,
+            seed=seed,
+        )
+
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        **_: object,
+    ) -> EngineerManagerObservation:
+        self._seed = self._seed if seed is None else seed
+        self._episode_id = episode_id or str(uuid4())
+        self._step_count = 0
+        self._env = FocusResourceEnv(
+            start_hour=self._start_hour,
+            end_hour=self._end_hour,
+            distraction_risk=self._distraction_risk,
+            seed=self._seed,
+        )
+        return self._to_observation(self._env.reset(), reward=0.0, done=False)
+
+    def step(
+        self,
+        action: EngineerManagerAction,
+        timeout_s: float | None = None,
+        **_: object,
+    ) -> EngineerManagerObservation:
+        del timeout_s
+        observation, reward, done, info = self._env.step(
+            (action.target_slot, action.operation)
+        )
+        self._step_count += 1
+        return self._to_observation(observation, reward=reward, done=done, info=info)
+
+    @property
+    def state(self) -> State:
+        return State(
+            episode_id=self._episode_id,
+            step_count=self._step_count,
+            current_slot=self._env.current_slot,
+            done=self._env.current_slot >= self._env.timeline_length,
+        )
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        return EnvironmentMetadata(
+            name="Engineer Manager",
+            description=(
+                "Manage a workday by scheduling deep work, rescheduling meetings, "
+                "and controlling communication noise."
+            ),
+            version="0.1.0",
+        )
+
+    def _to_observation(
+        self,
+        observation: dict[str, object],
+        *,
+        reward: float | None,
+        done: bool,
+        info: dict[str, object] | None = None,
+    ) -> EngineerManagerObservation:
+        payload = dict(observation)
+        payload["reward"] = reward
+        payload["done"] = done
+        payload["metadata"] = info or {}
+        return EngineerManagerObservation.model_validate(payload)

styles.css

@@ -0,0 +1,176 @@
+:root {
+    --bg-0: __BG0__;
+    --bg-1: __BG1__;
+    --line: __LINE__;
+    --text: __TEXT__;
+    --muted: __MUTED__;
+    --accent: __ACCENT__;
+    --accent-2: __ACCENT2__;
+}
+
+.stApp {
+    background:
+        radial-gradient(circle at top left, rgba(30, 86, 198, 0.20), transparent 30%),
+        radial-gradient(circle at top right, rgba(15, 150, 120, 0.16), transparent 28%),
+        linear-gradient(180deg, var(--bg-0) 0%, var(--bg-1) 48%, #0a1120 100%);
+    color: var(--text);
+}
+
+#MainMenu, header, footer, [data-testid="stToolbar"], [data-testid="stStatusWidget"], [data-testid="stDecoration"] {
+    visibility: hidden !important;
+    height: 0 !important;
+    position: fixed !important;
+}
+
+[data-testid="stAppViewContainer"] > .main {
+    padding-top: 1.1rem;
+}
+
+.block-container {
+    max-width: 1640px;
+}
+
+h1, h2, h3, p, label, span, div {
+    color: var(--text);
+}
+
+.stButton > button {
+    color: __BUTTON_TEXT__ !important;
+    background: linear-gradient(135deg, var(--accent), var(--accent-2)) !important;
+    border: 0 !important;
+    font-weight: 800 !important;
+    font-size: 0.92rem !important;
+    border-radius: 999px !important;
+    min-height: 2.7rem !important;
+    padding-left: 0.7rem !important;
+    padding-right: 0.7rem !important;
+}
+
+.stButton > button[kind="secondary"] {
+    background: linear-gradient(180deg, rgba(66, 128, 255, 0.10), rgba(66, 128, 255, 0.05)) !important;
+    color: #8dc2ff !important;
+    border: 1px solid rgba(98, 156, 255, 0.28) !important;
+}
+
+.stButton > button * {
+    color: __BUTTON_TEXT__ !important;
+}
+
+.stButton > button[kind="secondary"] * {
+    color: #8dc2ff !important;
+}
+
+div[data-testid="stMetric"] {
+    background: __METRIC_BG__;
+    border: 1px solid var(--line);
+    border-radius: 20px;
+    padding: 0.8rem;
+    box-shadow: __SHADOW__;
+}
+
+.stTextInput input, .stNumberInput input, .stSelectbox div[data-baseweb="select"] > div {
+    background: __INPUT_BG__ !important;
+    color: var(--text) !important;
+    border-radius: 14px !important;
+}
+
+.stDataFrame, [data-testid="stDataFrame"] {
+    border-radius: 18px !important;
+    overflow: hidden;
+    border: 1px solid var(--line);
+}
+
+.hero {
+    background: __HERO_BG__;
+    border: 1px solid var(--line);
+    border-radius: 32px;
+    padding: 1.5rem 1.6rem 1.35rem 1.6rem;
+    margin-bottom: 1.2rem;
+    box-shadow: __SHADOW__;
+    position: relative;
+    overflow: hidden;
+}
+
+.hero::after {
+    content: "";
+    position: absolute;
+    inset: auto -8% -35% auto;
+    width: 18rem;
+    height: 18rem;
+    border-radius: 999px;
+    background: radial-gradient(circle, rgba(124, 231, 255, 0.22), transparent 62%);
+    pointer-events: none;
+    filter: blur(6px);
+}
+
+.hero-kicker {
+    position: relative;
+    z-index: 1;
+    text-transform: uppercase;
+    letter-spacing: 0.18em;
+    font-size: 0.72rem;
+    color: var(--muted);
+    margin-bottom: 0.55rem;
+}
+
+.hero h1 {
+    margin: 0;
+    position: relative;
+    z-index: 1;
+    font-size: 3rem;
+    line-height: 0.95;
+    letter-spacing: -0.06em;
+    text-shadow: 0 10px 30px rgba(0, 0, 0, 0.18);
+}
+
+.hero p {
+    position: relative;
+    z-index: 1;
+    margin: 0.5rem 0 0 0;
+    max-width: 54rem;
+    color: var(--muted);
+    font-size: 1rem;
+}
+
+.help-chip {
+    position: relative;
+    z-index: 1;
+    display: inline-block;
+    margin: 0.55rem 0.45rem 0 0;
+    padding: 0.35rem 0.7rem;
+    border-radius: 999px;
+    border: 1px solid var(--line);
+    background: rgba(255,255,255,0.05);
+    color: var(--muted);
+    font-size: 0.83rem;
+}
+
+.status-card {
+    border: 1px solid var(--line);
+    border-radius: 20px;
+    padding: 0.85rem 0.95rem;
+    box-shadow: __SHADOW__;
+    margin-bottom: 0.5rem;
+}
+
+.status-card-label {
+    color: var(--muted);
+    font-size: 0.82rem;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.status-card-value {
+    margin-top: 0.25rem;
+    font-size: 1.15rem;
+    font-weight: 700;
+}
+
+.status-card-subtle {
+    background: linear-gradient(180deg, rgba(255,255,255,0.04), rgba(255,255,255,0.02));
+}
+
+.status-card-warning {
+    background: linear-gradient(180deg, rgba(145, 104, 17, 0.34), rgba(89, 64, 13, 0.34));
+    border-color: rgba(255, 204, 92, 0.30);
+}

uv.lock

@@ -0,0 +1,2 @@
+# Placeholder lockfile for local validator compatibility.
+# Regenerate with `uv lock` in an environment where `uv` is installed.

validate-submission.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh - Enhanced OpenEnv Submission Validator
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+REQUIRED_CMDS=("curl" "docker" "openenv")
+
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BLUE='\033[0;34m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BLUE='' BOLD='' NC=''
+fi
+
+log()  { printf "[%s] %b\n" "$(date +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}${BOLD}PASS${NC} -- $1"; }
+fail() { log "${RED}${BOLD}FAIL${NC} -- $1"; }
+warn() { log "${YELLOW}${BOLD}WARN${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+
+show_spinner() {
+  local pid=$1
+  local delay=0.1
+  local spinstr='|/-\'
+  while kill -0 "$pid" 2>/dev/null; do
+    local temp=${spinstr#?}
+    printf " [%c]  " "$spinstr"
+    spinstr=$temp${spinstr%"$temp"}
+    sleep "$delay"
+    printf "\b\b\b\b\b\b"
+  done
+  printf "    \b\b\b\b"
+}
+
+stop_at() {
+  printf "\n${RED}${BOLD}Validation stopped at %s.${NC} Please address the error above.\n" "$1"
+  exit 1
+}
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "${BOLD}Usage:${NC} %s <ping_url> [repo_dir]\n" "$0"
+  exit 1
+fi
+
+[[ ! $PING_URL =~ ^http ]] && PING_URL="https://$PING_URL"
+PING_URL="${PING_URL%/}"
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  fail "Directory '$REPO_DIR' not found."
+  exit 1
+fi
+
+printf "\n${BOLD}========================================${NC}\n"
+printf "${BOLD}   OpenEnv Submission Validator v2.0    ${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Target Repo: $REPO_DIR"
+log "Remote URL:  $PING_URL"
+printf "\n"
+
+log "${BOLD}Step 0/3: Checking Environment...${NC}"
+for cmd in "${REQUIRED_CMDS[@]}"; do
+  if ! command -v "$cmd" >/dev/null 2>&1; then
+    fail "Dependency missing: $cmd"
+    [[ "$cmd" == "openenv" ]] && hint "Run: pip install openenv-core"
+    stop_at "Pre-flight"
+  fi
+done
+
+if ! docker info >/dev/null 2>&1; then
+  fail "Docker daemon is not running."
+  hint "Ensure Docker Desktop or the Docker Engine is active."
+  stop_at "Pre-flight"
+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 \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 20 || echo "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responding."
+else
+  fail "HF Space /reset returned $HTTP_CODE"
+  hint "Check if your Space is sleepy or still building."
+  stop_at "Step 1"
+fi
+
+log "${BOLD}Step 2/3: Running Docker Build${NC} (This may take a while)..."
+if [ -f "$REPO_DIR/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR"
+elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR/server"
+else
+  fail "No Dockerfile found."
+  stop_at "Step 2"
+fi
+
+BUILD_LOG=$(mktemp)
+(docker build -t openenv-test "$DOCKER_CONTEXT" > "$BUILD_LOG" 2>&1) &
+BUILD_PID=$!
+show_spinner "$BUILD_PID"
+wait "$BUILD_PID"
+
+if [ $? -eq 0 ]; then
+  pass "Docker build successful."
+else
+  fail "Docker build failed."
+  printf "${YELLOW}--- Build Error Snippet ---${NC}\n"
+  tail -n 15 "$BUILD_LOG"
+  hint "Full logs can be found at $BUILD_LOG"
+  stop_at "Step 2"
+fi
+
+log "${BOLD}Step 3/3: Running OpenEnv Validate${NC} ..."
+if (cd "$REPO_DIR" && openenv validate); then
+  pass "Schema validation passed."
+else
+  fail "openenv validate discovered structural errors."
+  stop_at "Step 3"
+fi
+
+printf "\n"
+printf "${GREEN}${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}   ALL CHECKS PASSED SUCCESSFULLY!      ${NC}\n"
+printf "${GREEN}${BOLD}   Your submission is ready for HF.     ${NC}\n"
+printf "${GREEN}${BOLD}========================================${NC}\n\n"
+
+exit 0