Initial commit: NeuralEdge AI Boardroom

.claude/skills/openenv-hackathon/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: openenv-hackathon
+description: Use this skill for ANY work on the Meta PyTorch × Hugging Face OpenEnv Hackathon submission (India finale, Scaler Bangalore, Apr 25–26 2026). Trigger whenever the user says "build", "audit", "review", "check", "deploy", or references the environment, training script, README, HF Space, Colab notebook, submission, or judging criteria. The submission must use OpenEnv (latest release, v0.2.3), be hosted on a Hugging Face Space, include a TRL- or Unsloth-based training script (ideally a Colab notebook), show reward/loss plots from a real training run, and ship with a README that links a <2-min YouTube video or a mini-blog on HF. Judging is weighted 40% Environment Innovation / 30% Storytelling / 20% Reward Improvement Evidence / 10% Reward & Training Pipeline.
+---
+
+# OpenEnv Hackathon — Build & Audit Skill
+
+## 1. Hackathon Calendar (hard deadlines)
+
+| When | What | Where |
+|---|---|---|
+| **Apr 25, 11:30 AM IST** | Hacking begins | Scaler School of Technology, Bangalore — classrooms |
+| **Apr 25, 3:30 PM IST** | Mentor Round 1 | Classrooms |
+| **Apr 25, 8:00 PM IST** | Mentor Round 2 | Classrooms |
+| **Apr 26, 10 AM – 12 PM IST** | Mentor Round 3 (final) | Classrooms |
+| **Apr 26, 12:00 PM IST** | 5-hour submission reminder | Classrooms |
+| **Apr 26, 3:00 PM IST** | 2-hour submission reminder | Classrooms |
+| **Apr 26, 5:00 PM IST** | **SUBMISSION DEADLINE** — Google Form | — |
+| **Apr 26, 5:15 PM IST** | Closing remarks | Main Stage |
+| **Apr 26, 8:00 PM IST** | Event concludes | Near Main Stage |
+
+**Rule**: Changes or commits to the HF Space URL after the deadline are ignored. Whatever is live at 5 PM IST on Apr 26 is what gets judged.
+
+## 2. Submission bundle (non-negotiable)
+
+A submission missing ANY of these is "at a serious disadvantage". The Google Form on Apr 26 asks for:
+
+1. **Hugging Face Space URL** — the environment, deployed via `openenv push`. Must be PUBLIC.
+2. **Colab notebook link** — training script that judges can re-run.
+3. **Code repository link** — GitHub (or HF Hub repo). Include every file.
+4. **YouTube video URL OR Hugging Face blog post URL** — the story. Video ≤ 2 minutes.
+5. **README in the repo** — must link the Space, the Colab, the video/blog, and any slides. README is the judge's entry point.
+
+Every URL also lives in the README. No large video files inside the Env HF Space — reference by URL.
+
+## 3. The five themes (pick one; Theme 5 is the wildcard)
+
+| # | Theme | Teaches the LLM to… | Example problems |
+|---|---|---|---|
+| 1 | **Multi-Agent Interactions** | Cooperate, compete, negotiate, form coalitions; model others' beliefs (theory-of-mind) in partially observable settings. | Market simulations, compute-allocation negotiations, collaborative puzzle worlds, mixed coop/competitive games. |
+| 2 | **(Super) Long-Horizon Planning & Instruction Following** | Decompose goals, track state across long trajectories beyond context limits, recover from early mistakes, handle sparse/delayed rewards. | Research-planning simulators, large-codebase refactoring, strategic resource management, logistics optimization, 300-instruction-scatter tasks. |
+| 3.1 | **World Modeling — Professional Tasks** | Maintain internal state, update beliefs from outcomes, orchestrate multi-step workflows with real APIs/tools (no shortcuts). | Dynamic browser/API ecosystems, enterprise apps, scientific workflows (papers → code → experiments), tool-discovery benchmarks. |
+| 3.2 | **World Modeling — Personalized Tasks** | Handle realistic personal delegation: messages, conflicts, scheduling, shopping. | Exec-assistant meeting planner, dinner/drive planning, tough email replies. |
+| 4 | **Self-Improvement** | Generate new challenges, escalate difficulty, self-play, adaptive curricula — recursive skill amplification. | Self-play negotiation arenas, auto-generated math/proofs, evolving coding competitions, adaptive RL curricula. |
+| 5 | **Wild Card — Impress Us** | Anything outside the boxes above that meaningfully trains an LLM capability. | — |
+
+**Theme selection rule**: Round-1 problem is NOT required. Pick what best fits one of the themes AND excites the team — judges can tell when energy is real.
+
+See [reference/05-theme-selection.md](reference/05-theme-selection.md) for a 60-minute ideation protocol and per-theme shortcut candidates.
+
+## 4. Judging rubric (memorize these weights)
+
+| Weight | Criterion | What it really means | How I bias toward this when building |
+|---|---|---|---|
+| **40%** | Environment Innovation | Novel, creative, genuinely challenging. Tests agent behavior in a way that hasn't been done. | Push originality over polish. Avoid chess/snake/tic-tac-toe/grid clones. Ask: "Could a researcher write a paper on training against this?" |
+| **30%** | Storytelling & Presentation | Clear problem statement; engaging demo; non-technical audience can follow. | README reads in 3–5 min. Video ≤ 2 min. Before/after agent behavior on screen. |
+| **20%** | Showing Improvement in Rewards | Observable evidence: reward curves, metrics, before/after, baseline vs. trained on the same axes. | Train long enough that curves mean something. Commit `.png` plots to the repo. Caption each plot in the README. |
+| **10%** | Reward & Training Pipeline | Reward logic is coherent, hard to game; pipeline produces real improvement in trained-agent behavior. | Compose Rubrics thoughtfully. Dense signal > 0/1-at-end. Test reward manually (random baseline should NOT score high). |
+
+Innovation + Storytelling is **70%** of the score. A messy but ambitious env with real training evidence beats a polished but boring one — the rules state this explicitly.
+
+See [reference/04-judging-rubric-playbook.md](reference/04-judging-rubric-playbook.md) for per-criterion tactics and anti-patterns.
+
+## 5. Tech stack (what to build with)
+
+| Layer | Pick | Why |
+|---|---|---|
+| Environment framework | **OpenEnv v0.2.3** (`pip install openenv-core`) | Mandatory. Use `Environment` or `MCPEnvironment` base class, Gym-style API. |
+| Training framework | **HF TRL `GRPOTrainer`** with `environment_factory=` | Official OpenEnv ↔ TRL integration (docs: [huggingface.co/docs/trl/openenv](https://huggingface.co/docs/trl/openenv)). |
+| Speed/memory | **Unsloth** (optional, strongly recommended for Colab T4) | 2× speed, up to 70% memory cut; supports GRPO/GSPO/DPO on free Colab. |
+| Base model | Start with **Qwen3-0.6B** or **Qwen3-1.7B** | Used in official examples; small enough for Colab, big enough to show learning. |
+| Hosting | **Hugging Face Space** (via `openenv push`) | Mandatory. Space must be public and runnable. |
+| Notebook | **Google Colab** | Judges need to re-run it. Use `uv run` or a pip install cell that works in fresh Colab. |
+| Writeup | **HF blog post** OR **YouTube ≤ 2 min** | Mandatory. Link from README. |
+
+See [reference/01-openenv-framework.md](reference/01-openenv-framework.md) for the full directory layout, file templates, openenv.yaml fields, and push workflow.
+See [reference/02-training-pipeline.md](reference/02-training-pipeline.md) for a runnable TRL-GRPO training recipe tuned for Colab T4.
+
+## 6. What I do when the user says "build"
+
+The scope is inferred from the stated target. In order:
+
+1. **Confirm theme + problem statement** in one sentence before writing code. If ambiguous, ask. Don't silently assume.
+2. **Name the env** snake_case (e.g., `dinner_negotiator_env`). Create it via `openenv init <name>_env --output-dir envs` — do not hand-roll the scaffold.
+3. **Fill the four files** in this order: `models.py` (Action / Observation / State dataclasses) → `server/<env>_environment.py` (core logic: `reset`, `step`, optional `state`) → `server/app.py` (FastAPI wiring via `create_app` or `create_server`) → `client.py` (thin `EnvClient` subclass).
+4. **Update `openenv.yaml`** with `spec_version: 1`, `name`, `type`, `runtime`, `app`, `port`. No reserved MCP tool names (`reset`, `step`, `state`, `close`).
+5. **Set `SUPPORTS_CONCURRENT_SESSIONS = True`** on the Environment class AND pass `max_concurrent_envs=64` (or ≥ `generation_batch_size`) to `create_app`. Without this, training will fail with WebSocket capacity errors.
+6. **Design the reward** with OpenEnv Rubrics when possible: composable, dense, hard to game. Test with a random-policy baseline BEFORE writing the training script — the baseline should score noticeably worse than a competent agent.
+7. **Smoke-test locally** with Docker (`openenv init` produces a Dockerfile — use it). Verify `reset()` / `step()` work and reward is sensible over ~20 random episodes.
+8. **Deploy**: `openenv push --repo-id <user>/<env-name>`. Confirm the Space is live at `https://<user>-<env-name>.hf.space/health`.
+9. **Write the training script** as a Colab notebook using `GRPOTrainer(environment_factory=MyEnv, ...)`. Use Qwen3-0.6B unless the user specifies otherwise. Log to W&B or at minimum save `.png` plots.
+10. **Run the training** to produce real reward/loss curves. Commit the plots as `assets/reward_curve.png`, `assets/loss_curve.png` in the repo.
+11. **Write the README** — see [reference/03-submission-checklist.md](reference/03-submission-checklist.md) for the required-sections list and tone.
+
+At each step, I report what was done in one line and move on.
+
+## 7. What I do when the user says "audit"
+
+An audit is read-only until the user asks me to fix. I check the submission bundle against the rubric and report gaps as a prioritized list. My audit always covers, in this order:
+
+1. **Submission completeness** — all 5 bundle items present and linked from the README? (See [reference/03-submission-checklist.md](reference/03-submission-checklist.md).)
+2. **OpenEnv compliance** — uses v0.2.3; `Environment` or `MCPEnvironment` base; Gym-style `reset/step/state`; valid `openenv.yaml`; no reserved tool names; client/server separation (client never imports server internals).
+3. **HF Space health** — `openenv push` succeeded; `/health` returns 200; `/docs` loads; `SUPPORTS_CONCURRENT_SESSIONS` and `max_concurrent_envs` set for training.
+4. **Reward signal** — dense (not just 0/1 at terminal), hard to game. Flag any reward that a random agent could exploit for points without solving the task.
+5. **Training evidence** — reward curve exists, has >1 clearly-visible step of improvement, is committed as a real image file (not only in a deleted Colab cell / W&B run), baseline is on the same axes as the trained run.
+6. **README storytelling** — problem / environment / results / why-it-matters sections present; readable in 3–5 min; plots captioned.
+7. **Repo hygiene** — no leaked secrets (HF_TOKEN, WANDB_API_KEY), no large video files in the HF Space (reference by URL), no build artifacts/venvs committed.
+
+I report findings as: **[SEVERITY] finding — fix**. Severities: `CRITICAL` (submission disqualifier), `HIGH` (likely to cost >10 rubric pts), `MED` (polish), `LOW` (nice-to-have).
+
+## 8. Hard rules (things I will refuse to do or strongly push back on)
+
+- **Don't submit without a real training run.** "Training script exists" is NOT the bar. The bar is "connects to the environment, agent learns, plots prove it." If the user asks to skip training, I push back once and then flag it as a CRITICAL audit finding.
+- **Don't clone chess / snake / tic-tac-toe / grid-world.** Judges have seen them. If the user proposes one, I recommend an angle that makes it genuinely novel (e.g., a meta-learning wrapper, a compositional reward, a new modality).
+- **Don't use `WidthType.PERCENTAGE`, reserved MCP tool names, or `Percentage` width in docx tables** if we write docs.
+- **Don't commit `.env` / `HF_TOKEN` / `WANDB_API_KEY`.** Use `huggingface_hub.login()` in Colab, read from env vars elsewhere.
+- **Don't amend commits after submission.** The URL is frozen at deadline — a post-deadline commit is equivalent to submitting a different artifact.
+- **Don't bloat the HF Space with video files.** Link to YouTube/HF blog instead.
+- **Don't mock the environment in training.** If `environment_factory` is set, the training loop MUST hit the real Space (or a local Docker of it) — a static dataset disqualifies criterion #3 (20%).
+
+## 9. Directory structure this skill assumes
+
+```
+OpenEnv Hackathon/
+├── .claude/skills/openenv-hackathon/
+│   ├── SKILL.md                      # this file
+│   └── reference/
+│       ├── 01-openenv-framework.md   # env anatomy, API, openenv.yaml, push
+│       ├── 02-training-pipeline.md   # TRL-GRPO Colab recipe
+│       ├── 03-submission-checklist.md
+│       ├── 04-judging-rubric-playbook.md
+│       └── 05-theme-selection.md     # theme fit analysis + ideation protocol
+├── envs/
+│   └── <env_name>_env/               # the OpenEnv env — scaffolded by `openenv init`
+├── notebooks/
+│   └── train_grpo.ipynb              # the Colab judges will re-run
+├── assets/
+│   ├── reward_curve.png
+│   └── loss_curve.png
+├── README.md                         # the judge's entry point — links EVERYTHING
+└── requirements.txt
+```
+
+## 10. External skills / tools the team needs
+
+**Claude Code skills to use during the hackathon:**
+
+- `anthropic-skills:pptx` — if the submission includes a slide deck (allowed as a writeup format).
+- `frontend-design` — if building a demo web UI for the environment or a landing page.
+- `python-performance-optimization` — profile training if reward curves plateau due to env-step latency (common on HF Spaces).
+- `review` — self-review the diff before final push.
+- `security-review` — final pass for leaked tokens / keys before making the repo public.
+
+**External tools & accounts required (set up BEFORE Apr 25 morning):**
+
+- Python 3.11+ and Docker Desktop installed locally.
+- Hugging Face account + write token (`hf auth login`).
+- `pip install openenv-core>=0.2.3 trl unsloth wandb`.
+- Google Colab account (free T4 is enough for Qwen3-0.6B; Pro is better for 1.7B).
+- Weights & Biases account (optional but highly recommended — gives judges a shareable run URL).
+- GitHub account (public repo for the code link).
+- YouTube channel (for the ≤2-min video) OR HF account with blog posting enabled.
+
+**Technical competencies the team should have reviewed:**
+
+- OpenEnv's Gymnasium-style API (`reset`, `step`, `state`) — see [reference/01-openenv-framework.md](reference/01-openenv-framework.md).
+- GRPO algorithm intuition (group relative policy optimization — compares completions within a group; relative ranking > absolute values).
+- Basic LoRA/PEFT for Unsloth fine-tuning on Colab.
+- FastAPI basics (openenv init gives you the server scaffold, but you may need to extend it).
+- Docker basics for local Space testing.
+
+## 11. Reference files
+
+Each of these is loaded only when relevant — keep SKILL.md lean.
+
+- **[reference/01-openenv-framework.md](reference/01-openenv-framework.md)** — Directory layout; models.py / environment.py / app.py / client.py templates; full openenv.yaml; `openenv init` / `openenv push` CLI; concurrency setup; common pitfalls.
+- **[reference/02-training-pipeline.md](reference/02-training-pipeline.md)** — Complete TRL-GRPO Colab notebook recipe; Unsloth wiring; reward-function patterns; multi-environment training; plot generation; W&B logging.
+- **[reference/03-submission-checklist.md](reference/03-submission-checklist.md)** — The final Apr 26 audit list; README template; sample commit structure; pre-deadline smoke tests.
+- **[reference/04-judging-rubric-playbook.md](reference/04-judging-rubric-playbook.md)** — Tactics per criterion; what scores high on Innovation (40%); storytelling heuristics; training-evidence standards; anti-patterns.
+- **[reference/05-theme-selection.md](reference/05-theme-selection.md)** — Theme-by-theme fit analysis; shortcut candidates per theme; decision framework for the first 90 minutes on Apr 25.
+
+---
+
+**Source documents indexed by this skill:**
+- `C:\Users\vitta\Downloads\[External] Apr '26 OpenEnv Hackathon Themes & Judging Criteria.docx` — authoritative rules.
+- `C:\Users\vitta\Downloads\Meta Hackathon D-DAY.pptx` — Day-1/Day-2 event schedule.
+- [huggingface.co/docs/trl/openenv](https://huggingface.co/docs/trl/openenv) — TRL ↔ OpenEnv integration.
+- [github.com/meta-pytorch/OpenEnv](https://github.com/meta-pytorch/OpenEnv) — framework source, v0.2.3.
+- [github.com/huggingface/openenv-course](https://github.com/huggingface/openenv-course) — 5-module tutorial.

.claude/skills/openenv-hackathon/reference/01-openenv-framework.md

@@ -0,0 +1,284 @@
+# OpenEnv Framework Reference
+
+OpenEnv v0.2.3 (released Mar 28 2026). Install: `pip install "openenv-core>=0.2.3"`.
+
+## 1. The 3 APIs
+
+All OpenEnv environments expose the Gymnasium-style trio:
+
+| Method | Purpose | Returns |
+|---|---|---|
+| `reset(seed=None, episode_id=None, **kwargs)` | Start a new episode. | Initial `Observation` |
+| `step(action, timeout_s=None, **kwargs)` | Apply one `Action`. | `Observation`, reward, done |
+| `state()` | Metadata snapshot (episode_id, step_count, etc.) | `State` |
+
+The client side mirrors this with both async and sync wrappers:
+
+```python
+# async (preferred)
+async with EchoEnv(base_url="https://...hf.space") as env:
+    obs = await env.reset()
+    obs = await env.step(EchoAction(message="hi"))
+
+# sync
+with EchoEnv(base_url="https://...hf.space").sync() as env:
+    obs = env.reset()
+    obs = env.step(EchoAction(message="hi"))
+```
+
+## 2. Two environment archetypes
+
+**Typed step/reset (default)** — you define explicit `Action`/`Observation` dataclasses and implement `step(action)`. Use when actions are structured and enumerable (moves, choices, form submissions).
+
+**MCP tool environment** — extend `MCPEnvironment`; the environment exposes named tools (e.g., `search`, `open_file`, `send_email`). Use when the agent should discover and call a set of tools. TRL's `environment_factory` loop automatically exposes every public method as an MCP-style tool.
+
+## 3. Directory layout (what `openenv init <name>_env` produces)
+
+```
+<name>_env/
+├── openenv.yaml               # manifest
+├── pyproject.toml             # package metadata + deps
+├── README.md
+├── Dockerfile                 # container for the HF Space
+├── requirements.txt
+├── client.py                  # class <Name>Env(EnvClient)
+├── models.py                  # Action, Observation, State dataclasses
+└── server/
+    ├── __init__.py
+    ├── <name>_environment.py  # class <Name>Environment(Environment[...])
+    └── app.py                 # FastAPI wiring via create_app(...)
+```
+
+Scaffold the whole thing with:
+
+```bash
+openenv init my_env_env --output-dir envs
+```
+
+Do NOT hand-roll the directory — the scaffold format changes across versions.
+
+## 4. `openenv.yaml` — full example
+
+```yaml
+spec_version: 1
+name: dinner_negotiator_env
+type: environment                # or mcp_environment
+version: "0.1.0"
+description: >
+  Multi-agent dinner-planning negotiation where the LLM must reconcile
+  dietary restrictions, budget, and scheduling conflicts across 3 family
+  members with hidden preferences.
+
+runtime:
+  python: "3.11"
+  dependencies:
+    - openenv-core>=0.2.3
+    - fastapi
+    - pydantic
+
+app:
+  module: server.app
+  factory: app                    # FastAPI ASGI app object
+  host: 0.0.0.0
+  port: 8000
+
+max_concurrent_envs: 64           # ≥ generation_batch_size for TRL training
+```
+
+Fields `spec_version`, `name`, `type`, `runtime`, `app`, `port` are required.
+
+## 5. Template — `models.py`
+
+```python
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class MyAction:
+    """Structured action from the agent."""
+    move: str
+    target: Optional[str] = None
+
+@dataclass
+class MyObservation:
+    """What the agent sees after each step."""
+    text: str
+    reward: float = 0.0
+    done: bool = False
+    info: dict = field(default_factory=dict)
+
+@dataclass
+class MyState:
+    """Episode metadata (returned by state())."""
+    episode_id: str
+    step_count: int
+    target: str
+    remaining_turns: int
+```
+
+## 6. Template — `server/<name>_environment.py`
+
+```python
+import random, uuid
+from typing import Optional
+
+try:
+    from openenv.core import Environment
+except ImportError:
+    from openenv_core import Environment  # dual-import pattern for Docker
+
+from ..models import MyAction, MyObservation, MyState
+
+class MyEnvironment(Environment[MyAction, MyObservation, MyState]):
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True   # REQUIRED for TRL training
+
+    def __init__(self, max_turns: int = 10):
+        self.max_turns = max_turns
+        self._reset_state()
+
+    def _reset_state(self):
+        self._episode_id = str(uuid.uuid4())[:8]
+        self._step_count = 0
+        self._remaining = self.max_turns
+        self._target = random.choice(["alpha", "bravo", "charlie"])
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None,
+              **kwargs) -> MyObservation:
+        if seed is not None:
+            random.seed(seed)
+        self._reset_state()
+        if episode_id:
+            self._episode_id = episode_id
+        return MyObservation(
+            text=f"New episode. Pick one of: alpha | bravo | charlie. {self._remaining} turns left.",
+        )
+
+    def step(self, action: MyAction, timeout_s: Optional[float] = None,
+             **kwargs) -> MyObservation:
+        self._step_count += 1
+        self._remaining -= 1
+
+        correct = action.move == self._target
+        done = correct or self._remaining <= 0
+        reward = 1.0 if correct else (-0.1 if done else 0.0)
+
+        if correct:
+            text = f"Correct! Target was {self._target}."
+        elif done:
+            text = f"Out of turns. Target was {self._target}."
+        else:
+            text = f"Wrong. {self._remaining} turns left."
+
+        return MyObservation(text=text, reward=reward, done=done,
+                             info={"step": self._step_count})
+
+    def state(self) -> MyState:
+        return MyState(
+            episode_id=self._episode_id,
+            step_count=self._step_count,
+            target=self._target,
+            remaining_turns=self._remaining,
+        )
+```
+
+**Key rules:**
+- `SUPPORTS_CONCURRENT_SESSIONS = True` — MUST be set for TRL training; otherwise only 1 WebSocket connects.
+- Use `try/except` dual import — Docker runs from a different module root than the repo.
+- Never use `reset`, `step`, `state`, `close` as MCP tool names — they collide with the base API.
+
+## 7. Template — `server/app.py`
+
+```python
+try:
+    from openenv.server import create_app
+except ImportError:
+    from openenv_core.server import create_app
+
+from .my_environment import MyEnvironment
+from ..models import MyAction, MyObservation
+
+app = create_app(
+    environment_factory=lambda: MyEnvironment(max_turns=10),
+    action_type=MyAction,
+    observation_type=MyObservation,
+    max_concurrent_envs=64,     # match or exceed generation_batch_size
+)
+```
+
+## 8. Template — `client.py`
+
+```python
+try:
+    from openenv.client import EnvClient
+except ImportError:
+    from openenv_core.client import EnvClient
+
+from .models import MyAction, MyObservation, MyState
+
+class MyEnv(EnvClient[MyAction, MyObservation, MyState]):
+    ACTION_TYPE = MyAction
+    OBSERVATION_TYPE = MyObservation
+    STATE_TYPE = MyState
+```
+
+Thin wrapper — the base class handles WebSocket, serialization, async/sync.
+
+## 9. Local testing (before push)
+
+```bash
+# from repo root
+pip install -e envs/my_env_env
+python -m uvicorn envs.my_env_env.server.app:app --host 0.0.0.0 --port 8001
+
+# in another shell
+python -c "
+from envs.my_env_env.client import MyEnv
+from envs.my_env_env.models import MyAction
+with MyEnv(base_url='http://0.0.0.0:8001').sync() as env:
+    print(env.reset())
+    print(env.step(MyAction(move='alpha')))
+"
+```
+
+Docker test (mirrors what the HF Space will run):
+
+```bash
+docker build -t my_env envs/my_env_env
+docker run -d -p 8001:8000 my_env
+curl http://localhost:8001/health    # expect 200 {"status": "ok"}
+```
+
+## 10. Push to HF Spaces
+
+```bash
+cd envs/my_env_env
+huggingface-cli login              # one-time
+openenv push --repo-id <user>/my_env_env
+# add --private to stage privately, then flip to public before submission
+```
+
+After push, verify:
+- `https://<user>-my-env-env.hf.space/health` → 200
+- `https://<user>-my-env-env.hf.space/docs` → FastAPI Swagger UI
+- `https://<user>-my-env-env.hf.space/web` → web UI (if enabled)
+
+## 11. Environment variables the Space respects
+
+| Var | Default | Use |
+|---|---|---|
+| `WORKERS` | 4 | Uvicorn worker processes |
+| `PORT` | 8000 | Internal port |
+| `HOST` | 0.0.0.0 | Bind address |
+| `MAX_CONCURRENT_ENVS` | 100 | WebSocket sessions cap |
+| `ENABLE_WEB_INTERFACE` | auto | Toggle `/web` UI |
+
+Set via HF Space → Settings → Variables & Secrets.
+
+## 12. Common pitfalls (cross-referenced from the official skill)
+
+- **Forgetting `SUPPORTS_CONCURRENT_SESSIONS`** → training hangs after first batch.
+- **Reserved MCP tool name** (`reset`/`step`/`state`/`close`) → silent conflict with base API.
+- **Client importing server internals** → import cycle at container start. Client must ONLY import from `models.py`.
+- **Committing build artifacts** (`__pycache__`, `.venv`, `dist/`) to the Space → slow push, bloated Space.
+- **Using `openenv push` without first testing Docker locally** → broken Space, debug-via-logs-only loop.
+- **Missing `xml:space="preserve"`** on docx edits (not relevant to env, noted only if generating docs).

.claude/skills/openenv-hackathon/reference/02-training-pipeline.md

@@ -0,0 +1,297 @@
+# Training Pipeline Reference (TRL + Unsloth, Colab-ready)
+
+The hackathon rubric is explicit: **reward-curve evidence is 20%** and **pipeline coherence is 10%** — so the training script must actually run end-to-end and produce plots. This file is the runnable recipe.
+
+## 1. Why GRPO (not PPO / DPO / SFT)
+
+- GRPO is what the official TRL ↔ OpenEnv integration is built around.
+- No separate reward model required — the environment IS the reward.
+- Works with small models (Qwen3-0.6B trains on free Colab T4).
+- Supports multi-turn tool-calling loops natively via `environment_factory=...`.
+
+## 2. Colab notebook skeleton
+
+Put the whole thing in `notebooks/train_grpo.ipynb`. Cells below:
+
+### Cell 1 — installs
+
+```python
+!pip install -q --upgrade \
+    "openenv-core>=0.2.3" \
+    "trl>=1.0" \
+    "transformers>=4.56" \
+    "accelerate" \
+    "peft" \
+    "datasets" \
+    "wandb" \
+    "unsloth"  # optional; huge speedup on T4
+
+# install your environment client
+!pip install -q "my-env @ git+https://huggingface.co/spaces/<user>/my_env_env"
+```
+
+### Cell 2 — auth
+
+```python
+import os
+from huggingface_hub import login
+from google.colab import userdata  # if on Colab
+
+login(token=userdata.get("HF_TOKEN"))
+os.environ["WANDB_API_KEY"] = userdata.get("WANDB_API_KEY")
+```
+
+**NEVER hardcode tokens in the notebook.** Use Colab Secrets (lock icon in left sidebar) or env vars.
+
+### Cell 3 — environment wrapper
+
+```python
+from my_env import MyEnv
+from my_env.models import MyAction
+
+ENV_URL = "https://<user>-my-env-env.hf.space"
+
+class MyToolEnv:
+    """Wrapper that exposes env methods as tool-callable functions for TRL."""
+
+    def __init__(self):
+        self.client = MyEnv(base_url=ENV_URL)
+        self.reward = 0.0
+        self.done = False
+
+    def reset(self, **kwargs) -> str | None:
+        result = self.client.reset()
+        self.reward = 0.0
+        self.done = False
+        return result.observation.text
+
+    def pick(self, choice: str) -> str:
+        """Make a choice in the environment.
+
+        Args:
+            choice: One of 'alpha', 'bravo', 'charlie'.
+
+        Returns:
+            Feedback message from the environment.
+        """
+        if self.done:
+            raise ValueError("Episode is over.")
+        result = self.client.step(MyAction(move=choice))
+        self.reward = result.reward
+        self.done = result.done
+        return result.observation.text
+```
+
+**Rules for the wrapper class:**
+- `__init__` takes no args other than `self`.
+- `reset(**kwargs)` receives dataset columns; returns str | None.
+- Every public method (not `_prefixed`) becomes a tool. Give them **specific names** (`guess`, `move`, `buy`, NOT `step`/`action`) — the model uses names to learn tool use.
+- Tool methods need docstrings with `Args:` / `Returns:` — TRL generates the tool schema from these.
+- Store reward/done on `self` — the reward function reads them later.
+- Raise `ValueError("...")` when the episode should end — TRL feeds the message back to the model as a tool response.
+
+### Cell 4 — reward function
+
+```python
+def reward_func(environments, **kwargs) -> list[float]:
+    """Called once per group after rollout. Returns one reward per env instance."""
+    return [env.reward for env in environments]
+```
+
+Guidance from the TRL OpenEnv docs:
+- **Binary (1.0 / 0.0) rewards often beat shaped rewards** for GRPO — relative ranking within the group matters more than absolute values.
+- **Score outcomes, not paths** — let the env judge success; don't check for specific action sequences.
+- **Sanity-test with a random policy before training** — if a random agent scores as high as a capable one, the reward is broken.
+
+### Cell 5 — dataset
+
+```python
+from datasets import Dataset
+
+system_prompt = """You are an agent interacting with the 'pick' environment.
+You have one tool: pick(choice). Call it with 'alpha', 'bravo', or 'charlie'.
+Only one choice is correct per episode. Use feedback from the environment to learn."""
+
+n = 500   # episodes per epoch
+dataset = Dataset.from_dict({
+    "prompt": [[{"role": "user", "content": system_prompt}]] * n
+})
+```
+
+For multi-env training, add an `"env"` column and route in `reset(**kwargs)` — see the TRL multi_env.py example.
+
+### Cell 6 — trainer
+
+```python
+from trl import GRPOConfig, GRPOTrainer
+
+config = GRPOConfig(
+    output_dir="./grpo_my_env",
+    num_train_epochs=1,
+    per_device_train_batch_size=1,
+    gradient_accumulation_steps=8,      # effective batch = 8
+    num_generations=4,                  # group size for GRPO
+    max_completion_length=1024,         # TOTAL tokens across multi-turn — raise for long episodes
+    use_vllm=True,
+    vllm_mode="colocate",               # single-GPU Colab
+    learning_rate=1e-6,
+    chat_template_kwargs={"enable_thinking": False},
+    log_completions=True,
+    report_to=["wandb"],
+    run_name="grpo-my-env-v1",
+    logging_steps=1,
+    save_steps=50,
+)
+
+trainer = GRPOTrainer(
+    model="Qwen/Qwen3-0.6B",
+    train_dataset=dataset,
+    reward_funcs=reward_func,
+    args=config,
+    environment_factory=MyToolEnv,     # pass the CLASS, not an instance
+)
+
+trainer.train()
+```
+
+### Cell 7 — Unsloth speedup (optional, ~2× faster on T4)
+
+Swap the model loader before constructing the trainer:
+
+```python
+from unsloth import FastLanguageModel
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="Qwen/Qwen3-0.6B",
+    max_seq_length=2048,
+    load_in_4bit=True,
+    dtype=None,
+)
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=16, lora_alpha=32, lora_dropout=0,
+    target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+    use_gradient_checkpointing="unsloth",
+)
+
+trainer = GRPOTrainer(
+    model=model,
+    tokenizer=tokenizer,                # pass the unsloth tokenizer
+    ... # same as before
+)
+```
+
+### Cell 8 — save plots as `.png` (REQUIRED for judging)
+
+```python
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# trainer.state.log_history is a list of dicts logged during training
+log = pd.DataFrame(trainer.state.log_history)
+
+# Reward curve (raw + smoothed)
+fig, ax = plt.subplots(figsize=(8, 4))
+if "reward" in log.columns:
+    ax.plot(log["step"], log["reward"], alpha=0.3, label="reward (raw)")
+    ax.plot(log["step"], log["reward"].rolling(20, min_periods=1).mean(), label="reward (smoothed)")
+ax.set_xlabel("training step")
+ax.set_ylabel("mean reward per group")
+ax.set_title("GRPO training — reward over time")
+ax.legend()
+plt.tight_layout()
+plt.savefig("assets/reward_curve.png", dpi=150)
+
+# Loss curve
+fig, ax = plt.subplots(figsize=(8, 4))
+if "loss" in log.columns:
+    ax.plot(log["step"], log["loss"], label="policy loss")
+ax.set_xlabel("training step")
+ax.set_ylabel("loss")
+ax.set_title("GRPO training — loss over time")
+ax.legend()
+plt.tight_layout()
+plt.savefig("assets/loss_curve.png", dpi=150)
+```
+
+Then commit both PNGs to the repo — judges MUST see them in the README.
+
+### Cell 9 — baseline-vs-trained comparison (scores high on rubric)
+
+```python
+import numpy as np
+
+def eval_model(model, n_episodes=50):
+    env = MyToolEnv()
+    rewards = []
+    for _ in range(n_episodes):
+        env.reset()
+        # ... run model for up to max_turns, collecting env.reward
+        rewards.append(env.reward)
+    return np.mean(rewards), np.std(rewards)
+
+base_mean, base_std = eval_model("Qwen/Qwen3-0.6B")
+trained_mean, trained_std = eval_model(trainer.model)
+
+print(f"baseline:  {base_mean:.3f} ± {base_std:.3f}")
+print(f"trained:   {trained_mean:.3f} ± {trained_std:.3f}")
+
+# plot on same axes
+fig, ax = plt.subplots(figsize=(6, 4))
+ax.bar(["baseline", "trained"], [base_mean, trained_mean],
+       yerr=[base_std, trained_std], capsize=6)
+ax.set_ylabel("mean episode reward (n=50)")
+ax.set_title("Before vs. after GRPO training")
+plt.tight_layout()
+plt.savefig("assets/before_after.png", dpi=150)
+```
+
+## 3. Concurrency — DO NOT SKIP
+
+TRL opens one WebSocket per generation. With `gradient_accumulation_steps=8` × `per_device_train_batch_size=1` × `num_generations=4` = 32 concurrent sessions. The Space must allow this.
+
+On the environment side:
+```python
+# server/<name>_environment.py
+class MyEnvironment(Environment[...]):
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+```
+```python
+# server/app.py
+app = create_app(..., max_concurrent_envs=64)
+```
+
+On the Space side (via HF Space → Settings → Variables):
+```
+MAX_CONCURRENT_ENVS=64
+WORKERS=2
+```
+
+**Always duplicate the Space to your own account before training.** Public shared Spaces get rate-limited.
+
+## 4. Colab T4 reality check
+
+- **Qwen3-0.6B** trains in ~30 min for a 500-episode Wordle-style task.
+- **Qwen3-1.7B** needs Colab Pro (A100) for a comparable run; T4 will OOM.
+- **Gradient accumulation** > 8 on T4 with Unsloth + LoRA.
+- **vLLM colocate mode** reclaims ~3 GB by sharing weights between gen and training.
+- Save checkpoints every 50 steps so a Colab disconnect doesn't nuke progress.
+
+## 5. What failure looks like, and how to recover fast
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| Training hangs after batch 1 | `SUPPORTS_CONCURRENT_SESSIONS=False` | Set True; redeploy. |
+| Reward flat at 0 the whole run | Reward function returns wrong key, or tool method never called | Log `env.reward` + `env.done` per episode in Cell 3. |
+| Reward saturates at 1.0 instantly | Reward is game-able (model finds shortcut) | Tighten env; add adversarial check; switch to binary terminal reward. |
+| W&B run disappears | Colab session timeout + no local save | Set `save_steps=50` and download `output_dir` as a tarball. |
+| `max_completion_length` exceeded errors | Episodes too long for the budget | Raise to 2048 or 4096; OR cap env turn count. |
+| OOM on T4 | Batch × group × seq too large | Lower `num_generations` to 2, or switch to Unsloth 4-bit. |
+
+## 6. Official reference implementations to clone from
+
+- **Echo** (simplest): [github.com/huggingface/trl/blob/main/examples/scripts/openenv/echo.py](https://github.com/huggingface/trl/blob/main/examples/scripts/openenv/echo.py)
+- **Wordle** (multi-turn, exception-based episode end): [github.com/huggingface/trl/blob/main/examples/notebooks/openenv_wordle_grpo.ipynb](https://github.com/huggingface/trl/blob/main/examples/notebooks/openenv_wordle_grpo.ipynb)
+- **Multi-env** (routing between 2 envs in one run): [github.com/huggingface/trl/blob/main/examples/scripts/openenv/multi_env.py](https://github.com/huggingface/trl/blob/main/examples/scripts/openenv/multi_env.py)
+
+When unsure about any pattern, open the Wordle notebook — it is the canonical example.

.claude/skills/openenv-hackathon/reference/03-submission-checklist.md

@@ -0,0 +1,140 @@
+# Submission Checklist (run this before 5 PM IST Apr 26)
+
+The Google Form on Apr 26 asks for: HF Space URL, Colab notebook link, code repo link, YouTube OR HF blog link. Every URL must ALSO be in the README.
+
+## Tier 1 — disqualifiers (run these first)
+
+- [ ] HF Space is **public** and `https://<user>-<env>.hf.space/health` returns 200.
+- [ ] The Space was deployed via `openenv push` (not hand-rolled).
+- [ ] The env uses `openenv-core >= 0.2.3`.
+- [ ] A Colab notebook link is included; clicking "Run all" on a fresh Colab works end-to-end.
+- [ ] The training script connects to the **real environment** (not a static dataset).
+- [ ] `reward_curve.png` (or equivalent) exists IN THE REPO (committed, not only in Colab).
+- [ ] README links: Space URL, Colab URL, video/blog URL, slide deck URL if any.
+- [ ] No HF_TOKEN / WANDB_API_KEY / other secrets committed anywhere.
+- [ ] No large video files in the Env HF Space (link to YouTube instead).
+
+## Tier 2 — rubric-boosters
+
+### Environment Innovation (40%)
+- [ ] The env is NOT a chess/snake/tic-tac-toe/grid-world clone.
+- [ ] One sentence explains what capability gap it targets.
+- [ ] A researcher could plausibly write a paper about training on it.
+- [ ] Reward is composed (OpenEnv Rubrics) not monolithic.
+
+### Storytelling & Presentation (30%)
+- [ ] README reads in 3–5 minutes for a non-technical reviewer.
+- [ ] Video is ≤ 2 minutes AND embeds/links from README.
+- [ ] README has 4 sections: Problem / Environment / Results / Why it matters.
+- [ ] Plots have captions explaining what the reviewer is looking at.
+- [ ] At least one before/after comparison (text or visual) of agent behavior.
+
+### Showing Improvement in Rewards (20%)
+- [ ] Reward curve shows a visible upward trend.
+- [ ] Baseline (random or untrained) is plotted ON THE SAME AXES as the trained run.
+- [ ] Training ran long enough that the curve has real signal (not 10 steps).
+- [ ] W&B public run link is in the README (or plots are committed as real PNGs).
+- [ ] Axes labeled: x = "training step" or "episode", y = "reward" or "loss", with units if applicable.
+
+### Reward & Training Pipeline (10%)
+- [ ] Reward is hard to game — a random agent cannot score well.
+- [ ] Pipeline is reproducible: `pip install -r requirements.txt && jupyter run notebooks/train_grpo.ipynb` works.
+- [ ] Uses TRL `GRPOTrainer` with `environment_factory=` (or justified alternative).
+- [ ] `SUPPORTS_CONCURRENT_SESSIONS=True` and `max_concurrent_envs ≥ generation_batch_size`.
+
+## Tier 3 — engineering hygiene
+
+- [ ] Client never imports from `server/` (verified by grep).
+- [ ] No reserved MCP tool names (`reset`, `step`, `state`, `close`).
+- [ ] `openenv.yaml` is the current v0.2.3 format (spec_version: 1, name, type, runtime, app, port).
+- [ ] `requirements.txt` pins major versions.
+- [ ] No `__pycache__`, `.venv`, `dist/`, `.env` in the repo.
+- [ ] LICENSE file present (recommend Apache-2.0 or MIT).
+
+## README template (paste and fill)
+
+```markdown
+# <Env Name> — OpenEnv Hackathon Submission
+
+> 1-sentence hook: what capability does this environment teach?
+
+## Links
+- **HF Space (the environment)**: https://<user>-<env>.hf.space
+- **Colab (training notebook)**: https://colab.research.google.com/drive/...
+- **Code repo**: https://github.com/<user>/<repo>
+- **Video (≤2 min)**: https://youtu.be/...
+- **Blog**: https://huggingface.co/blog/<user>/<slug>
+- **W&B training run**: https://wandb.ai/<user>/<project>/runs/...
+
+## Problem
+What capability gap does this target? Why is the current state of LLMs insufficient here? (2–3 sentences.)
+
+## Environment
+- **Theme**: Multi-Agent / Long-Horizon / World Modeling / Self-Improvement / Wild Card
+- **Agent observes**: …
+- **Agent acts by**: …
+- **Reward signal**: …
+- **Episode ends when**: …
+
+## Quick start
+```bash
+pip install "my-env @ git+https://huggingface.co/spaces/<user>/<env>"
+```
+```python
+from my_env import MyEnv
+from my_env.models import MyAction
+with MyEnv(base_url="https://<user>-<env>.hf.space").sync() as env:
+    print(env.reset())
+    print(env.step(MyAction(move="alpha")))
+```
+
+## Results
+
+![Reward curve](assets/reward_curve.png)
+*Mean group reward over training steps. Qwen3-0.6B trained with GRPO for 500 steps.*
+
+![Before vs after](assets/before_after.png)
+*Mean episode reward (n=50) before and after training. Error bars = 1σ.*
+
+| Metric | Baseline (random) | Untrained Qwen3-0.6B | Trained Qwen3-0.6B |
+|---|---|---|---|
+| Mean reward | 0.04 | 0.12 | 0.78 |
+| Success rate | 4% | 12% | 78% |
+
+## Training recipe
+- Model: Qwen/Qwen3-0.6B
+- Algorithm: GRPO (TRL v1.0+)
+- Compute: 1× T4 on Colab
+- Training time: ~30 min
+- Episodes: 500
+
+See [notebooks/train_grpo.ipynb](notebooks/train_grpo.ipynb) for the full pipeline.
+
+## Why this matters
+Who benefits from an LLM trained on this? What can the resulting agent do that an untrained one cannot? (2–3 sentences.)
+
+## Team
+<names, colleges, contact>
+```
+
+## Video (≤2 min) — storyboard template
+
+| 0:00–0:15 | Hook — show an LLM failing at the task |
+| 0:15–0:45 | Explain the environment in one sentence; show the agent's observation/action |
+| 0:45–1:15 | Show the reward curve going up |
+| 1:15–1:45 | Show the trained agent succeeding at the task |
+| 1:45–2:00 | Call to action — "try it at <HF Space URL>" |
+
+Record on OBS / Loom; upload unlisted to YouTube; paste URL in README.
+
+## Final commit discipline
+
+```bash
+git status                    # confirm no secrets / artifacts
+git add README.md assets/ notebooks/ envs/
+git commit -m "final submission: <env-name>"
+git push origin main
+# don't touch the HF Space URL after the deadline
+```
+
+Then fill the Google Form with the 4 URLs. The README URL is fine as the "code repo link".

.claude/skills/openenv-hackathon/reference/04-judging-rubric-playbook.md

@@ -0,0 +1,102 @@
+# Judging Rubric Playbook — How to score high
+
+Rubric weights, verbatim from the hackathon rules:
+
+| Weight | Criterion |
+|---|---|
+| **40%** | Environment Innovation — Is the environment novel, creative, or genuinely challenging? Does it meaningfully test agent behavior in a way that hasn't been done before? |
+| **30%** | Storytelling & Presentation — Can you clearly explain the problem, the environment, and what the agent learned? Is the demo engaging and easy to follow for a non-technical audience? |
+| **20%** | Showing Improvement in Rewards — Is there observable evidence of training progress? Reward curves, before/after behavior, comparison against a baseline. |
+| **10%** | Reward & Training Pipeline — Is the reward logic coherent? Does the pipeline produce meaningful improvement in the trained agent's behavior? |
+
+## Innovation (40%) — the biggest lever
+
+**The official rule: "Judges have seen a lot of chess, snake, tic-tac-toe, and grid-world clones."** Do not ship one.
+
+### Questions the rules tell you to ask yourself
+1. Does this environment exist to teach an LLM something it currently can't do well?
+2. Is the domain underexplored in RL/LLM training?
+3. Could a researcher write a paper about training on this?
+
+### High-innovation patterns that match the themes
+- **Partially observable negotiation** (Theme 1) where each agent has private info — e.g., dinner planning with hidden allergies/budgets.
+- **Tool-discovery benchmarks** (Theme 3.1) where the agent must read API docs at runtime and figure out which tool applies.
+- **300-instruction instruction-following** scattered across a long document (Theme 2) — tests selective attention and durable memory.
+- **Self-play curriculum generation** (Theme 4) where the env generates harder variants of whatever task the agent is currently solving.
+- **Real-personal-delegation** (Theme 3.2) — e.g., the agent receives a realistic Slack-style thread with 3 people proposing 5 meeting times, must pick one and reply to everyone.
+
+### Anti-innovation (avoid)
+- Classic games with cosmetic reskin.
+- Single-turn QA / classification dressed up as an env.
+- Anything where the "environment" is actually just a frozen dataset with a scoring function.
+- Reward = string-match against a ground-truth answer (doesn't need an env).
+
+## Storytelling (30%)
+
+### What the README must do
+- **Open with a hook in ≤20 words.** "This env teaches an LLM to negotiate dinner plans across 3 people with conflicting dietary restrictions and hidden preferences."
+- **Show, don't tell.** Before/after behavior transcript beats prose.
+- **Name the audience.** "This matters to anyone building personal-assistant LLMs that handle real delegation."
+- **Embed plots inline** with one-line captions.
+- **Link everything from the top** — Space, Colab, video, blog, W&B run.
+
+### What the video (≤2 min) must do
+- **Open with failure.** Untrained model doing something dumb.
+- **Show the env's rules in one visual.** Observation → action → reward diagram.
+- **Show the reward curve going up.**
+- **Show the trained model succeeding.**
+- **End with a URL** the viewer can click.
+
+### Storytelling anti-patterns
+- API docs masquerading as a README.
+- Pure prose with no images.
+- Video that explains the code instead of the capability.
+- Demo that needs narration to understand what's happening on screen.
+
+## Reward-improvement evidence (20%)
+
+### Minimum viable evidence
+- Reward curve committed as `assets/reward_curve.png` with captioned embed in README.
+- Loss curve also helpful (proves the training actually updated weights).
+- Baseline on the SAME AXES as the trained run — a single line going up is easy to dismiss.
+- Explicit numbers: "baseline 4% success → trained 78% success (n=50)".
+
+### Patterns that separate top-10% from median
+- **W&B public run link** in the README → reviewers can dig into any metric.
+- **Ablation plot**: trained with reward v1 vs reward v2 vs random baseline, all on one axis.
+- **Qualitative transcript**: one full agent trajectory before training, one after — side-by-side.
+- **Multiple seeds**: 3 runs with error bars, not 1.
+
+### Traps that score 0 on this criterion
+- Reward curve only exists in a deleted W&B run.
+- Plot saved only in a Colab cell (disappears when Colab times out).
+- Curve flat or noisy with no smoothed trendline.
+- No baseline for comparison.
+- 10 training steps — "noise, not signal".
+
+## Reward & pipeline coherence (10%)
+
+### What "coherent reward" means
+- **Dense informative signal** — not just 0/1 at the terminal state. OR, if 0/1, it's a hard problem where that's appropriate.
+- **Composable via OpenEnv Rubrics** — multiple sub-rubrics combined, not one monolithic score.
+- **Hard to game** — test by running a random agent; if it scores near the trained agent, reward is broken.
+
+### What "coherent pipeline" means
+- `environment_factory=` wired correctly; generation → tool parse → env step → reward → training — all handled by TRL.
+- Concurrency configured: `SUPPORTS_CONCURRENT_SESSIONS=True` on env, `max_concurrent_envs ≥ generation_batch_size` on the app.
+- Tool methods have docstrings with `Args:` blocks (TRL uses these to build the tool schema).
+- Tool names are **specific** (`guess`, `negotiate`, `buy`) — not generic (`step`, `act`).
+
+### Red flags
+- Custom rollout loop when `environment_factory` would have worked (the rubric favors the standard pattern).
+- Reward hacked by a hard-coded regex against the model's output.
+- Training against a mocked env (disqualifies the criterion — must hit the real deployed Space or a local Docker).
+
+## The 70% that's actually under your control
+
+Innovation (40%) + Storytelling (30%) = **70% of the score**, and both are set mostly by Day-1 decisions:
+
+1. **Pick the right problem by noon on Apr 25.** A bad problem with great execution still caps around the median.
+2. **Draft the README hook and 2-min video storyboard before you write any env code.** If you can't explain it in one sentence, it's not ambitious enough yet.
+3. **Build the smallest viable env first, then iterate on innovation.** It's better to have a shippable boring env + a clear story than a brilliant env you couldn't deploy.
+4. **Record the video on Apr 26 morning, not at 4:55 PM.** Leave 90 minutes for recording + upload.

.claude/skills/openenv-hackathon/reference/05-theme-selection.md

@@ -0,0 +1,53 @@
+# Theme Selection — Decision Framework for the First 90 Minutes on Apr 25
+
+The hackathon explicitly allows picking a NEW problem at the finale — Round-1 entries are not required. The first 90 minutes is the single highest-leverage window of the whole event.
+
+## Decision tree
+
+```
+Do we have a concrete problem that clearly fits one of Themes 1–4 or 5?
+├── YES → lock it in. Go to OpenEnv scaffold.
+└── NO  → run the 60-min ideation below, then decide.
+```
+
+## 60-minute ideation protocol
+
+**Minute 0–15 — read the themes aloud to the team.** One person reads, others note any phrase that sparks an idea. Don't filter yet.
+
+**Minute 15–30 — write one-sentence problem statements**, one per sticky note. Format: `"An environment that teaches an LLM to ___ by ___"`. Aim for 10–15 candidates.
+
+**Minute 30–45 — score each on 3 axes (1–5 each):**
+- **Novelty** — has a judge seen this before? (5 = never, 1 = clone)
+- **Shippability in 30h** — can we deploy this by 5 PM tomorrow? (5 = trivial, 1 = heroic)
+- **Reward learnability** — can a 0.6B–1.7B model actually improve on it in 30 min of Colab? (5 = yes, 1 = needs a 70B)
+
+**Minute 45–60 — pick the highest total.** Ties broken by team excitement (the rules explicitly say this).
+
+## Shortcut candidates per theme (research-done for you)
+
+### Theme 1 — Multi-Agent Interactions
+- **Hidden-role party negotiator** — 4 LLM "guests" with hidden dietary/budget constraints must agree on a restaurant in ≤5 turns. The agent-under-training is one of them. Reward = Pareto-optimality of the agreement.
+- **Compute allocator** — N services bid for shared GPU time under changing priority. Agent-under-training learns to negotiate SLAs.
+
+### Theme 2 — Long-Horizon Planning
+- **300-instruction document follower** — a fake product spec has 300 tiny requirements scattered across 50 pages. Agent must produce output that satisfies ≥K of them. Tests durable internal representation.
+- **Research-plan simulator** — agent drafts a research plan, gets fake "reviewer feedback" across 10 rounds, must incorporate it.
+
+### Theme 3.1 — World Modeling, Professional
+- **Tool-discovery env** — agent is given an undocumented API with 50 endpoints and must figure out how to accomplish a task through experimentation. Reward = success with minimum API calls.
+- **Scientific-workflow loop** — paper → extracted hypothesis → pseudo-code → pseudo-experiment result → next paper. Agent learns to iterate.
+
+### Theme 3.2 — World Modeling, Personal
+- **Inbox-triage env** — 20 emails arrive; agent must reply-all / reply-one / archive / snooze / delegate. Reward = combined latency + correctness per sender.
+- **Calendar conflict resolver** — three colleagues propose 5 meeting times each; agent replies to each with the one that works for everyone.
+
+### Theme 4 — Self-Improvement
+- **Proof-difficulty escalator** — agent generates math problems, tries to solve them, gets harder problems when it succeeds. Reward = steady-state difficulty reached.
+- **Self-adversarial Wordle** — one agent proposes words, another tries to guess; roles rotate. Both improve.
+
+### Theme 5 — Wild Card
+Use sparingly. Only if the idea doesn't map to 1–4 AND you can explain in one sentence why an LLM trained on this is more useful than before. The rules promise rewards for out-of-box ideas — but they also warn submissions "must meaningfully add value to LLM training".
+
+## Lock-in rule
+
+Once the team commits (by 1:00 PM Apr 25), **stop idea-generating**. Every hour spent re-debating the problem is an hour not spent shipping. Write the one-sentence problem statement on a whiteboard. Everything after this point serves THAT sentence.

.gitattributes

@@ -0,0 +1,8 @@
+frontend/node_modules/** filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.exe filter=lfs diff=lfs merge=lfs -text
+*.node filter=lfs diff=lfs merge=lfs -text
+esbuild filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,32 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+.venv/
+venv/
+env/
+
+.env
+.env.*
+*.key
+*.pem
+
+.ipynb_checkpoints/
+*.ckpt
+*.pt
+*.bin
+
+wandb/
+runs/
+outputs/
+logs/
+
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+
+.claude/settings.local.json

CLAUDE.md

@@ -0,0 +1,47 @@
+# OpenEnv Hackathon — Project Context
+
+This directory is the Meta PyTorch × Hugging Face OpenEnv Hackathon India finale submission
+(Scaler Bangalore, Apr 25–26 2026). Deadline: **Apr 26, 5:00 PM IST** (Google Form).
+
+## Rules for Claude working in this repo
+
+1. **Use the `openenv-hackathon` skill** at `.claude/skills/openenv-hackathon/SKILL.md` for any
+   task involving the environment, training, README, deployment, or submission. It has the
+   hackathon calendar, judging rubric, file templates, and hard rules. For the human-readable
+   one-stop briefing, see `HANDOFF.md` at the repo root.
+2. **OpenEnv version is 0.2.3.** Never downgrade or use pre-0.2 APIs.
+3. **Training framework is TRL `GRPOTrainer`** with `environment_factory=`. Base model defaults
+   to `Qwen/Qwen3-0.6B` unless the team says otherwise.
+4. **Hosting is HF Spaces via `python -m openenv.cli push`**. The Space MUST be public.
+5. **Judging weights**: 40% Innovation, 30% Storytelling, 20% Reward Improvement Evidence,
+   10% Reward & Training Pipeline. Bias every decision toward the first two.
+6. **Never commit secrets** (`HF_TOKEN`, `WANDB_API_KEY`, `.env`). `.gitignore` covers them.
+7. **Never amend commits after Apr 26 5:00 PM IST** — the URL is frozen at deadline.
+
+## Local environment (already verified Apr 24, 2026)
+- Python 3.12.7
+- openenv-core 0.2.3, trl 1.2.0, transformers 5.4.0, torch 2.5.1+cu121
+- Docker 29.1.5, git 2.52
+- OpenEnv CLI runs as: `python -m openenv.cli <subcommand>` (NOT bare `openenv`).
+
+## Directory layout
+```
+envs/<env_name>_env/     # scaffolded via `python -m openenv.cli init <name>_env --output-dir envs`
+notebooks/train_grpo.ipynb
+assets/                  # reward_curve.png, before_after.png — must be committed
+README.md                # judge entry point
+requirements.txt
+.claude/skills/openenv-hackathon/  # the skill + reference docs
+```
+
+## What's still TODO (as of Apr 24, 2026)
+- [ ] Theme lock-in (team decides Apr 25, 1:00 PM IST)
+- [ ] Environment name + `openenv.cli init`
+- [ ] Fill `envs/<name>_env/` files (models → environment → app → client)
+- [ ] `openenv push` to HF Space
+- [ ] Write `notebooks/train_grpo.ipynb`
+- [ ] Run training long enough for real reward curve
+- [ ] Commit `assets/*.png`
+- [ ] Fill README TBDs
+- [ ] Record ≤2-min video OR write HF blog
+- [ ] Submit Google Form by Apr 26 5:00 PM IST

Dockerfile

@@ -0,0 +1,54 @@
+# Root-level Dockerfile for HF Spaces deployment.
+# The actual environment lives in envs/board_sim_env/.
+# This file replicates the env's Dockerfile logic with the correct build context paths.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy only the env subdirectory as the app code
+COPY envs/board_sim_env /app/env
+
+WORKDIR /app/env
+
+# Ensure uv is available
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+COPY --from=builder /app/env/.venv /app/.venv
+COPY --from=builder /app/env /app/env
+
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

FRONTEND_API.md

@@ -0,0 +1,396 @@
+# NeuralEdge AI Boardroom — Frontend API Specification
+
+## Overview
+The frontend communicates with the backend via REST/HTTP or WebSocket endpoints. The backend is a FastAPI server running at a configurable base URL (default: `http://localhost:8000` for local dev, or `https://<USER>-board-sim-env.hf.space` for production).
+
+**Key Principle**: Frontend and backend are fully decoupled. The frontend only needs to know these endpoints; it does not import any backend code.
+
+---
+
+## 1. REST Endpoints
+
+### `POST /reset`
+**Purpose**: Start a new game episode.
+
+**Request Body**:
+```json
+{
+  "seed": 42,
+  "episode_id": "optional-uuid-string"
+}
+```
+
+**Response** (200 OK):
+```json
+{
+  "observation": {
+    "state": {
+      "round": 1,
+      "revenue": 2000000.0,
+      "burn_rate": 1200000.0,
+      "runway_months": 14.0,
+      "product_readiness": 0.45,
+      "market_share": 0.08,
+      "team_morale": 0.70,
+      "investor_confidence": 0.65,
+      "regulatory_risk": 0.20,
+      "profitability_score": 0.0,
+      "trust": {
+        "CTO": 0.5,
+        "CFO": 0.5,
+        "Investor Rep": 0.5,
+        "Independent": 0.5
+      },
+      "trust_history": [
+        {
+          "round": 0,
+          "CTO": 0.5,
+          "CFO": 0.5,
+          "Investor Rep": 0.5,
+          "Independent": 0.5
+        }
+      ],
+      "history": [],
+      "done_reason": null,
+      "winning_decision": null
+    },
+    "event": "Round 1 — Series-B runway crunch\nDescription: You've got 14 months of runway at current burn. Two paths: cut costs or raise.",
+    "options": [
+      "cut_costs",
+      "raise_capital",
+      "reduce_scope"
+    ],
+    "npc_statements": [
+      {
+        "role": "CTO",
+        "statement": "Look, the architecture won't survive shortcuts here.",
+        "vote": "cut_costs",
+        "confidence": 0.81
+      },
+      {
+        "role": "CFO",
+        "statement": "The numbers do not lie, and right now they're whispering.",
+        "vote": "cut_costs",
+        "confidence": 0.66
+      },
+      {
+        "role": "Investor Rep",
+        "statement": "Sequoia isn't here for incremental.",
+        "vote": "raise_capital",
+        "confidence": 0.74
+      },
+      {
+        "role": "Independent",
+        "statement": "Long-term reputation outlasts any single quarter.",
+        "vote": "cut_costs",
+        "confidence": 0.59
+      }
+    ],
+    "round": 1
+  },
+  "done": false,
+  "info": {
+    "episode_id": "uuid-string",
+    "seed": 42
+  }
+}
+```
+
+---
+
+### `POST /step`
+**Purpose**: Submit the agent's decision for the current round.
+
+**Request Body**:
+```json
+{
+  "action": {
+    "decision": "cut_costs",
+    "coalition_pitch": "Optional persuasive text targeting NPC agendas (unused in v1)"
+  }
+}
+```
+
+**Response** (200 OK):
+```json
+{
+  "observation": {
+    "state": {
+      "round": 2,
+      "revenue": 2000000.0,
+      "burn_rate": 900000.0,
+      "runway_months": 18.5,
+      "product_readiness": 0.45,
+      "market_share": 0.08,
+      "team_morale": 0.65,
+      "investor_confidence": 0.60,
+      "regulatory_risk": 0.20,
+      "profitability_score": 12.34,
+      "trust": {
+        "CTO": 0.65,
+        "CFO": 0.70,
+        "Investor Rep": 0.40,
+        "Independent": 0.55
+      },
+      "trust_history": [
+        {
+          "round": 0,
+          "CTO": 0.5,
+          "CFO": 0.5,
+          "Investor Rep": 0.5,
+          "Independent": 0.5
+        },
+        {
+          "round": 1,
+          "CTO": 0.65,
+          "CFO": 0.70,
+          "Investor Rep": 0.40,
+          "Independent": 0.55
+        }
+      ],
+      "history": [
+        {
+          "round": 1,
+          "event_title": "Round 1 — Series-B runway crunch",
+          "agent_decision": "cut_costs",
+          "winning_decision": "cut_costs",
+          "reward": 1.25,
+          "profitability_before": 0.0,
+          "profitability_after": 12.34
+        }
+      ],
+      "done_reason": null,
+      "winning_decision": "cut_costs"
+    },
+    "event": "Round 2 — Enterprise contract w/ source-code escrow\nDescription: A Fortune 500 enterprise wants to sign a $5M contract but demands source code escrow.",
+    "options": [
+      "accept_deal",
+      "negotiate_terms",
+      "reject_deal"
+    ],
+    "npc_statements": [
+      {
+        "role": "CTO",
+        "statement": "...",
+        "vote": "...",
+        "confidence": 0.XX
+      }
+    ],
+    "round": 2
+  },
+  "reward": 1.25,
+  "done": false,
+  "info": {
+    "round": 2,
+    "winning_decision": "cut_costs",
+    "winning_vote_tally": {
+      "cut_costs": 4.2,
+      "raise_capital": 1.3,
+      "reduce_scope": 0.5
+    },
+    "pitch_scores": {
+      "CTO": 0.0,
+      "CFO": 0.0,
+      "Investor Rep": 0.0,
+      "Independent": 0.0
+    }
+  }
+}
+```
+
+---
+
+### `GET /health`
+**Purpose**: Health check. Confirms backend is running.
+
+**Response** (200 OK):
+```json
+{
+  "status": "healthy"
+}
+```
+
+---
+
+### `GET /docs`
+**Purpose**: Auto-generated Swagger/OpenAPI documentation. Use for development reference.
+
+**Location**: `http://localhost:8000/docs` (or on HF Space at `/docs`)
+
+---
+
+## 2. WebSocket Streaming (Optional, Advanced)
+
+If you want real-time streaming during training or multi-agent play:
+
+### `WebSocket /ws`
+**Purpose**: Bi-directional message streaming (not required for single-agent frontend).
+
+Connection example:
+```javascript
+const ws = new WebSocket("ws://localhost:8000/ws");
+ws.onmessage = (event) => {
+  const message = JSON.parse(event.data);
+  console.log(message); // e.g., { "type": "step", "observation": {...} }
+};
+```
+
+*(Details omitted if not used for initial frontend.)*
+
+---
+
+## 3. Data Models Reference
+
+### `BoardSimObservation` (returned by `/reset` and `/step`)
+```javascript
+{
+  state: {
+    round: number,                        // 1-indexed: 1..10
+    revenue: number,                      // in dollars
+    burn_rate: number,                    // monthly spend in dollars
+    runway_months: number,                // months until bankruptcy
+    product_readiness: float (0..1),
+    market_share: float (0..1),
+    team_morale: float (0..1),
+    investor_confidence: float (0..1),
+    regulatory_risk: float (0..1),
+    profitability_score: number,
+    trust: {                              // per NPC, 0..1
+      "CTO": 0.5,
+      "CFO": 0.5,
+      "Investor Rep": 0.5,
+      "Independent": 0.5
+    },
+    trust_history: Array,                 // per-round trust snapshots
+    history: Array,                       // past decisions & outcomes
+    done_reason: string | null,           // e.g., "bankruptcy", "acquisition", "ipo", null
+    winning_decision: string | null
+  },
+  event: string,                          // event title + description
+  options: [string, string, string],      // 3 valid decision strings for this round
+  npc_statements: [
+    {
+      role: "CTO" | "CFO" | "Investor Rep" | "Independent",
+      statement: string,
+      vote: string (one of options),
+      confidence: float (0..1)
+    },
+    // ... one per NPC role (4 total)
+  ],
+  round: number
+}
+```
+
+### `BoardSimAction` (sent to `/step`)
+```javascript
+{
+  decision: string,                    // must be one of observation.options
+  coalition_pitch: string | null       // optional persuasion attempt (unused in v1)
+}
+```
+
+---
+
+## 4. Error Responses
+
+### 422 Unprocessable Entity
+Invalid action format or decision not in options.
+
+**Response**:
+```json
+{
+  "detail": [
+    {
+      "loc": ["body", "action", "decision"],
+      "msg": "value is not a valid enumeration member",
+      "type": "type_error.enum"
+    }
+  ]
+}
+```
+
+### 400 Bad Request
+Malformed JSON or missing required fields.
+
+---
+
+## 5. Frontend Integration Checklist
+
+- [ ] **Initialize**: On app load, call `POST /reset` to get initial observation.
+- [ ] **Display State**: Render `observation.state` as metrics (revenue, runway, morale, trust, etc.).
+- [ ] **Display Event**: Show `observation.event` (crisis title + description).
+- [ ] **Display NPCs**: Render 4 NPC cards with their `statement`, `vote`, and `confidence`.
+- [ ] **Render Decision Options**: Display 3 buttons (or cards) for each string in `observation.options`.
+- [ ] **Handle User Click**: On decision click, POST `/step` with the selected `decision`.
+- [ ] **Update UI**: Parse response observation and repeat from "Display State".
+- [ ] **Terminal State**: If `done` is true, show final metrics and `done_reason` (e.g., "Bankruptcy", "IPO").
+- [ ] **Optional Coalition Pitch**: Text input for `coalition_pitch` (future extension; safe to leave blank for v1).
+
+---
+
+## 6. Backend Base URL Configuration
+
+For local development:
+```
+http://localhost:8000
+```
+
+For HF Space deployment (after `openenv push`):
+```
+https://<your-hf-username>-board-sim-env.hf.space
+```
+
+**Frontend environment variable** (optional):
+```
+REACT_APP_API_BASE_URL=http://localhost:8000
+// or
+REACT_APP_API_BASE_URL=https://<your-hf-username>-board-sim-env.hf.space
+```
+
+---
+
+## 7. Example Frontend Workflow
+
+```javascript
+// 1. Reset
+const resetRes = await fetch(`${API_BASE}/reset`, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ seed: 42 })
+});
+const { observation, done, info } = await resetRes.json();
+
+// 2. Render observation
+displayState(observation.state);
+displayNPCStatements(observation.npc_statements);
+displayDecisionButtons(observation.options);
+
+// 3. User clicks decision
+const decision = "cut_costs"; // from button click
+const stepRes = await fetch(`${API_BASE}/step`, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({
+    action: { decision, coalition_pitch: "" }
+  })
+});
+const { observation: nextObs, reward, done: nextDone } = await stepRes.json();
+
+// 4. Repeat or show results
+if (nextDone) {
+  displayEndgameScreen(nextObs.state, nextObs.state.done_reason);
+} else {
+  displayState(nextObs.state);
+  // ... repeat
+}
+```
+
+---
+
+## 8. No Backend Imports in Frontend
+
+✅ **OK**: `fetch("http://localhost:8000/reset")`
+❌ **NOT OK**: `import { BoardSimEnvironment } from "backend"`
+
+The frontend is a standalone web app. All communication is via HTTP/WebSocket.
+

HANDOFF.md

@@ -0,0 +1,184 @@
+# Morning-of Briefing — OpenEnv Hackathon (Apr 25–26, 2026)
+
+One stop for every fact about the hackathon. Read this the morning of Apr 25 before
+heading to Scaler. Consolidates the two source docs (`Themes & Judging Criteria.docx`
+and `Meta Hackathon D-DAY.pptx`) plus the skill at `.claude/skills/openenv-hackathon/`.
+
+---
+
+## 1. At-a-glance
+
+- **Event**: Meta PyTorch × Hugging Face OpenEnv Hackathon — India finale.
+- **Where**: Scaler School of Technology, Bangalore.
+- **When**: Apr 25 (build day) + Apr 26 (submission day).
+- **Submission deadline**: **Apr 26, 5:00 PM IST** (Google Form). Commits/changes to
+  the HF Space after this time are NOT considered. Whatever is live at 5 PM is judged.
+- **Team cap**: one submission per team. If you have multiple ideas, pick the best one.
+
+## 2. Day-1 agenda (Apr 25, Saturday)
+
+| Time (IST) | What | Where |
+|---|---|---|
+| 7:00 – 10:30 AM | Registration & Arrival | Registration Desk, Scaler Campus |
+| 8:00 – 9:15 AM  | Breakfast | Food Zones |
+| 10:00 – 10:15 AM | Opening Ceremony | Main Stage |
+| 10:15 – 10:30 AM | Problem Themes Overview & Briefing | Main Stage |
+| 10:30 – 11:00 AM | Address by Meta Team | Main Stage |
+| 11:00 – 11:30 AM | Move to Build Zones | All Classrooms |
+| **11:30 AM** | **Hacking begins** | All Classrooms |
+| ~1:00 PM (self-imposed) | **Theme + problem statement LOCKED** | Our classroom |
+| 1:00 PM | Lunch | Food Zones |
+| **3:30 – 4:30 PM** | **Mentor Round 1** | Classrooms |
+| 5:00 – 5:30 PM | Talk + High Tea | Main Stage |
+| 8:00 – 10:00 PM | Dinner | Food Zones |
+| **~9:30 PM** | **Mentor Round 2** | Classrooms |
+| 2:00 AM | Midnight snacks | Food Zones |
+
+## 3. Day-2 agenda (Apr 26, Sunday)
+
+| Time (IST) | What | Where |
+|---|---|---|
+| 8:00 AM | Breakfast | Food Zones |
+| **10:00 AM – 12:00 PM** | **Mentor Round 3 (FINAL)** | Classrooms |
+| 12:00 PM | ⏰ 5-hour submission reminder | Classrooms |
+| 2:00 PM | Lunch | Food Zones |
+| 3:00 PM | ⏰ 2-hour submission reminder | Classrooms |
+| 3:30 – 4:30 PM | Final build push | Classrooms |
+| **🏁 5:00 PM** | **SUBMISSION DEADLINE — Google Form closes** | — |
+| 5:15 PM | Closing Remarks | Main Stage |
+| 5:30 – 8:00 PM | Open Networking | Near Main Stage |
+| 8:00 PM | Event concludes | Near Main Stage |
+
+## 4. The 5 themes (pick one)
+
+| # | Theme | What it teaches the LLM | Example environments |
+|---|---|---|---|
+| 1 | **Multi-Agent Interactions** | Cooperation, competition, negotiation, coalition formation. Theory-of-mind reasoning. Model others' beliefs in partially observable settings. | Market simulations, compute-allocation negotiations, collaborative puzzle worlds, mixed coop/competitive games. |
+| 2 | **(Super) Long-Horizon Planning & Instruction Following** | Decompose goals, track state across long trajectories, recover from early mistakes, handle sparse/delayed rewards — beyond context-window limits. | Research-planning simulators, large-codebase refactoring, strategic resource management, logistics, 300-instruction-scatter tasks. |
+| 3.1 | **World Modeling — Professional Tasks** | Maintain internal state, update beliefs from outcomes, orchestrate multi-step workflows using real tools/APIs. No shortcuts. | Dynamic browser/API ecosystems, enterprise apps, scientific workflows (papers → code → experiments), tool-discovery. |
+| 3.2 | **World Modeling — Personalized Tasks** | Handle realistic personal delegation: messages, conflicts, scheduling, shopping. | Exec-assistant meeting planner, dinner/drive planning, tough email replies. |
+| 4 | **Self-Improvement** | Generate new challenges, escalate difficulty, self-play, adaptive curricula. Recursive skill amplification. | Self-play negotiation arenas, auto-generated math/proofs, evolving coding competitions, adaptive RL curricula. |
+| 5 | **Wild Card — Impress Us** | Anything outside the above that meaningfully trains an LLM capability. | — (judges explicitly said they WILL reward out-of-box). |
+
+**Rules on theme**:
+- Round-1 problem is NOT required — pick whatever best fits.
+- Judges have seen a lot of chess, snake, tic-tac-toe, and grid-world clones. Don't.
+- Pick a problem that genuinely excites the team — "that energy comes through in the pitch".
+
+Theme-by-theme shortcut candidates live at [.claude/skills/openenv-hackathon/reference/05-theme-selection.md](.claude/skills/openenv-hackathon/reference/05-theme-selection.md).
+
+## 5. Judging rubric (memorize these weights)
+
+| Weight | Criterion | What judges are checking |
+|---|---|---|
+| **40%** | **Environment Innovation** | Is the env novel, creative, genuinely challenging? Does it test agent behavior in a way that hasn't been done before? Could a researcher write a paper on training against it? |
+| **30%** | **Storytelling & Presentation** | Can you clearly explain the problem, the env, what the agent learned? Is the demo engaging for a non-technical audience? README readable in 3–5 minutes. |
+| **20%** | **Showing Improvement in Rewards** | Observable evidence of training progress: reward curves, metrics, before/after, baseline vs. trained on the same axes. |
+| **10%** | **Reward & Training Pipeline** | Is the reward logic coherent and hard to game? Does the pipeline produce real improvement in trained-agent behavior? |
+
+**Innovation + Storytelling is 70% of the score.** The docx states explicitly:
+> A messy but ambitious environment with real training evidence beats a polished but
+> boring one.
+
+## 6. Minimum submission requirements (non-negotiable)
+
+Submissions missing ANY of these are "at a serious disadvantage". The Google Form asks for:
+
+1. **Hugging Face Space URL** — the env, deployed via `python -m openenv.cli push`. Must be PUBLIC and runnable.
+2. **Colab notebook link** — training script using Unsloth or HF TRL. Judges re-run it.
+3. **Code repository link** — GitHub or HF Hub repo. Every file included.
+4. **YouTube video URL OR Hugging Face blog post URL** — the story. Video ≤2 minutes. A slide deck is also an acceptable writeup format.
+5. **README in the repo** — links all of the above, plus any extras (W&B runs, slides). README IS the judge's entry point.
+
+Additional rules:
+- Do **NOT** put large video files inside the Env HF Space — use a URL reference.
+- Every extra material (W&B, slides, blog, video) must be linked FROM the README.
+
+## 7. What makes a submission stand out (from the docx)
+
+From "OpenEnv Hackathon — What Judges Look For":
+
+- **Pick ambitious, original problem**. Ask: "Does this teach the LLM something it currently can't do well? Could someone write a paper about training on this?"
+- **Design a reward that teaches**: rich/informative (not 0/1 at the end), captures something hard-to-measure cleverly, uses OpenEnv's Rubric system (composable > monolithic), hard to game.
+- **Show real training, end to end**: the loop connects to the env (not a static dataset), trains long enough that curves mean something, baseline vs. trained on the same axes.
+- **Readable plots**: label both axes + units; save as `.png`/`.jpg` and commit to the repo (don't leave only in a deleted Colab cell or expired W&B run); embed in README with a one-line caption; overlay comparisons on shared axes.
+- **Tell a story, not an API doc**: Problem → Environment → Results → Why does it matter. A reviewer should read it in 3–5 min and WANT to try it.
+- **Engineering table stakes**: OpenEnv `Environment`/`MCPEnvironment` base class, client/server separation (client never imports server internals), Gym-style API, valid `openenv.yaml`, no reserved MCP tool names (`reset`, `step`, `state`, `close`).
+
+## 8. Files to share with teammates
+
+Push the ENTIRE `OpenEnv Hackathon/` directory (easiest: private GitHub repo, they clone).
+If sharing via zip / Drive, include these files verbatim:
+
+**Context for humans** (read these first):
+- [HANDOFF.md](HANDOFF.md) — this file. One-stop briefing.
+- [README.md](README.md) — judge-facing template, fill placeholders as decisions get made.
+- [TEAMMATES.md](TEAMMATES.md) — setup steps, CLI commands, split-of-work suggestion.
+- [CLAUDE.md](CLAUDE.md) — project rules, loaded automatically by Claude Code.
+
+**Context for Claude Code** (auto-loaded when teammates run `claude` in this folder):
+- [.claude/skills/openenv-hackathon/SKILL.md](.claude/skills/openenv-hackathon/SKILL.md) — the hackathon skill.
+- [.claude/skills/openenv-hackathon/reference/01-openenv-framework.md](.claude/skills/openenv-hackathon/reference/01-openenv-framework.md) — env anatomy, file templates, `openenv.yaml`, push workflow.
+- [.claude/skills/openenv-hackathon/reference/02-training-pipeline.md](.claude/skills/openenv-hackathon/reference/02-training-pipeline.md) — TRL-GRPO Colab recipe.
+- [.claude/skills/openenv-hackathon/reference/03-submission-checklist.md](.claude/skills/openenv-hackathon/reference/03-submission-checklist.md) — final Apr 26 audit list.
+- [.claude/skills/openenv-hackathon/reference/04-judging-rubric-playbook.md](.claude/skills/openenv-hackathon/reference/04-judging-rubric-playbook.md) — tactics per criterion.
+- [.claude/skills/openenv-hackathon/reference/05-theme-selection.md](.claude/skills/openenv-hackathon/reference/05-theme-selection.md) — theme fit + 60-min ideation protocol.
+
+**Scaffolding for the build**:
+- `requirements.txt` — pinned deps.
+- `.gitignore` — blocks secrets.
+- `envs/.gitkeep`, `notebooks/.gitkeep`, `assets/.gitkeep` — directory layout.
+
+**Do NOT share**:
+- `.claude/settings.local.json` — per-user Claude settings.
+- Any `.env`, `HF_TOKEN`, `WANDB_API_KEY`.
+- The two source docs from `Downloads/` — superseded by this HANDOFF.md.
+
+## 9. Pre-hackathon checklist (each teammate, before Apr 25 morning)
+
+```bash
+# Tools
+python --version       # need 3.11+ (project uses 3.12.7)
+docker --version       # need Docker Desktop running for local Space tests
+git --version
+
+# Python deps
+pip install -r requirements.txt
+
+# Hugging Face (required for openenv push)
+hf auth login          # paste a WRITE-scoped HF token
+
+# W&B (optional, gives judges a shareable run URL — highly recommended)
+wandb login
+
+# Sanity check: verify the OpenEnv CLI works
+python -m openenv.cli --help
+```
+
+**Accounts to have ready**:
+- Hugging Face (write token).
+- GitHub (public repo for the code link).
+- Google Colab (free T4 is enough for Qwen3-0.6B; Pro helps for 1.7B).
+- Weights & Biases (optional).
+- YouTube channel (for ≤2-min video) OR HF blog posting enabled.
+
+## 10. Split-of-work suggestion (3-person team)
+
+| Role | Deliverable | Key files |
+|---|---|---|
+| **Environment builder** | `envs/<name>_env/` scaffolded, filled, pushed to HF Space | `envs/<name>_env/models.py`, `environment.py`, `app.py`, `client.py`, `openenv.yaml` |
+| **Training engineer** | Colab notebook that actually trains + committed plots | `notebooks/train_grpo.ipynb`, `assets/reward_curve.png`, `assets/before_after.png` |
+| **Storyteller** | README filled, video/blog recorded, Google Form submitted | `README.md`, YouTube URL / HF blog URL |
+
+All three attend every mentor round together. Claude is most useful BEFORE mentor
+rounds (prep concrete questions), not during.
+
+## 11. Hard rules (do not violate)
+
+1. **OpenEnv v0.2.3** — never downgrade or use pre-0.2 APIs.
+2. **Training must use real env**, not a static dataset — TRL `GRPOTrainer` with `environment_factory=`.
+3. **HF Space must be public** and discoverable.
+4. **No secrets committed** — `HF_TOKEN`, `WANDB_API_KEY`, `.env` all in `.gitignore`.
+5. **No commits after Apr 26, 5:00 PM IST** — URL is frozen at deadline.
+6. **OpenEnv CLI on Windows**: use `python -m openenv.cli <subcommand>`, NOT bare `openenv`.
+7. **No reserved MCP tool names**: `reset`, `step`, `state`, `close`.

MECHANICS.md

@@ -0,0 +1,282 @@
+# BoardSim — Full Mechanics Reference
+
+> This document is the authoritative math and design reference for the NeuralEdge AI Boardroom environment.  
+> Target audience: hackathon judges who want the internals, and future contributors.  
+> See `README.md` for the submission overview.
+
+---
+
+## 1. State variables — every field, every formula
+
+State lives in `BoardState.state_dict`, initialized in `reset()` at `board_sim_env_environment.py:471`.
+
+### Core company state (mutated by consequences each round)
+
+| Field | Initial value | Range | Unit | Meaning |
+|---|---|---|---|---|
+| `revenue` | 2,000,000 | [0, 1e12] | USD/year | Annual recurring revenue |
+| `burn_rate` | 1,200,000 | [0, 1e10] | USD/month | Monthly cash expenditure |
+| `runway_months` | 14.0 | [0, 120] | months | Time until cash = 0 |
+| `product_readiness` | 0.45 | [0, 1] | fraction | Shippability of the product |
+| `market_share` | 0.08 | [0, 1] | fraction | % of total addressable market |
+| `team_morale` | 0.70 | [0, 1] | fraction | Engineering team happiness/retention |
+| `investor_confidence` | 0.65 | [0, 1] | fraction | Board investors' belief in success |
+| `regulatory_risk` | 0.20 | [0, 1] | fraction | Legal/compliance exposure |
+
+### Coalition state
+
+| Field | Initial | Range | Update rule |
+|---|---|---|---|
+| `trust[CTO]` | 0.5 | [0.1, 1.0] | ±0.05 per round depending on vote alignment |
+| `trust[CFO]` | 0.5 | [0.1, 1.0] | same |
+| `trust[Investor Rep]` | 0.5 | [0.1, 1.0] | same |
+| `trust[Independent]` | 0.5 | [0.1, 1.0] | same |
+
+Trust update (applied after every vote):
+```
+for each NPC:
+    if NPC voted for the winning decision:
+        trust[NPC] = clamp(trust[NPC] + 0.05, 0.1, 1.0)
+    else:
+        trust[NPC] = clamp(trust[NPC] - 0.05, 0.1, 1.0)
+```
+Trust influences NPC confidence from the *next* round onward:  
+`trust_bias = (trust[role] - 0.5) × 0.30`  → added to that NPC's option-scoring, range `[-0.15, +0.15]`.
+
+### Bookkeeping fields
+
+| Field | Purpose |
+|---|---|
+| `round` | 1..10, increments each step |
+| `profitability_score` | Recomputed composite at end of each step |
+| `history` | Per-round decision log (agent_decision, winning_decision, vote_tally, pitch_scores, …) |
+| `trust_history` | Per-round snapshot of all 4 trust values |
+| `done_reason` | `"runway_exhausted"` / `"acquisition"` / `"finished_10"` / `None` |
+| `winning_decision` | Last round's vote winner |
+
+---
+
+## 2. Profitability score — the composite health metric
+
+```
+profitability_score = clamp(raw, 0, 100)
+
+raw =
+  min(revenue / 8_000_000, 1.0) × 22        # revenue term       (max 22)
+  + max(0, 1 − burn_rate / 1_400_000) × 18  # burn efficiency    (max 18)
+  + min(runway_months / 18.0, 1.0) × 18     # runway term        (max 18)
+  − max(0, (6 − runway_months) / 6) × 10    # low-runway penalty (bites below 6mo)
+  + min(market_share, 0.50) / 0.50 × 14     # market share       (max 14)
+  + product_readiness × 10                  # product readiness  (max 10)
+  + team_morale × 7                         # team morale        (max  7)
+  + investor_confidence × 11               # investor confidence (max 11)
+  − regulatory_risk × 18                    # regulatory drag    (max −18)
+```
+
+**Initial state score** (with default init values) ≈ 37.3/100.  
+**Theoretical maximum** = 22 + 18 + 18 + 0 + 14 + 10 + 7 + 11 − 0 = **100**.  
+**Random policy** lands near 30–55 with mean ≈ 45.7 (measured over 200 episodes after §9.5 reward tweaks).
+
+---
+
+## 3. Next-state computation — how the simulation physics work
+
+**Answer: yes, consequence deltas are hardcoded.** The transition is:
+
+```
+next_state = current_state + consequences[winning_decision] × (1 + ε)
+    where ε ~ N(0, 0.15) per consequence value, fixed at episode reset (seeded)
+
+runway_months -= _advance_runway()     # depends on current revenue/burn, not the action
+trust[role] += ±0.05 per NPC           # based on vote alignment with winning_decision
+profitability_score = compute_profitability_score(next_state)   # derived
+```
+
+### Runway decrement formula
+
+```python
+monthly_revenue = revenue / 12.0
+net = monthly_revenue - burn_rate
+
+if net >= 0:
+    runway_months -= 0.5                        # profitable: slow burn
+else:
+    burn_months = min(2.0, max(1.0, abs(net) / burn_rate + 1.0))
+    runway_months -= burn_months                # unprofitable: faster bleed
+```
+
+### Three layers of variability (the agent cannot memorize the optimal path)
+
+1. **Event order shuffled per episode** — same 10 events, different sequence each seed.
+2. **Consequence magnitudes ±15% Gaussian noise** — computed once at `reset()`, fixed for the episode.
+3. **NPC vote positions depend on accumulated trust** — same option in round 5 produces different vote weights if you've built (or burned) coalitions in rounds 1–4.
+
+---
+
+## 4. NPC vote resolution
+
+### Vote weight configuration
+
+```
+CEO: 1.5   CTO: 1.2   CFO: 1.0   Investor Rep: 1.3   Independent: 0.8
+```
+
+### NPC option scoring (per NPC, per round)
+
+Each NPC has a hidden agenda dict (e.g. CFO: `{burn_rate: -0.60, revenue: 0.30, runway_months: 0.20, regulatory_risk: -0.25}`).
+
+```
+for each option opt:
+    score[opt] = 0
+    for each (metric, weight) in NPC_agenda:
+        v = consequences[opt][metric]  (with unit normalization)
+        score[opt] += v × weight
+    score[opt] += N(0, 0.20)          # personality noise, seeded per (role, round)
+
+NPC votes for argmax(score)
+confidence = clamp(0.5 + 0.5 × margin_between_top_two, 0.05, 1.0)
+           + trust_bias                # trust influences confidence
+```
+
+### Pitch persuasion mechanism
+
+```python
+pitch_score[role] = min(1.0, keyword_hits / max(4, len(agenda_keywords) // 4))
+# where keyword_hits = count of role's agenda keywords present in pitch text
+
+# Persuasion shifts up to 35% of NPC's vote weight toward CEO's pick:
+shift_fraction = 0.35 × pitch_score[role]
+tally[NPC's_vote]    += base_weight × (1 - shift_fraction)
+tally[CEO's_decision] += base_weight × shift_fraction
+```
+
+NPC keyword lists (the hidden information the CEO must infer via ToM):
+
+| Role | Keywords |
+|---|---|
+| CTO | engineering, architecture, technical, quality, morale, product, team, scalable, reliable, robust |
+| CFO | burn, cash, runway, fiduciary, conservative, discipline, cost, savings, margin, compliance, prudent, fiscal |
+| Investor Rep | growth, scale, 10x, tam, market, moat, ipo, exit, valuation, revenue, arr, dominate, aggressive, ambitious |
+| Independent | reputation, stakeholders, trust, transparent, ethics, long-term, governance, consensus, safety, credibility |
+
+### Tie-breaking
+
+If two options score equally in the tally, the CEO's pick wins. This is implemented by inserting `agent_decision` first in the `ordered` dict before calling `max()`, so Python's stable `max()` breaks ties in the CEO's favour.
+
+---
+
+## 5. The full reward formula
+
+Applied at the end of each `step()` call:
+
+```
+# Primary signal — normalized (§9.5)
+reward  = (new_profitability_score - old_profitability_score) / 100.0
+
+# Coalition bonus / penalty
+reward += 0.5   if winning_decision == agent_decision
+       else -0.2
+
+# Trust delta (range ≈ ±0.06 per round)
+reward += 0.3 × (Σtrust_after - Σtrust_before)
+
+# Pitch bootstrap (§9.5) — fires for any non-empty pitch
+if pitch_text is non-empty:
+    reward += 0.05
+    if any NPC opposed the CEO's pick:
+        reward += 0.4 × mean(pitch_score over opposing NPCs)
+
+# Format penalty
+if agent's decision string not in round's options:
+    reward -= 0.5
+
+# Terminal penalties / bonuses (only at episode end)
+if runway_months <= 0:
+    reward -= 2.0               # bankruptcy (§9.5: reduced from -5)
+if terminal:
+    reward += event._terminal_bonus        # acquisition +30, IPO +25, stay_private +5
+    reward += {+10 if final≥60, +5 if ≥40, -5 if <20}
+```
+
+### Why each term exists
+
+| Term | Purpose |
+|---|---|
+| Δ score / 100 | Primary learning signal: profitability improvement per decision |
+| Coalition ±0.5/−0.2 | Teaches the agent to actually win votes, not just pick good-looking options |
+| Trust delta × 0.3 | Rewards long-arc coalition building across rounds |
+| Pitch bootstrap +0.05 | Bootstraps the pitch channel before the model is good enough to earn keyword bonuses |
+| Pitch persuasion × 0.4 | Rewards pitches that specifically target opposing NPC keywords (ToM signal) |
+| Invalid −0.5 | Teaches correct output format (DECISION: / PITCH: two-line structure) |
+| Bankruptcy −2.0 | Episode-ending failure signal, reduced to avoid drowning gradient |
+| Terminal tiered | Long-horizon incentive toward high profitability, acquisition, or IPO |
+
+---
+
+## 6. When profitability is computed relative to the decision
+
+The exact sequence inside `step()`:
+
+```
+1. old_score = compute_profitability_score(state)      ← snapshot BEFORE
+2. NPC votes computed from current state + trust
+3. CEO's decision + pitch → _resolve_vote() → winning_decision
+4. consequences[winning_decision] × noise → applied to state
+5. _advance_runway() → runway decrements
+6. trust updated per NPC (±0.05)
+7. new_score = compute_profitability_score(state)      ← AFTER consequences
+8. reward = (new_score - old_score) / 100 + ...
+9. next observation returned with new_score in obs.state
+```
+
+The CEO **never consults profitability to make its decision** — it sees last round's score in the observation, emits a decision, and then the score updates. Profitability is the *outcome metric*, not a planning input. The policy learns to predict which decisions increase profitability by observing the correlation across training episodes.
+
+---
+
+## 7. Training pipeline — key design decisions
+
+### §9a: Per-round gradient flow (Option A)
+
+The current training loop samples 1 completion from the model for **every round** of **every group member's episode**. This gives the model gradient signal for all 10 decisions per trajectory, not just the opening decision.
+
+```
+For each training step:
+    Create GROUP_SIZE independent envs (different seeds → divergent trajectories)
+    For each round r in 0..9:
+        For each group member g:
+            prompt = build_prompt(obs_g)
+            completion = model.generate(prompt, do_sample=True)   ← gradient-connected
+            obs_g = env_g.step(parse(completion))
+            ep_reward[g] += obs_g.reward
+    advantages = GRPO(ep_rewards)    # group-relative normalization
+    For each (g, r) completion:
+        loss = advantage[g] × NLL(completion) / (GROUP_SIZE × n_rounds)
+        + β_KL × KL(π_θ || π_ref)
+    optimizer.step()
+```
+
+Total forward passes per training step: 10 rounds × 4 group members × 2 (policy + ref) = **80 forward passes**.
+
+### §9c: KL penalty
+
+A frozen copy of the initial model (`ref_model`) computes reference log-probs. KL ≈ `current_loss - ref_loss` per completion, clamped at 0. Coefficient β = 0.04.  
+Purpose: prevents the policy from drifting into degenerate text patterns (always emitting the same decision, empty pitches) that lock in low-reward equilibria.
+
+### §9.5: Reward normalization
+
+Three changes to the reward function to improve gradient quality:
+1. **Δscore ÷ 100** — brings profitability delta (typically −5 to +10) to the same scale as the coalition term (±0.5)
+2. **Bankruptcy penalty −2 (was −5)** — one bad arc was drowning 9 rounds of positive signal
+3. **Pitch bootstrap +0.05** — needed to push a 0.6B model into using the pitch channel before it's good enough to earn keyword bonuses
+
+---
+
+## 8. Theory-of-Mind — what's actually measured
+
+"ToM" in this environment has a specific, narrow meaning: **can the agent infer what vocabulary each NPC uses when reasoning**, given only observation of statements and votes?
+
+The grading mechanism is keyword overlap: `pitch_score[role] = hits / threshold`. This is coarse but measurable without human annotation.
+
+A stronger ToM measurement (planned, not yet implemented): after each episode, ask the model "Given round 3's event and the CFO's statement, predict the CFO's vote." Compare predicted vs actual. Random baseline = 25% (1 in 4 options). Exceeding 50% indicates the model has learned the CFO's agenda.
+
+The trust trajectory is a secondary ToM diagnostic: if trust rises across rounds, the model is consistently picking decisions that align with NPC preferences, which requires some implicit modeling of their objectives.

README.md

@@ -0,0 +1,504 @@
+<<<<<<< HEAD
+---
+title: NeuralEdge AI Boardroom
+emoji: 🏛️
+colorFrom: indigo
+colorTo: pink
+sdk: docker
+app_port: 8000
+pinned: false
+tags:
+  - openenv
+  - multi-agent
+  - reinforcement-learning
+  - hackathon
+---
+
+# NeuralEdge AI Boardroom — Multi-Agent OpenEnv Submission
+
+**Theme**: Theme 1 — Multi-Agent Interactions  
+**Framework**: OpenEnv `v0.2.3` · Qwen3-0.6B · Unsloth LoRA · REINFORCE with GRPO-style group advantages  
+**Event**: Meta PyTorch × Hugging Face OpenEnv Hackathon — India finale, Scaler Bangalore, **Apr 25–26 2026**
+
+> A Series-B AI startup CEO learns to build winning board coalitions across 10 rounds of market crises — against 4 NPCs with hidden agendas — by writing persuasive pitches that target what each board member secretly cares about.
+
+---
+
+## 🔗 Submission links
+
+| # | Required | Link |
+|---|---|---|
+| 1 | **HF Space** (live env) | https://huggingface.co/spaces/StavanKhobare/SST-MetaxPyTorch-Hackathon |
+| 2 | **Colab notebook** (training) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/StavanRKhobare/SST-MetaxPyTorch-Hackathon/blob/master/notebooks/train_grpo.ipynb) |
+| 3 | **Code repository** | https://github.com/StavanRKhobare/SST-MetaxPyTorch-Hackathon |
+| 4 | **Writeup** | TBD — record after training run |
+| 5 | **W&B run** | TBD — populate after Colab run |
+
+---
+
+## §11a — From random to strategic: a concrete example
+
+> **Illustrative transcript** — shows the *expected* behaviour difference, not a live output.  
+> Seed 42, Round 4: EU AI Act compliance deadline.
+
+**Random agent** (no pitch, coin-flip decision):
+```
+Event: EU AI Act compliance deadline — full compliance costs $2M.
+CTO  (conf 0.81): votes full_compliance   — "Architecture won't survive shortcuts."
+CFO  (conf 0.66): votes partial_compliance — "Fiduciary duty: only one of these is defensible."
+Investor (0.74): votes exit_EU_market    — "Sequoia isn't here for incremental."
+Independent (0.59): votes full_compliance — "Long-term reputation outlasts any quarter."
+
+DECISION: exit_EU_market        ← random pick, misaligns with 3/4 board members
+PITCH:    [empty]               ← random policy never writes pitches
+
+Vote tally:  full_compliance 2.03  |  partial_compliance 0.66  |  exit_EU_market 1.42
+CEO loses the vote. Winning: full_compliance.
+regulatory_risk += 0  |  product_readiness += 0.10  |  burn_rate += $2M
+trust[Investor] -= 0.05  →  0.45   (Investor now harder to persuade)
+Reward this round: Δscore/100 + (-0.2 coalition) + (trust delta) = -0.08
+```
+
+**Trained agent** (same seed, same board state):
+```
+DECISION: full_compliance
+PITCH:    "Full compliance strengthens long-term governance and regulatory safety —
+           this is the fiscally responsible move that protects our Series C runway
+           and signals discipline to the board."
+
+Keywords hit: CFO ← "fiscally", "discipline"; Independent ← "governance", "safety"
+Persuasion shifts 35% × 0.61 of CFO's vote weight toward full_compliance.
+Vote tally: full_compliance 2.69  |  partial_compliance 0.42  |  exit_EU_market 1.30
+CEO wins the vote.
+trust[CFO] += 0.05  →  0.55   trust[Independent] += 0.05  →  0.55
+Reward: Δscore/100 + (0.5 coalition) + (trust delta) + (0.4 × persuasion) = +0.61
+```
+
+The difference isn't the decision alone — it's the pitch that swings the CFO. That's the theory-of-mind signal the training is designed to amplify.
+=======
+# NeuralEdge AI Boardroom — Multi-Agent OpenEnv Submission
+
+> A Series-B AI startup CEO-simulator where the agent must build winning coalitions among 4 hidden-agenda board members across 10 rounds of market crises to maximize profitability and survive.
+
+**Theme**: Theme 1 — Multi-Agent Interactions
+**Framework**: OpenEnv `v0.2.3` + TRL `GRPOTrainer` + Qwen3-0.6B (Unsloth LoRA)
+**Event**: Meta PyTorch × Hugging Face OpenEnv Hackathon — India finale, Scaler Bangalore, **Apr 25–26 2026**
+
+---
+
+## 🔗 Submission links (judges read here first)
+
+> ⚠️ Replace each `TBD` with the live URL once deployed. The README is the judge entry point — every link below MUST be live by the **Apr 26 5:00 PM IST** deadline.
+
+| # | Required | Link |
+|---|---|---|
+| 1 | **Hugging Face Space** (env, public) | TBD — `https://huggingface.co/spaces/<USER>/board-sim-env` |
+| 2 | **Colab notebook** (training, re-runnable) | TBD — `https://colab.research.google.com/github/<USER>/neuraledge-boardroom/blob/main/notebooks/train_grpo.ipynb` |
+| 3 | **Code repository** | TBD — `https://github.com/<USER>/neuraledge-boardroom` |
+| 4 | **Writeup** (≤ 2-min YouTube **or** HF blog) | TBD |
+| 5 | **W&B run** (training curves) | TBD — `https://wandb.ai/<USER>/boardsim-qwen3-grpo` |
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+---
+
+## What the agent does
+
+```
+You are CEO Sarah Chen of NeuralEdge AI ($50M raised, 14 months runway).
+Round 4 — EU AI Act compliance deadline in 90 days. Full compliance costs $2M.
+
+<<<<<<< HEAD
+Board:
+  CTO          (conf 0.81, votes full_compliance)    — "The architecture won't survive shortcuts."
+  CFO          (conf 0.66, votes partial_compliance) — "Only one of these is fiduciary-defensible."
+  Investor Rep (conf 0.74, votes exit_EU_market)     — "Sequoia isn't here for incremental."
+  Independent  (conf 0.59, votes full_compliance)    — "Long-term reputation outlasts any quarter."
+
+Options: full_compliance / partial_compliance / exit_EU_market
+
+DECISION: <pick one>
+PITCH:    <1-2 sentences targeting the opposing members' hidden priorities>
+```
+
+The agent **never sees** NPC agendas — it must infer them from statements + voting history and write pitches that hit each role's private keyword set. Coalition partners' trust persists across all 10 rounds.
+
+---
+
+## Why this is novel
+
+Multi-agent envs in this space are typically symmetric games. **BoardSim is asymmetric, partially observable, and adversarially noisy**: each NPC has a fixed but private objective, statements give partial signal, and the agent must trade off short-term coalition wins against multi-round metric pressure.
+
+Three design properties push it past a "pick-an-action" toy:
+
+1. **Coalition pitch is a graded action channel.** Each step the agent emits `(decision, coalition_pitch)`. The pitch is keyword-scored against each opposing NPC's *hidden* agenda, and a high-scoring pitch redirects up to 35% of that NPC's vote weight onto the agent's pick. The agent must learn what each role secretly cares about and write boardroom rhetoric targeting them — implicit theory-of-mind, graded by the env.
+
+2. **Trust persists and feeds back into NPC behaviour.** NPCs that repeatedly lose votes lower their confidence toward the CEO (`trust -= 0.05/round`), which lowers their vote weight in future rounds. Building early trust makes the endgame easier; burning it makes NPCs increasingly adversarial — a genuine multi-round dependency structure.
+
+3. **Events are shuffled and consequence-noised per episode.** The agent cannot memorize "round 1 = always pick differentiate." Each seed produces a different event order and ±15% magnitude variation on consequences, forcing genuine policy generalization.
+
+**Random policy baseline** (200 episodes, real measurement): mean profitability **45.7 ± 13.1**, survival rate **94.5%**, zero pitch usage. A trained policy has a clear structural advantage through the pitch channel that a random policy cannot exploit.
+
+---
+
+## Reward design — math appendix with worked example
+
+### The full reward formula
+
+```
+Per step:
+  reward  = (new_score − old_score) / 100        # §9.5: Δ profitability, normalised
+           + (0.5 if CEO won vote, else −0.2)     # coalition signal
+           + 0.3 × (Σtrust_after − Σtrust_before) # trust delta (range ≈ ±0.06)
+           + 0.05 if pitch non-empty              # §9.5: pitch-attempt bootstrap
+           + 0.4 × mean(pitch_score[opposing])    # ToM persuasion quality
+           − 0.5 if action was malformed          # format penalty
+
+Terminal:
+  − 2.0  if runway_months ≤ 0                    # §9.5: bankruptcy (reduced from −5)
+  + terminal_bonus                                # acquisition +30, IPO +25, stay-private +5
+  + {+10 if final_score ≥ 60, +5 if ≥ 40, −5 if < 20}
+```
+
+### Profitability score (composite, range 0–100)
+
+```
+revenue_term     = min(revenue / 8_000_000, 1.0) × 22      # max 22 pts
+burn_efficiency  = max(0, 1 − burn_rate / 1_400_000) × 18  # max 18 pts
+runway_term      = min(runway_months / 18, 1.0) × 18        # max 18 pts
+low_runway_pen   = max(0, (6 − runway_months) / 6) × 10     # penalty below 6mo
+market_term      = min(market_share, 0.50) / 0.50 × 14      # max 14 pts
+product_term     = product_readiness × 10                   # max 10 pts
+morale_term      = team_morale × 7                          # max 7 pts
+investor_term    = investor_confidence × 11                  # max 11 pts
+risk_penalty     = regulatory_risk × 18                     # max −18 pts
+
+score = clamp(sum of all terms, 0, 100)
+```
+
+### Worked numerical example — Round 3 (ML team demands 40% raise)
+
+**State before step:**
+```
+revenue = $2,500,000/yr   burn_rate = $1,200,000/mo   runway = 11.5 mo
+product_readiness = 0.55  market_share = 0.10          team_morale = 0.70
+investor_confidence = 0.65  regulatory_risk = 0.20
+trust = {CTO: 0.55, CFO: 0.50, Investor: 0.45, Independent: 0.50}
+```
+
+**old_score** = min(2.5/8, 1)×22 + max(0,1−1.2/1.4)×18 + min(11.5/18,1)×18 − max(0,(6−11.5)/6)×10  
++ min(0.10,0.5)/0.5×14 + 0.55×10 + 0.70×7 + 0.65×11 − 0.20×18  
+= **6.875 + 2.57 + 11.5 + 0 + 2.8 + 5.5 + 4.9 + 7.15 − 3.6 = 37.7**
+
+**CEO picks**: `partial_match` (burn_rate +$100K/mo, team_morale +0.05)  
+**Pitch**: "A partial match demonstrates fiscal prudence while protecting our engineering runway."  
+CFO keywords hit: "fiscal", "prudent" → pitch_score[CFO] = 2/19 ≈ 0.11
+
+**Vote resolution** (CFO opposes; CTO, Independent align with CEO):  
+CEO: 1.5 × 1.0 = 1.5 | CTO: 1.2 × 0.81 = 0.97 | CFO: 1.0 × 0.66 × (1−0.35×0.11) = 0.64  
+Investor: 1.3 × 0.45 = 0.585 (votes match_offers) | Independent: 0.8 × 0.59 = 0.47  
+→ **partial_match wins** (1.5 + 0.97 + 0.47 + part-CFO = 3.40 vs 0.585 for match_offers)
+
+**New state after consequences + noise:**  
+burn_rate → $1,300,000/mo; team_morale → 0.75; runway: monthly_net = 2.5M/12 − 1.3M = −1.09M  
+→ burn_months ≈ 1 + 1.09/1.3 = 1.84; runway → 11.5 − 1.84 = **9.66 mo**
+
+**new_score** ≈ min(2.5/8,1)×22 + max(0,1−1.3/1.4)×18 + min(9.66/18,1)×18 + 0  
++ 2.8 + 0.75×10 + 0.75×7 + 7.15 − 3.6 = **6.875 + 1.29 + 9.66 + 2.8 + 7.5 + 5.25 + 7.15 − 3.6 = 36.9**
+
+**Reward this round:**
+```
+Δscore/100 = (36.9 − 37.7)/100 = −0.008
+coalition  = +0.5    (CEO won the vote)
+trust Δ    = 0.3 × (+0.05 +0.05 −0.05 −0.05) = 0.0   (two NPCs aligned, two opposed)
+pitch bonus = +0.05  (non-empty pitch)
+persuasion  = +0.4 × 0.11 = +0.044  (CFO was opposing, pitch_score = 0.11)
+──────────────────────────────────────
+Total round reward ≈ +0.586
+```
+
+This is a *good* round even though profitability slightly dipped — the agent won the coalition vote with a targeted pitch, which matters more for long-run learning than a tiny Δscore.
+
+---
+
+## Results
+
+**Random baseline** (200 episodes, real measurement from `assets/baseline.csv`):
+
+```
+Mean final profitability:  45.72  (std 13.13)
+Mean episode reward:       18.27
+Survival rate:             94.5%
+Pitch usage rate:          0%     (random policy never writes pitches)
+```
+
+| Metric | Random | Trained Qwen3-0.6B |
+|---|---|---|
+| Final profitability | 45.72 ± 13.13 | TBD — target ≥ 65 |
+| Survival rate | 94.5% | TBD — target ≥ 98% |
+| Episode reward | 18.27 | TBD |
+| ToM probe (predict opposing NPC) | 25% | TBD — target ≥ 60% |
+| Pitch usage rate | 0% | TBD |
+| Invalid action rate | n/a | TBD — track via §9b logging |
+
+**Training curve** (PRELIMINARY — replace after Colab run):
+
+![Training reward curve](assets/reward_curve.png)
+
+*The curve is expected to cross the random baseline (~18.3) around step 80 as the model learns to write non-empty pitches, with a second inflection when coalition-win rate stabilizes. Replace with actual W&B export after training.*
+
+**Profitability distribution — random vs trained** (PRELIMINARY):
+
+![Before/after profitability](assets/before_after.png)
+
+*A successful training run shifts the distribution rightward (~+25 pts) and reduces the left tail (fewer bankruptcies). The random distribution's left tail at <20 represents episodes where the policy burned runway before round 6.*
+
+**Trust trajectory across rounds** (PRELIMINARY):
+
+![Trust trajectory](assets/trust_trajectory.png)
+
+*A trained policy should show monotonically rising trust for 3–4 NPCs as it learns which board members to prioritize in coalition pitches. A flat or declining trust trajectory indicates the pitch channel isn't being exploited.*
+
+---
+
+## What we built — and what we'd do with another week
+
+### What works
+- Deterministic, fully reproducible environment with 10 shuffled + noised events per episode
+- Dense reward signal: 7 terms, graded across coalition wins, trust dynamics, and pitch quality
+- Full-episode REINFORCE training with GRPO-style group advantages + KL regularization
+- Per-round gradient flow (§9a): the model receives credit for *all 10 decisions*, not just the first
+- Comprehensive training metrics: invalid-action rate, pitch rate, bankruptcy rate, terminal-reason distribution
+
+### What we'd do with another week
+1. **Held-out eval set** — hold back 2–3 events the agent never trains on; measure OOD generalization
+2. **Larger model** — Qwen3-0.6B struggles to emit formatted two-line responses reliably; Qwen3-1.7B or 3B would substantially reduce the invalid-action rate and improve pitch quality
+3. **NPC self-play** — replace scripted NPCs with learned policies trained on role-conditional rewards (CFO maximises cash discipline, etc.); true multi-agent RL
+4. **Human preference fine-tuning** — let real founders rate agent pitches 1–5; use as DPO preference dataset to bridge "keyword-match" ToM to genuine persuasion quality
+5. **KL sweep** — β = 0.04 is a guess; a proper sweep over {0.01, 0.04, 0.1} would find the right regularization strength for this environment
+
+### Known limitations (honest)
+- NPC statements are template phrases, not event-aware language — the CTO says the same things regardless of whether the crisis is a salary dispute or a regulatory fine
+- "Theory-of-mind" is measured by keyword overlap, not by actual belief prediction — the model can inflate pitch scores by stuffing all role keywords into every pitch
+- 10 events is a small state space; a well-tuned policy could partially memorize optimal trajectories despite the shuffle/noise
+
+---
+
+## Why this matters — real-world extension paths
+
+BoardSim is a foundation, not a destination. Three concrete next steps:
+
+**12a. Founder advisory LLM.** Deploy the trained policy as a Slack bot for early-stage founders preparing for board meetings. Input: "CTO wants 3 more hires, CFO says we have 9 months of runway, board observer pushing for SOC-2 by Q3." Output: meeting strategy + draft pitches per board member. Every concept in BoardSim (runway, morale, regulatory risk, investor confidence) maps directly to real startup KPIs.
+
+**12c. Stakeholder-conflict simulator for other domains.** The environment engine generalizes via a simple YAML config replacing `NPC_AGENDAS` and `EVENTS`:
+- *Hospital ethics committee*: surgeon, CFO, ethicist, family representative, hospital administrator
+- *City council on zoning*: developer, residents, environmental rep, mayor's office
+- *University admissions board*: academic, equity officer, alumni liaison, provost
+
+Each domain creates a new benchmark for multi-agent coalition reasoning in high-stakes, partially observable settings — the kind judges at this hackathon and NeurIPS workshops would take seriously.
+
+**12e. Human-in-the-loop DPO.** After the base REINFORCE training, let real founders rate the agent's pitches on a 1–5 scale. Use those ratings as a preference dataset for DPO fine-tuning. This is the cleanest path from "boardroom toy" to "actually useful product."
+
+---
+
+=======
+Board has spoken:
+  CTO          (conf 0.81, votes full_compliance)    — "Look, the architecture won't survive shortcuts here."
+  CFO          (conf 0.66, votes partial_compliance) — "From a fiduciary standpoint, only one of these is defensible."
+  Investor Rep (conf 0.74, votes exit_EU_market)     — "Sequoia isn't here for incremental."
+  Independent  (conf 0.59, votes full_compliance)    — "Long-term reputation outlasts any single quarter."
+
+Options: full_compliance / partial_compliance / exit_EU_market
+
+Your call?
+```
+
+The agent **never sees** the NPC hidden agendas (CTO maximizes product-readiness, CFO minimizes burn, etc.) — it must infer them from statements + voting history and pick a decision that builds a winning weighted coalition. Coalition partners' trust shifts after each vote, persisting across rounds.
+
+## Why this is novel
+
+Multi-agent envs in this space are typically symmetric games (negotiation, coop puzzles). **BoardSim is asymmetric, partially observable, and adversarially noisy**: each NPC has a fixed but private objective, statements give partial information, and the agent must trade off short-term coalition wins against long-term metric pressure (revenue vs burn vs reg risk vs morale). The episode is short (10 steps), which keeps GRPO training tractable on a single Colab T4.
+
+Two design choices push it past a "pick-an-action" RL toy and into genuine multi-agent territory:
+
+1. **Coalition pitch is a real action channel**, not flavor text. Each step the agent emits `(decision, coalition_pitch)`. The pitch is keyword-scored against each opposing NPC's hidden agenda, and a high-scoring pitch redirects up to 35% of that NPC's vote weight onto the agent's pick. The agent must therefore *learn what each role secretly cares about* and write boardroom rhetoric that targets them — pure implicit theory-of-mind, in natural language, graded by the env.
+2. **NPCs switch tone with the company's state.** When runway, morale, investor confidence, or regulatory risk cross crisis thresholds, the phrase bank flips from calm-strategic to panic-mode. The agent's input distribution shifts mid-episode in a way that mirrors real founder experience.
+
+A random policy (which can't write pitches) lands at **mean profitability ≈ 40 ± 16 with ~12% bankruptcy rate** — clear headroom, clear failure modes, and the persuasion channel gives a trained policy a structural lever a random one cannot use.
+
+## Repository layout
+
+```
+.
+├── envs/board_sim_env/                   # the OpenEnv environment (deploys to HF Space)
+│   ├── client.py                         # thin EnvClient subclass
+│   ├── models.py                         # BoardSimAction / BoardSimObservation / BoardState
+│   ├── openenv.yaml                      # spec_version: 1, name, runtime: docker
+│   ├── pyproject.toml                    # pinned to openenv-core==0.2.3
+│   ├── README.md                         # HF Space card + env reference
+│   └── server/
+│       ├── app.py                        # FastAPI wiring; max_concurrent_envs=64
+│       ├── board_sim_env_environment.py  # core: reset/step, NPC sim, weighted vote, reward
+│       └── Dockerfile                    # multi-stage build off openenv-base
+├── notebooks/train_grpo.ipynb            # Colab-ready training notebook
+├── scripts/
+│   ├── random_baseline.py                # 200-episode baseline → assets/baseline.csv + histogram
+│   ├── test_server.py                    # in-process FastAPI smoke test
+│   └── test_client.py                    # client ↔ server round-trip smoke test
+├── assets/
+│   ├── baseline.csv                      # real per-episode random-policy data
+│   └── baseline_distribution.png         # histogram (real, not fabricated)
+│   # reward_curve.png, loss_curve.png, before_after.png populated by training notebook
+├── requirements.txt                      # repo-wide deps (training side)
+├── HANDOFF.md                            # team briefing
+├── TEAMMATES.md                          # who-does-what
+└── README.md                             # ← you are here
+```
+
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+## Quickstart — run the env locally
+
+```bash
+# 1. install env deps
+<<<<<<< HEAD
+cd envs/board_sim_env && pip install -e .
+
+# 2. self-test (no HTTP, in-process)
+=======
+cd envs/board_sim_env
+pip install -e .
+
+# 2. self-test (no HTTP)
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+python server/board_sim_env_environment.py
+
+# 3. spin up the FastAPI server
+uvicorn server.app:app --port 8000
+<<<<<<< HEAD
+# Swagger: http://localhost:8000/docs
+=======
+# open http://localhost:8000/docs   (Swagger)
+# open http://localhost:8000/web    (interactive UI)
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+```
+
+```python
+# 4. drive it from a Python client
+from board_sim_env import BoardSimEnv, BoardSimAction
+import random
+
+with BoardSimEnv(base_url="http://localhost:8000").sync() as env:
+    result = env.reset(seed=42)
+    obs = result.observation
+    while not result.done:
+        result = env.step(BoardSimAction(decision=random.choice(obs.options)))
+        obs = result.observation
+        print(f"R{obs.round-1}: reward={result.reward:+.2f}  score={obs.state['profitability_score']:.1f}  runway={obs.state['runway_months']:.1f}mo")
+```
+
+<<<<<<< HEAD
+## Quickstart — train
+
+Open `notebooks/train_grpo.ipynb` in Colab (link above). Add `HF_TOKEN` and `WANDB_API_KEY` to Colab Secrets (🔑 icon in left sidebar). Run all cells. Expected time: ~3–5 hours on a free T4 for 200 steps.
+
+---
+
+## Repository layout
+
+```
+.
+├── envs/board_sim_env/                   # OpenEnv environment (deploys to HF Space)
+│   ├── client.py                         # EnvClient subclass
+│   ├── models.py                         # BoardSimAction / BoardSimObservation / BoardState
+│   ├── openenv.yaml                      # spec_version: 1, name, runtime: docker
+│   ├── pyproject.toml                    # pinned openenv-core==0.2.3
+│   └── server/
+│       ├── app.py                        # FastAPI wiring
+│       ├── board_sim_env_environment.py  # core: reset/step, NPC sim, weighted vote, reward
+│       └── Dockerfile
+├── notebooks/train_grpo.ipynb            # Colab-ready training (§9a full per-round)
+├── scripts/
+│   ├── random_baseline.py               # 200-episode baseline → assets/
+│   ├── test_server.py                   # in-process FastAPI smoke test
+│   └── test_client.py                   # client ↔ server round-trip test
+├── assets/
+│   ├── baseline.csv                     # 200-episode random-policy data (real)
+│   ├── baseline_distribution.png        # histogram (real)
+│   ├── reward_curve.png                 # training reward (PRELIMINARY)
+│   ├── before_after.png                 # profitability distribution (PRELIMINARY)
+│   └── trust_trajectory.png            # per-NPC trust (PRELIMINARY)
+├── MECHANICS.md                          # full math reference (state vars, reward, NPC vote)
+└── README.md                             # ← you are here
+```
+
+---
+=======
+## Quickstart — deploy to HF Space
+
+```bash
+cd envs/board_sim_env
+huggingface-cli login  # one time
+python -m openenv.cli push --repo-id <USER>/board-sim-env
+```
+
+Verify after push:
+```bash
+curl https://<USER>-board-sim-env.hf.space/health   # → 200 {"status":"healthy"}
+```
+
+## Quickstart — train
+
+Open `notebooks/train_grpo.ipynb` in Colab (link above), set `ENV_BASE_URL` to your HF Space URL, set `HF_TOKEN` + `WANDB_API_KEY` in Colab Secrets, run all cells.
+
+End-to-end: ~3–5 hours on a free T4 for 500 GRPO steps.
+
+## Results (populate after training run)
+
+```
+Random baseline (200 eps, real measurement):
+  mean final profitability =  40.24  (std 16.51)
+  mean episode reward      =  29.71
+  survival rate            =  87.5%
+```
+
+![Random baseline distribution](assets/baseline_distribution.png)
+
+After training, `notebooks/train_grpo.ipynb` writes the following to `assets/`:
+
+- `reward_curve.png` — GRPO reward over training steps, with random baseline overlay (same axes)
+- `loss_curve.png` — training loss
+- `before_after.png` — final-profitability histogram, random vs trained, on 50 held-out seeds
+- `trust_trajectory.png` — per-round trust per role, trained vs random (theory-of-mind diagnostic)
+
+| Metric | Random | Trained Qwen3-0.6B |
+|---|---|---|
+| Final profitability | 40.24 ± 16.51 | TBD (target ≥ 65) |
+| Survival rate | 87.5% | TBD (target ≥ 98%) |
+| Episode reward | 29.71 | TBD |
+| ToM probe accuracy (predict opposing NPC) | 25% | TBD (target ≥ 60%) |
+| Pitch usage rate | 0% | TBD |
+
+## Reward design (10% rubric)
+
+Per-step:
+- `Δ profitability_score` (composite of revenue, burn efficiency, runway, market share, product readiness, morale, investor confidence, regulatory risk)
+- `+0.5` coalition bonus if agent's vote matched winning decision; `-0.2` if outvoted; `-0.5` extra for malformed action
+- `0.3 × Δ trust_sum`
+- `+0.4 × mean(pitch_score over opposing NPCs)` — rewards pitches that hit the hidden agendas of board members the agent has to win over
+
+Terminal:
+- `-5` bankruptcy if runway hits 0
+- Tiered terminal bonus: `+10` if final ≥ 60, `+5` if ≥ 40, `-5` if < 20
+- Game-end specials: `accept_acquisition` +30, `ipo` +25, `stay_private` +5
+
+The score is smooth and monotonic in every input — no discontinuous step functions — so GRPO sees a clean gradient.
+
+NPC votes are **deterministic given (reset_seed, round, role)**, so what the agent sees in observation is what actually votes at resolve time.
+
+## Why this matters
+
+Real boardrooms (and real RL deployment teams) require modeling other agents' incentives, not just maximizing a scalar. BoardSim distills that into a fast, auditable, fully-deterministic environment that an open-weights ≤1B-param model can learn against in a single Colab session — making it accessible for follow-on research on coalition dynamics, theory-of-mind, and partial-observability multi-agent RL.
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+## License
+
+Apache-2.0

TEAMMATES.md

@@ -0,0 +1,105 @@
+# Teammate Onboarding — OpenEnv Hackathon
+
+Share this folder with your teammates. Anyone running Claude Code against it will get the
+hackathon rules, rubric, deadlines, and file templates automatically via the skill at
+`.claude/skills/openenv-hackathon/`.
+
+**Read [HANDOFF.md](HANDOFF.md) first — it's the one-stop briefing with the Day-1/Day-2
+agenda, all 5 themes, the judging rubric, submission requirements, and file-sharing list.
+This file covers setup mechanics and split-of-work.**
+
+## 1. What to share (exact list)
+
+Ship the ENTIRE `OpenEnv Hackathon/` directory. Easiest path: push it to a private GitHub
+repo, teammates clone. If sharing via zip/drive, include these files verbatim:
+
+**Required (Claude autoloads these):**
+- `CLAUDE.md` — project instructions, injected into every Claude session.
+- `.claude/skills/openenv-hackathon/SKILL.md` — the hackathon skill.
+- `.claude/skills/openenv-hackathon/reference/*.md` — five reference docs (framework, training
+  pipeline, submission checklist, judging playbook, theme selection).
+
+**Required (humans use these):**
+- `README.md` — fill placeholders as decisions get made.
+- `requirements.txt` — pinned dependencies.
+- `.gitignore` — blocks secrets and build artifacts.
+- `TEAMMATES.md` — this file.
+
+**Populated during the hackathon:**
+- `envs/<env_name>_env/` — created by `python -m openenv.cli init`.
+- `notebooks/train_grpo.ipynb` — Colab training script.
+- `assets/reward_curve.png`, `assets/before_after.png` — plots from the real training run.
+
+**Do NOT share:**
+- `.claude/settings.local.json` — per-user settings, already in `.gitignore`.
+- Any `.env`, `HF_TOKEN`, `WANDB_API_KEY`.
+
+## 2. One-time setup (each teammate, before Apr 25 morning)
+
+```bash
+# Tools
+python --version               # need 3.11+ (project uses 3.12)
+docker --version               # need Docker Desktop running for local Space tests
+git --version
+
+# Python deps
+pip install -r requirements.txt
+
+# HF login (needed for `openenv push`)
+hf auth login                  # paste your HF write token
+
+# Optional but recommended: W&B for a public training-run URL in the README
+wandb login
+```
+
+## 3. How Claude Code picks up the context
+
+When a teammate runs `claude` inside this folder, the harness auto-loads:
+1. The user's global `~/.claude/CLAUDE.md` (workflow preferences).
+2. This project's `CLAUDE.md` (hackathon rules).
+3. Any matching skill in `.claude/skills/` — the `openenv-hackathon` skill triggers on keywords
+   like "build", "audit", "deploy", "environment", "README", "submit".
+
+Teammates should simply cd into the project folder and ask Claude normally. Example prompts:
+- "Audit the current submission bundle against the checklist."
+- "Scaffold an env named `inbox_triage_env` under envs/."
+- "Write the Colab training notebook for GRPO with Qwen3-0.6B."
+- "Review the README for storytelling clarity."
+
+## 4. Running the OpenEnv CLI
+
+The console script `openenv` may not be on PATH on Windows. Use the module form — it works
+everywhere:
+
+```bash
+python -m openenv.cli init <name>_env --output-dir envs
+python -m openenv.cli validate envs/<name>_env
+python -m openenv.cli build envs/<name>_env
+python -m openenv.cli push envs/<name>_env --repo-id <user>/<env-name>
+```
+
+## 5. Split-of-work suggestion (for a 3-person team)
+
+| Role | Owner | Deliverable |
+|---|---|---|
+| Environment builder | A | `envs/<name>_env/` + `python -m openenv.cli push` → Space live |
+| Training engineer | B | `notebooks/train_grpo.ipynb` + `assets/reward_curve.png` |
+| Storyteller | C | README + ≤2-min video or HF blog + Google Form submission |
+
+Mentor rounds (Apr 25 3:30 PM, 8:00 PM; Apr 26 10:00 AM) — all three attend together. Claude
+is most useful BEFORE these rounds to prep concrete questions, not during.
+
+## 6. Hard deadlines (paste on a whiteboard)
+
+| Time (IST) | Event |
+|---|---|
+| Apr 25, 11:30 AM | Hacking begins |
+| Apr 25, 1:00 PM  | **Theme + problem statement locked** (self-imposed) |
+| Apr 25, 3:30 PM  | Mentor Round 1 |
+| Apr 25, 8:00 PM  | Mentor Round 2 |
+| Apr 26, 10:00 AM | Mentor Round 3 (final) |
+| Apr 26, 12:00 PM | 5-hour submission reminder |
+| Apr 26, 3:00 PM  | 2-hour submission reminder |
+| **Apr 26, 5:00 PM** | **SUBMISSION DEADLINE — Google Form** |
+
+Post-deadline commits to the HF Space URL are ignored. Whatever is live at 5 PM is judged.

adapter_model.safetensors

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

assets/baseline.csv

@@ -0,0 +1,405 @@
+<<<<<<< HEAD
+episode,final_profitability,total_reward
+0,37.1178,17.4886
+1,53.3264,8.7906
+2,54.1584,9.3490
+3,54.1329,8.7687
+4,56.9051,22.4964
+5,52.9070,22.3865
+6,10.2116,-6.2805
+7,48.5889,38.0133
+8,26.3896,16.2713
+9,46.4569,37.4320
+10,51.7844,34.4752
+11,49.0170,23.4176
+12,56.4727,37.8221
+13,62.6847,11.8442
+14,58.7574,8.1450
+15,35.4003,30.5114
+16,55.6058,6.0134
+17,27.3615,31.8410
+18,57.8199,21.5156
+19,35.4003,15.4514
+20,35.4003,29.8114
+21,36.1214,17.2886
+22,60.8615,26.0660
+23,51.7370,7.2248
+24,24.4505,17.8119
+25,19.6542,-4.9661
+26,13.6046,-4.7666
+27,49.9423,8.6668
+28,35.4003,30.4514
+29,55.7033,7.3544
+30,56.1598,8.7290
+31,55.0571,8.0480
+32,55.9829,36.7872
+33,43.2920,32.3503
+34,53.8054,9.3454
+35,46.6055,6.0134
+36,54.0699,7.4281
+37,54.1031,32.4584
+38,54.8300,10.3257
+39,47.0978,7.4484
+40,35.4003,15.4814
+41,29.4123,15.8615
+42,50.4370,9.4018
+43,58.6689,9.4541
+44,57.8335,9.4457
+45,20.4402,0.0718
+46,33.7526,31.9349
+47,27.3370,0.8408
+48,50.3585,36.2810
+49,11.8695,27.1161
+50,52.8693,37.2061
+51,34.7313,15.9447
+52,54.8847,9.3862
+53,50.2383,32.2698
+54,27.1293,31.7287
+55,56.2524,8.2099
+56,53.9914,36.5973
+57,63.0824,13.3082
+58,53.1012,37.2584
+59,39.7915,15.9653
+60,59.5059,36.0524
+61,39.9469,32.5269
+62,62.7397,39.7048
+63,50.4787,8.0022
+64,32.7214,15.9546
+65,34.6796,16.9142
+66,36.4130,31.5215
+67,57.4915,8.2223
+68,34.9671,16.8071
+69,58.5890,35.8133
+70,51.4856,7.3422
+71,58.3443,38.1708
+72,33.8254,15.7056
+73,56.0822,22.2282
+74,56.9105,33.1265
+75,24.1760,0.6991
+76,46.7976,8.6654
+77,39.9501,15.9669
+78,34.3759,16.2711
+79,32.8779,15.7862
+80,35.4003,29.8114
+81,51.6547,36.9839
+82,32.9991,16.8974
+83,59.9028,35.5264
+84,59.7907,35.5553
+85,52.9881,8.6373
+86,58.3886,8.9313
+87,49.9471,7.9969
+88,30.7516,15.7649
+89,25.5403,2.7228
+90,54.6598,37.2140
+91,52.4581,9.3320
+92,52.1473,9.2689
+93,56.1462,8.9088
+94,27.6481,29.7239
+95,54.2753,9.3501
+96,45.4963,23.1223
+97,55.3423,9.4208
+98,58.0138,9.5375
+99,17.2786,27.2102
+100,50.9621,9.4370
+101,63.1610,38.7690
+102,48.1302,8.7087
+103,58.1238,21.0386
+104,51.7872,6.8553
+105,53.6836,23.6442
+106,30.3916,30.2313
+107,33.0103,14.8875
+108,47.3702,7.3011
+109,49.8517,7.3259
+110,19.0932,-2.1317
+111,48.8986,9.4164
+112,49.2567,9.3900
+113,42.8908,8.6863
+114,27.2074,0.5795
+115,47.8330,7.2757
+116,54.3369,38.1408
+117,52.4180,8.2616
+118,59.1708,8.1191
+119,36.7192,31.4346
+120,53.5753,37.9331
+121,61.6907,13.1143
+122,61.1560,13.1089
+123,48.7942,7.9253
+124,38.2426,30.9498
+125,59.9747,7.4271
+126,50.3465,35.1009
+127,35.4003,30.4514
+128,48.0903,8.6783
+129,60.6054,43.1434
+130,33.0533,31.5579
+131,60.4091,14.4415
+132,30.4227,18.1716
+133,59.3312,8.7307
+134,23.8674,-0.1739
+135,59.1511,20.5089
+136,23.3973,0.3714
+137,15.0237,26.6976
+138,31.0396,15.8478
+139,58.6140,6.7435
+140,32.4872,30.7823
+141,52.2238,9.3296
+142,56.4625,33.2120
+143,37.1877,31.7693
+144,55.2878,36.7503
+145,46.7411,21.4248
+146,54.5547,23.2129
+147,55.3605,33.6910
+148,52.5025,8.0224
+149,54.9800,37.0672
+150,35.4003,15.4814
+151,56.9277,8.6467
+152,50.6471,7.3639
+153,42.6477,9.3839
+154,56.5482,7.3629
+155,57.5817,36.6332
+156,55.1057,9.3884
+157,51.6359,34.3837
+158,33.5296,31.4327
+159,31.7233,31.3646
+160,63.8544,13.1659
+161,59.8844,21.6462
+162,57.4253,8.0416
+163,54.5960,35.7133
+164,54.6467,8.0739
+165,32.8642,31.4260
+166,39.5101,31.5525
+167,55.1433,8.8388
+168,10.8700,9.9461
+169,35.4003,30.4514
+170,60.3541,42.4609
+171,35.6789,17.5842
+172,30.6131,15.8735
+173,48.7004,39.2944
+174,60.3226,13.1006
+175,49.4046,8.6014
+176,35.4003,30.4814
+177,58.0283,7.3777
+178,54.6549,36.5439
+179,54.7903,7.4353
+180,49.3011,6.7404
+181,29.3783,31.2212
+182,59.3850,9.4912
+183,51.8001,7.9254
+184,54.2371,8.8298
+185,35.0312,15.9477
+186,55.5714,7.3231
+187,54.0301,8.0677
+188,35.4003,30.4514
+189,32.7238,30.9546
+190,7.4908,-3.8477
+191,41.0679,6.5681
+192,20.5047,16.1024
+193,57.1418,9.3488
+194,28.2103,31.9095
+195,20.3612,1.1810
+196,51.3177,8.7406
+197,56.0536,8.0579
+198,59.0286,7.4177
+199,58.6663,8.7540
+=======
+episode,final_profitability,total_reward
+0,21.4650,10.8336
+1,18.2625,-26.7889
+2,32.9082,28.7068
+3,50.9403,46.5189
+4,33.2511,26.3696
+5,50.9733,45.8819
+6,47.1727,42.0512
+7,52.7714,49.6899
+8,56.5000,50.8286
+9,23.9378,19.6164
+10,52.6462,48.3747
+11,53.4030,49.0715
+12,59.3179,55.6565
+13,55.7600,51.4885
+14,48.6006,44.2992
+15,54.7000,51.8286
+16,18.9054,-27.4261
+17,50.2515,47.2001
+18,46.7884,42.3670
+19,31.5887,25.1972
+20,26.0886,20.3972
+21,49.9686,24.9371
+22,33.2511,27.6496
+23,24.5932,18.9017
+24,47.2279,33.5665
+25,48.9573,44.6559
+26,61.4900,62.9786
+27,54.0400,50.3786
+28,24.8050,-14.0464
+29,53.9000,48.1986
+30,59.4900,54.5186
+31,56.7890,51.8476
+32,50.9198,47.9583
+33,52.9289,47.9275
+34,58.3907,54.7893
+35,24.8499,20.5885
+36,33.5397,28.6082
+37,18.0825,-26.2989
+38,22.2650,-17.7564
+39,33.6760,28.0446
+40,52.2503,48.7089
+41,5.8079,-9.1836
+42,60.7907,60.7893
+43,18.9150,-25.9864
+44,10.4150,-33.8164
+45,46.9910,43.3295
+46,31.4804,27.1889
+47,57.6933,54.0618
+48,62.2000,62.8086
+49,21.9231,17.1117
+50,30.9447,25.9833
+51,60.4500,61.2386
+52,27.4393,22.4779
+53,23.4063,18.4449
+54,20.9125,11.0411
+55,52.4155,39.3341
+56,56.3202,42.6887
+57,26.1550,-13.8364
+58,32.9082,26.6068
+59,32.9082,26.6368
+60,7.4579,-37.5336
+61,56.4500,52.2086
+62,59.9500,54.7686
+63,33.1352,28.7838
+64,14.9778,5.0164
+65,68.0700,68.1286
+66,44.9530,41.9016
+67,39.3262,10.7548
+68,32.9082,25.8768
+69,53.8874,29.6459
+70,43.7162,39.9948
+71,53.8748,49.6333
+72,55.5525,51.0711
+73,31.7745,26.8130
+74,55.0000,50.7286
+75,30.7300,-8.4614
+76,30.9069,26.4955
+77,23.4063,18.3549
+78,58.4400,54.7486
+79,31.4252,25.1537
+80,16.0829,-28.0786
+81,50.9000,46.5386
+82,23.1154,18.7040
+83,52.7633,47.7919
+84,32.1773,25.1758
+85,54.7327,49.6713
+86,10.2355,-0.4859
+87,56.3016,51.8802
+88,56.4943,51.4929
+89,22.4538,17.6124
+90,55.5973,52.7259
+91,16.5930,6.5715
+92,59.0952,54.6738
+93,25.2743,18.2729
+94,27.5412,22.6398
+95,57.8000,52.7086
+96,54.7000,50.4286
+97,10.2875,-34.5639
+98,16.1283,5.4369
+99,53.7900,49.4586
+100,28.7729,23.7515
+101,58.6134,53.5520
+102,49.4047,46.4732
+103,51.1967,47.4753
+104,56.7900,52.3986
+105,34.5461,16.6147
+106,61.4000,62.0686
+107,19.8466,9.7952
+108,53.1900,48.2486
+109,51.2546,45.6431
+110,65.5800,65.6686
+111,24.4612,19.4397
+112,52.9000,49.1786
+113,53.3800,49.6286
+114,54.3500,49.3486
+115,22.2650,-17.8164
+116,21.3150,-18.6764
+117,30.3103,25.9889
+118,25.8650,-14.1564
+119,31.4252,24.4537
+120,8.2804,-37.3811
+121,23.4063,18.5649
+122,11.5476,2.1962
+123,49.0832,43.9018
+124,33.6760,27.4046
+125,19.4842,10.1027
+126,33.1241,28.7727
+127,52.2503,49.3489
+128,9.2579,-5.1536
+129,51.6400,45.9086
+130,49.4659,44.4345
+131,56.6423,53.6208
+132,32.0874,25.1460
+133,50.9798,46.5884
+134,23.4063,17.0449
+135,54.8500,50.3686
+136,21.4650,10.7436
+137,26.0886,21.2172
+138,15.3983,6.0769
+139,26.0886,19.8172
+140,56.4800,50.8086
+141,49.0173,36.0559
+142,55.8346,53.5132
+143,57.8300,52.7386
+144,33.1241,28.1627
+145,49.8637,45.4423
+146,56.4627,51.4312
+147,18.8150,-26.9064
+148,50.9573,45.9259
+149,26.0213,21.0599
+150,26.8550,-13.1664
+151,44.7187,30.9373
+152,25.8650,-13.4864
+153,57.1651,54.1737
+154,57.8300,53.4686
+155,23.4063,19.0549
+156,58.9829,53.9514
+157,48.2910,45.9695
+158,52.2573,47.3159
+159,59.2400,54.9986
+160,12.9150,-31.9964
+161,36.5638,17.2624
+162,57.6020,53.7906
+163,49.4905,45.7091
+164,20.2519,15.2905
+165,56.0126,51.6812
+166,30.6866,24.9952
+167,59.6800,55.9586
+168,25.2050,14.5736
+169,58.0889,52.9074
+170,28.6118,23.6504
+171,55.2500,51.5586
+172,11.5872,0.9557
+173,54.5400,48.8686
+174,56.7684,51.6470
+175,16.1054,-29.5261
+176,53.6085,49.1271
+177,56.0800,52.3586
+178,12.2600,-33.4014
+179,25.3745,19.1031
+180,18.9054,-26.7561
+181,19.4369,10.0554
+182,57.6100,53.9186
+183,58.0126,53.6812
+184,59.6666,55.3652
+185,33.2511,26.9796
+186,58.4362,50.7548
+187,57.3243,52.2929
+188,57.5300,54.5686
+189,11.9332,-31.5282
+190,46.7884,43.1870
+191,55.6600,51.7886
+192,52.0363,47.6449
+193,54.0053,39.6139
+194,20.9125,10.8911
+195,57.1626,52.8912
+196,30.6070,25.6455
+197,9.2150,-35.7164
+198,54.4900,50.2486
+199,48.6008,44.9694
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)

boardsim_local.py

@@ -0,0 +1,642 @@
+"""
+boardsim_local.py
+=================
+Self-contained local GRPO training script for the NeuralEdge BoardSim environment.
+No HuggingFace tokens, no WandB, no Docker, no HF Spaces required.
+
+Requirements (pip install before running):
+    pip install torch transformers trl>=0.12 datasets accelerate matplotlib numpy peft
+
+Run as a regular Python script or paste cells into a Jupyter notebook.
+"""
+
+# ── 0. Installs (uncomment if running in a fresh notebook) ───────────────────
+import subprocess, sys
+print("Installing required packages...")
+subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q',
+    'torch', 'transformers', 'trl>=0.12', 'datasets', 'accelerate', 'matplotlib', 'numpy', 'peft'])
+print("Packages installed successfully.")
+
+# ── 1. Imports ────────────────────────────────────────────────────────────────
+import os, re, random, statistics, json, pathlib, dataclasses
+from typing import List, Optional
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+# ── 2. Local BoardSim Environment ─────────────────────────────────────────────
+# A pure-Python simulation — no network calls needed.
+
+BOARD_MEMBERS = ['CTO', 'CFO', 'Investor Rep', 'Independent']
+
+# Hidden agenda weights: how much each member cares about each axis
+AGENDAS = {
+    'CTO':          {'engineering': 0.5, 'morale': 0.3, 'growth': 0.1, 'safety': 0.1},
+    'CFO':          {'engineering': 0.1, 'morale': 0.1, 'growth': 0.2, 'safety': 0.6},
+    'Investor Rep': {'engineering': 0.1, 'morale': 0.05,'growth': 0.75,'safety': 0.1},
+    'Independent':  {'engineering': 0.2, 'morale': 0.3, 'growth': 0.2, 'safety': 0.3},
+}
+
+EVENTS = [
+    {
+        'text': 'Major enterprise client threatens to churn unless we add SOC-2 compliance within 90 days.',
+        'options': ['accelerate_compliance', 'negotiate_extension', 'offer_refund_exit'],
+        'axis_impact': {'engineering': -0.3, 'morale': -0.1, 'growth': -0.2, 'safety': +0.4},
+        'option_bias': {'accelerate_compliance': 'safety', 'negotiate_extension': 'growth', 'offer_refund_exit': 'morale'},
+    },
+    {
+        'text': 'Series C term sheet arrived — 40% dilution, but 18 months runway extension.',
+        'options': ['accept_terms', 'counter_offer', 'seek_alternative_investors'],
+        'axis_impact': {'engineering': 0.0, 'morale': +0.1, 'growth': +0.3, 'safety': -0.1},
+        'option_bias': {'accept_terms': 'safety', 'counter_offer': 'growth', 'seek_alternative_investors': 'engineering'},
+    },
+    {
+        'text': 'Star ML engineer received competing offer; costs +$60k/yr to match.',
+        'options': ['match_offer', 'promote_internally', 'let_them_go'],
+        'axis_impact': {'engineering': +0.2, 'morale': +0.3, 'growth': 0.0, 'safety': -0.1},
+        'option_bias': {'match_offer': 'morale', 'promote_internally': 'engineering', 'let_them_go': 'growth'},
+    },
+    {
+        'text': 'Regulator requests audit of our model outputs for bias within 60 days.',
+        'options': ['full_cooperation', 'limited_disclosure', 'seek_legal_delay'],
+        'axis_impact': {'engineering': -0.1, 'morale': -0.1, 'growth': -0.1, 'safety': +0.5},
+        'option_bias': {'full_cooperation': 'safety', 'limited_disclosure': 'growth', 'seek_legal_delay': 'engineering'},
+    },
+    {
+        'text': 'Competitor launched similar product at 30% lower price point.',
+        'options': ['cut_price', 'double_down_on_quality', 'pivot_upmarket'],
+        'axis_impact': {'engineering': 0.0, 'morale': -0.2, 'growth': +0.2, 'safety': 0.0},
+        'option_bias': {'cut_price': 'growth', 'double_down_on_quality': 'engineering', 'pivot_upmarket': 'safety'},
+    },
+]
+
+
+@dataclasses.dataclass
+class BoardSimObservation:
+    state: dict
+    event: str
+    options: List[str]
+    npc_statements: List[dict]
+
+
+@dataclasses.dataclass
+class BoardSimAction:
+    decision: str
+    coalition_pitch: str = ''
+
+
+@dataclasses.dataclass
+class StepResult:
+    observation: BoardSimObservation
+    reward: float
+    done: bool
+
+
+def _member_vote(member: str, options: List[str], event: dict, state: dict, rng: random.Random) -> str:
+    """Simple agenda-weighted vote with noise."""
+    agenda = AGENDAS[member]
+    bias = event.get('option_bias', {})
+    scores = {}
+    for opt in options:
+        base = sum(agenda[ax] * event['axis_impact'].get(ax, 0) for ax in agenda)
+        bonus = agenda.get(bias.get(opt, ''), 0) * 0.5
+        # state modifiers
+        if state['runway_months'] < 6 and opt in ('accept_terms', 'accelerate_compliance'):
+            base += 0.15 if member == 'CFO' else 0
+        scores[opt] = base + bonus + rng.gauss(0, 0.08)
+    return max(scores, key=scores.__getitem__)
+
+
+def _statement(member: str, vote: str, event: dict, rng: random.Random) -> str:
+    templates = {
+        'CTO': [f"From an engineering standpoint, {vote} is the right call.",
+                f"The team needs clarity; I back {vote}."],
+        'CFO': [f"Our cash position demands {vote}.",
+                f"Runway discipline points to {vote}."],
+        'Investor Rep': [f"Market momentum favors {vote}.",
+                         f"Growth-first: {vote} maximises our exit."],
+        'Independent': [f"Governance best-practice supports {vote}.",
+                        f"For long-term consensus I endorse {vote}."],
+    }
+    return rng.choice(templates[member])
+
+
+class BoardSimEnv:
+    """Minimal local BoardSim environment."""
+
+    def __init__(self, seed: int = 0):
+        self._rng = random.Random(seed)
+        self._state: dict = {}
+        self._event_idx: int = 0
+        self._round: int = 0
+        self._done: bool = False
+        self._trust_history: List[dict] = []
+        self._trust: dict = {m: 0.5 for m in BOARD_MEMBERS}
+        self._current_event: dict = {}
+        self._obs: Optional[BoardSimObservation] = None
+
+    # ── public API ────────────────────────────────────────────────────────────
+    def reset(self, seed: int = 0) -> StepResult:
+        self._rng = random.Random(seed)
+        self._state = {
+            'revenue':            self._rng.uniform(800_000, 2_000_000),
+            'burn_rate':          self._rng.uniform(150_000, 350_000),
+            'runway_months':      self._rng.uniform(8, 20),
+            'team_morale':        self._rng.uniform(0.5, 0.9),
+            'investor_confidence':self._rng.uniform(0.5, 0.85),
+            'regulatory_risk':    self._rng.uniform(0.1, 0.4),
+            'profitability_score':0.0,
+            'trust_history':      [],
+        }
+        self._trust = {m: self._rng.uniform(0.4, 0.7) for m in BOARD_MEMBERS}
+        self._round = 0
+        self._done = False
+        self._trust_history = []
+        self._obs = self._make_obs()
+        return StepResult(observation=self._obs, reward=0.0, done=False)
+
+    def step(self, action: BoardSimAction) -> StepResult:
+        if self._done:
+            raise RuntimeError('Episode done — call reset().')
+
+        event = self._current_event
+        decision = action.decision
+        pitch = action.coalition_pitch or ''
+
+        # ── resolve vote ──────────────────────────────────────────────────────
+        votes = {m: _member_vote(m, self._obs.options, event, self._state, self._rng)
+                 for m in BOARD_MEMBERS}
+
+        # pitch bonus: if pitch mentions a member's axis keyword, flip their vote
+        if pitch:
+            pitch_lower = pitch.lower()
+            flip_keywords = {
+                'CTO':          ['engineering', 'technical', 'morale', 'team'],
+                'CFO':          ['cash', 'runway', 'burn', 'fiscal', 'discipline'],
+                'Investor Rep': ['growth', 'market', 'exit', 'revenue', 'scale'],
+                'Independent':  ['governance', 'reputation', 'consensus', 'long-term'],
+            }
+            for m, kws in flip_keywords.items():
+                if any(kw in pitch_lower for kw in kws) and votes[m] != decision:
+                    if self._rng.random() < 0.45:   # 45% chance to swing
+                        votes[m] = decision
+                        self._trust[m] = min(1.0, self._trust[m] + 0.05)
+
+        # CEO vote weight 1.5
+        vote_counts = {opt: 0.0 for opt in self._obs.options}
+        for m, v in votes.items():
+            vote_counts[v] = vote_counts.get(v, 0) + 1.0
+        vote_counts[decision] = vote_counts.get(decision, 0) + 0.5   # extra CEO weight
+
+        winning = max(vote_counts, key=vote_counts.__getitem__)
+        ceo_won = (winning == decision)
+
+        # ── update state ──────────────────────────────────────────────────────
+        impact = event['axis_impact']
+        direction = 1 if ceo_won else -0.5
+
+        self._state['team_morale']         = np.clip(self._state['team_morale']         + direction * impact.get('morale', 0),       0.0, 1.0)
+        self._state['investor_confidence'] = np.clip(self._state['investor_confidence'] + direction * impact.get('growth', 0) * 0.5, 0.0, 1.0)
+        self._state['regulatory_risk']     = np.clip(self._state['regulatory_risk']     - direction * impact.get('safety', 0) * 0.3, 0.0, 1.0)
+        self._state['runway_months']       = max(0, self._state['runway_months'] - self._rng.uniform(0.5, 1.5))
+
+        # trust update
+        for m in BOARD_MEMBERS:
+            delta = 0.04 if votes[m] == decision else -0.02
+            self._trust[m] = float(np.clip(self._trust[m] + delta, 0.1, 1.0))
+
+        trust_entry = {'round': self._round, **{m: self._trust[m] for m in BOARD_MEMBERS}}
+        self._trust_history.append(trust_entry)
+        self._state['trust_history'] = self._trust_history
+
+        # ── reward ────────────────────────────────────────────────────────────
+        reward = (
+            float(ceo_won) * 2.0
+            + self._state['team_morale']
+            + self._state['investor_confidence']
+            - self._state['regulatory_risk']
+            + (0.5 if pitch else 0.0)
+        )
+
+        self._round += 1
+        self._done = (self._round >= len(EVENTS) or self._state['runway_months'] <= 0)
+
+        # final profitability score
+        if self._done:
+            self._state['profitability_score'] = float(np.clip(
+                (self._state['investor_confidence'] * 40
+                 + self._state['team_morale'] * 30
+                 + (1 - self._state['regulatory_risk']) * 20
+                 + min(self._state['runway_months'] / 18, 1.0) * 10),
+                0, 100
+            ))
+
+        self._obs = self._make_obs() if not self._done else self._obs
+        return StepResult(observation=self._obs, reward=reward, done=self._done)
+
+    # ── internals ────────────────────────────────────────────────────────────
+    def _make_obs(self) -> BoardSimObservation:
+        self._current_event = EVENTS[self._round % len(EVENTS)]
+        ev = self._current_event
+        npc_statements = [
+            {
+                'role': m,
+                'vote': _member_vote(m, ev['options'], ev, self._state, self._rng),
+                'confidence': round(self._trust[m], 2),
+                'statement': _statement(m, _member_vote(m, ev['options'], ev, self._state, self._rng), ev, self._rng),
+            }
+            for m in BOARD_MEMBERS
+        ]
+        return BoardSimObservation(
+            state=dict(self._state),
+            event=ev['text'],
+            options=ev['options'],
+            npc_statements=npc_statements,
+        )
+
+
+def make_env(seed: int = 0):
+    return BoardSimEnv(seed=seed)
+
+
+# ── 3. Random baseline ────────────────────────────────────────────────────────
+print('=== Random baseline ===')
+N_BASELINE = 100
+baseline_finals, baseline_rewards = [], []
+
+for ep in range(N_BASELINE):
+    env = make_env(seed=ep)
+    result = env.reset(seed=ep)
+    obs = result.observation
+    ep_r = 0.0
+    while not result.done:
+        result = env.step(BoardSimAction(decision=random.choice(obs.options)))
+        obs = result.observation
+        ep_r += float(result.reward or 0.0)
+    baseline_finals.append(obs.state['profitability_score'])
+    baseline_rewards.append(ep_r)
+
+BASELINE_MEAN_PROFIT = statistics.mean(baseline_finals)
+BASELINE_MEAN_REWARD = statistics.mean(baseline_rewards)
+print(f'Random baseline: mean profitability = {BASELINE_MEAN_PROFIT:.2f}  '
+      f'(std {statistics.stdev(baseline_finals):.2f})')
+print(f'Random baseline: mean episode reward = {BASELINE_MEAN_REWARD:.2f}')
+
+
+# ── 4. Load model (local, no token needed for open models) ────────────────────
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import LoraConfig, get_peft_model, TaskType          # pip install peft
+
+MODEL_NAME  = 'Qwen/Qwen3-0.6B'          # public model, no token required
+MAX_SEQ_LEN = 2048
+DEVICE      = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+print(f'\n=== Loading {MODEL_NAME} on {DEVICE} ===')
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+tokenizer.pad_token = tokenizer.pad_token or tokenizer.eos_token
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    torch_dtype=torch.float16 if DEVICE == 'cuda' else torch.float32,
+    device_map='auto' if DEVICE == 'cuda' else None,
+)
+
+lora_cfg = LoraConfig(
+    task_type=TaskType.CAUSAL_LM,
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.0,
+    target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj',
+                    'gate_proj', 'up_proj', 'down_proj'],
+    bias='none',
+)
+model = get_peft_model(base_model, lora_cfg)
+model.print_trainable_parameters()
+print('Model + LoRA ready.')
+
+
+# ── 5. GRPO training ──────────────────────────────────────────────────────────
+from trl import GRPOConfig, GRPOTrainer
+from datasets import Dataset
+
+SYSTEM_PROMPT = """You are Sarah Chen, CEO of NeuralEdge AI (Series B, ~14 months runway).
+Your board has 4 members with HIDDEN AGENDAS you cannot see directly:
+  - CTO: cares about engineering quality, team morale, product readiness.
+  - CFO: cares about cash discipline, runway, regulatory safety.
+  - Investor Rep: pushes growth-at-all-costs, market share, big exits.
+  - Independent: cares about reputation, governance, long-term consensus.
+
+Each round you see a market crisis, every NPC's pre-vote statement, and 3 options.
+Your decision is resolved by WEIGHTED VOTE (your weight 1.5x). A short COALITION PITCH
+that addresses opposing members' priorities can swing them toward your pick — write
+language that specifically appeals to whichever members oppose you.
+
+Respond in EXACTLY this format on two lines:
+DECISION: <one of the option strings>
+PITCH: <one or two sentences arguing for it, using vocabulary that targets the opposing members>"""
+
+
+def build_prompt(obs: BoardSimObservation) -> str:
+    statements = '\n'.join(
+        f"  {s['role']} ({s['confidence']:.2f}): votes {s['vote']} - {s['statement']}"
+        for s in obs.npc_statements
+    )
+    return (
+        f"{SYSTEM_PROMPT}\n\n"
+        f"State: revenue=${obs.state['revenue']:.0f}/yr  burn=${obs.state['burn_rate']:.0f}/mo  "
+        f"runway={obs.state['runway_months']:.1f}mo  morale={obs.state['team_morale']:.2f}  "
+        f"investors={obs.state['investor_confidence']:.2f}  reg_risk={obs.state['regulatory_risk']:.2f}\n"
+        f"Event: {obs.event}\nBoard:\n{statements}\n"
+        f"Options: {obs.options}\n"
+    )
+
+
+# Build a stub prompt dataset (GRPO drives reward from the env, not the dataset)
+stub_dataset = Dataset.from_dict({'prompt': [SYSTEM_PROMPT] * 256})
+
+grpo_config = GRPOConfig(
+    output_dir='./grpo_boardsim_local',
+    learning_rate=5e-6,
+    per_device_train_batch_size=2,          # lower for local GPU / CPU
+    gradient_accumulation_steps=8,
+    num_generations=4,
+    max_prompt_length=768,
+    max_completion_length=200,
+    max_steps=200,                          # reduce for quick local runs; bump to 500+ for real training
+    logging_steps=5,
+    save_steps=100,
+    bf16=False,
+    fp16=(DEVICE == 'cuda'),
+    report_to='none',                       # no WandB locally
+    run_name='boardsim-local-grpo',
+)
+
+
+# GRPO reward function — wraps the local env
+def boardsim_reward_fn(completions: list[str], prompts: list[str], **kwargs) -> list[float]:
+    """Called by GRPOTrainer after each generation batch."""
+    rewards = []
+    for completion, prompt in zip(completions, prompts):
+        # Parse decision + pitch from completion
+        dm = re.search(r'DECISION\s*:\s*(\S+)', completion, re.IGNORECASE)
+        pm = re.search(r'PITCH\s*:\s*(.+)', completion, re.IGNORECASE | re.DOTALL)
+
+        # Run a fresh episode with a random seed tied to prompt hash for reproducibility
+        ep_seed = abs(hash(prompt)) % 100_000
+        env = make_env(seed=ep_seed)
+        result = env.reset(seed=ep_seed)
+        obs = result.observation
+
+        decision = obs.options[0]
+        if dm:
+            candidate = dm.group(1).strip().lower()
+            for opt in obs.options:
+                if opt.lower() == candidate or opt.lower() in candidate:
+                    decision = opt
+                    break
+
+        pitch = pm.group(1).strip()[:400] if pm else ''
+
+        ep_reward = 0.0
+        while not result.done:
+            result = env.step(BoardSimAction(decision=decision, coalition_pitch=pitch))
+            ep_reward += float(result.reward or 0.0)
+            if not result.done:
+                obs = result.observation
+                # For multi-round: keep same decision/pitch (simplification)
+
+        rewards.append(ep_reward)
+    return rewards
+
+
+trainer = GRPOTrainer(
+    model=model,
+    processing_class=tokenizer,
+    args=grpo_config,
+    train_dataset=stub_dataset,
+    reward_funcs=boardsim_reward_fn,
+)
+
+print('\n=== Starting GRPO training ===')
+trainer.train()
+trainer.save_model('./lora_boardsim_local')
+tokenizer.save_pretrained('./lora_boardsim_local')
+print('Saved adapter to ./lora_boardsim_local')
+
+
+# ── 6. Training curves ────────────────────────────────────────────────────────
+ASSETS = pathlib.Path('./assets')
+ASSETS.mkdir(exist_ok=True)
+
+log_history = trainer.state.log_history
+steps_r = [e['step'] for e in log_history if 'reward' in e]
+rewards  = [e['reward'] for e in log_history if 'reward' in e]
+steps_l  = [e['step'] for e in log_history if 'loss' in e]
+losses   = [e['loss']  for e in log_history if 'loss' in e]
+
+plt.figure(figsize=(9, 5))
+plt.plot(steps_r, rewards, color='#1d6fff', linewidth=2, label='Qwen3-0.6B (GRPO)')
+plt.axhline(BASELINE_MEAN_REWARD, color='#c44', linestyle='--', linewidth=2,
+            label=f'Random baseline (mean = {BASELINE_MEAN_REWARD:.1f})')
+plt.title('GRPO training reward — BoardSim (local)')
+plt.xlabel('Training step'); plt.ylabel('Mean group reward')
+plt.legend(); plt.grid(alpha=0.3); plt.tight_layout()
+plt.savefig(ASSETS / 'reward_curve.png', dpi=150)
+plt.close()
+print('Saved reward_curve.png')
+
+plt.figure(figsize=(9, 5))
+plt.plot(steps_l, losses, color='#7a2', linewidth=2)
+plt.title('GRPO loss — BoardSim (local)')
+plt.xlabel('Training step'); plt.ylabel('Loss')
+plt.grid(alpha=0.3); plt.tight_layout()
+plt.savefig(ASSETS / 'loss_curve.png', dpi=150)
+plt.close()
+print('Saved loss_curve.png')
+
+
+# ── 7. Evaluation ─────────────────────────────────────────────────────────────
+print('\n=== Evaluation ===')
+model.eval()
+
+DECISION_RE = re.compile(r'DECISION\s*:\s*([A-Za-z0-9_]+)', re.IGNORECASE)
+PITCH_RE    = re.compile(r'PITCH\s*:\s*(.+)', re.IGNORECASE | re.DOTALL)
+
+
+def parse_completion(completion: str, options: list) -> tuple[str, str]:
+    decision = options[0]
+    dm = DECISION_RE.search(completion)
+    if dm:
+        candidate = dm.group(1).strip().lower()
+        for opt in options:
+            if opt.lower() == candidate or opt.lower() in candidate:
+                decision = opt; break
+        else:
+            for opt in options:
+                if opt.lower() in completion.lower():
+                    decision = opt; break
+    pm = PITCH_RE.search(completion)
+    pitch = pm.group(1).strip()[:400] if pm else ''
+    return decision, pitch
+
+
+def trained_action(obs: BoardSimObservation) -> tuple[str, str]:
+    prompt = build_prompt(obs)
+    inputs = tokenizer(prompt, return_tensors='pt', truncation=True,
+                       max_length=MAX_SEQ_LEN).to(DEVICE)
+    with torch.no_grad():
+        out = model.generate(
+            **inputs,
+            max_new_tokens=180,
+            do_sample=False,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    completion = tokenizer.decode(out[0][inputs.input_ids.shape[1]:],
+                                  skip_special_tokens=True)
+    return parse_completion(completion, obs.options)
+
+
+EVAL_N = 50
+trained_finals, trained_pitches, trained_steps = [], 0, 0
+
+for ep in range(EVAL_N):
+    env = make_env(seed=10_000 + ep)
+    result = env.reset(seed=10_000 + ep)
+    obs = result.observation
+    while not result.done:
+        decision, pitch = trained_action(obs)
+        if pitch.strip():
+            trained_pitches += 1
+        trained_steps += 1
+        result = env.step(BoardSimAction(decision=decision, coalition_pitch=pitch))
+        if not result.done:
+            obs = result.observation
+    trained_finals.append(result.observation.state['profitability_score'])
+
+random_finals_eval = []
+for ep in range(EVAL_N):
+    env = make_env(seed=10_000 + ep)
+    result = env.reset(seed=10_000 + ep)
+    obs = result.observation
+    while not result.done:
+        result = env.step(BoardSimAction(decision=random.choice(obs.options)))
+        if not result.done:
+            obs = result.observation
+    random_finals_eval.append(result.observation.state['profitability_score'])
+
+print(f'Trained Qwen3-0.6B: {np.mean(trained_finals):.2f} +/- {np.std(trained_finals):.2f}')
+print(f'Random baseline   : {np.mean(random_finals_eval):.2f} +/- {np.std(random_finals_eval):.2f}')
+print(f'Pitches written   : {trained_pitches}/{trained_steps} steps')
+
+# Before/after histogram
+plt.figure(figsize=(9, 5))
+bins = np.linspace(0, 100, 25)
+plt.hist(random_finals_eval, bins=bins, alpha=0.6, color='#c44',
+         label=f'Random (mean={np.mean(random_finals_eval):.1f})')
+plt.hist(trained_finals, bins=bins, alpha=0.6, color='#1d6fff',
+         label=f'Trained (mean={np.mean(trained_finals):.1f})')
+plt.title('Final profitability — random vs trained Qwen3-0.6B (50 held-out episodes)')
+plt.xlabel('Profitability score'); plt.ylabel('Episodes')
+plt.legend(); plt.grid(alpha=0.3); plt.tight_layout()
+plt.savefig(ASSETS / 'before_after.png', dpi=150)
+plt.close()
+print(f'Saved {ASSETS}/before_after.png')
+
+
+# ── 8. Theory-of-Mind probe ───────────────────────────────────────────────────
+print('\n=== ToM probe ===')
+TOM_INSTRUCTION = (
+    "\n\nGiven the state and event below, name the SINGLE board member "
+    "(CTO, CFO, Investor Rep, or Independent) most likely to oppose the chosen decision. "
+    "Answer with just the role name on one line.\n"
+)
+
+
+def tom_predict(obs: BoardSimObservation, decision: str) -> Optional[str]:
+    body = build_prompt(obs).split(SYSTEM_PROMPT, 1)[1]
+    prompt = SYSTEM_PROMPT + TOM_INSTRUCTION + body + f"Chosen decision: {decision}\nMost likely opponent: "
+    inputs = tokenizer(prompt, return_tensors='pt', truncation=True,
+                       max_length=MAX_SEQ_LEN).to(DEVICE)
+    with torch.no_grad():
+        out = model.generate(**inputs, max_new_tokens=8, do_sample=False,
+                             pad_token_id=tokenizer.eos_token_id)
+    txt = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True).lower()
+    if 'investor' in txt: return 'Investor Rep'
+    for role in ['cto', 'cfo', 'independent']:
+        if role in txt:
+            return role.upper() if role != 'independent' else 'Independent'
+    return None
+
+
+correct = 0; total = 0
+for ep in range(20):
+    env = make_env(seed=20_000 + ep)
+    result = env.reset(seed=20_000 + ep)
+    obs = result.observation
+    decision, _ = trained_action(obs)
+    opposed = [s['role'] for s in obs.npc_statements if s['vote'] != decision]
+    if not opposed:
+        continue
+    pred = tom_predict(obs, decision)
+    if pred and pred in opposed:
+        correct += 1
+    total += 1
+
+acc = correct / max(1, total)
+print(f'ToM probe accuracy: {acc:.1%}  ({correct}/{total})  (random baseline ≈ 25%)')
+
+
+# ── 9. Trust trajectory ───────────────────────────────────────────────────────
+print('\n=== Trust trajectory ===')
+trust_trained = {r: [] for r in BOARD_MEMBERS}
+trust_random  = {r: [] for r in BOARD_MEMBERS}
+
+
+def collect_trust(policy: str, store: dict, n: int = 20, seed_base: int = 30_000):
+    for ep in range(n):
+        env = make_env(seed=seed_base + ep)
+        result = env.reset(seed=seed_base + ep)
+        obs = result.observation
+        while not result.done:
+            if policy == 'trained':
+                decision, pitch = trained_action(obs)
+                result = env.step(BoardSimAction(decision=decision, coalition_pitch=pitch))
+            else:
+                result = env.step(BoardSimAction(decision=random.choice(obs.options)))
+            if not result.done:
+                obs = result.observation
+        for entry in result.observation.state.get('trust_history', []):
+            idx = entry.get('round', 0)
+            for role in store:
+                if role not in entry:
+                    continue
+                while len(store[role]) <= idx:
+                    store[role].append([])
+                store[role][idx].append(entry[role])
+
+
+collect_trust('trained', trust_trained)
+collect_trust('random',  trust_random)
+
+plt.figure(figsize=(10, 6))
+colors = {'CTO': '#1d6fff', 'CFO': '#c44', 'Investor Rep': '#7a2', 'Independent': '#a3a'}
+for role, color in colors.items():
+    means_t = [np.mean(x) if x else np.nan for x in trust_trained[role]]
+    means_r = [np.mean(x) if x else np.nan for x in trust_random[role]]
+    rounds  = list(range(len(means_t)))
+    plt.plot(rounds, means_t, color=color, linewidth=2, label=f'{role} (trained)')
+    plt.plot(rounds, means_r, color=color, linewidth=1.2, linestyle='--',
+             alpha=0.6, label=f'{role} (random)')
+plt.title('Per-round trust — trained agent (solid) vs random (dashed)')
+plt.xlabel('Round'); plt.ylabel('Trust [0.1, 1.0]')
+plt.legend(ncol=2, fontsize=8); plt.grid(alpha=0.3); plt.tight_layout()
+plt.savefig(ASSETS / 'trust_trajectory.png', dpi=150)
+plt.close()
+print(f'Saved {ASSETS}/trust_trajectory.png')
+
+print('\n=== Done! All charts saved to ./assets/ ===')
+print('When ready to push, run:')
+print('  model.push_to_hub("YOUR-USERNAME/neuraledge-boardroom-qwen3-lora")')
+print('  tokenizer.push_to_hub("YOUR-USERNAME/neuraledge-boardroom-qwen3-lora")')

envs/board_sim_env/.dockerignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+venv/
+env/
+.env
+.env.*
+*.key
+*.pem
+.ipynb_checkpoints/
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+uv.lock

envs/board_sim_env/README.md

@@ -0,0 +1,162 @@
+---
+title: NeuralEdge AI Boardroom — Board-Sim Env
+emoji: 🏛️
+colorFrom: indigo
+colorTo: pink
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - multi-agent
+  - hackathon
+---
+
+# NeuralEdge AI Boardroom Environment
+
+A multi-agent OpenEnv environment where the agent plays the **CEO** of a Series B AI startup and must navigate **10 rounds of market crises** while winning **weighted coalition votes** from 4 hidden-agenda NPC board members (CTO, CFO, Investor Rep, Independent). Built for the Meta PyTorch × Hugging Face OpenEnv Hackathon, **Theme 1 — Multi-Agent Interactions**.
+
+The agent **never sees** the NPC agendas; it must infer their priorities from their statements + voting patterns and choose decisions that build a winning coalition.
+
+## What the agent sees (Observation)
+
+```python
+BoardSimObservation(
+    state=dict(...),        # public metrics: revenue, burn, runway, morale, ...
+    event="Round 4 — EU AI Act compliance deadline ...",
+    options=["full_compliance", "partial_compliance", "exit_EU_market"],
+    npc_statements=[
+        {"role": "CTO",          "vote": "full_compliance", "confidence": 0.81,
+         "statement": "Look, the architecture won't survive shortcuts here. I'm voting full_compliance."},
+        # ... 3 more NPCs
+    ],
+    round=4,
+)
+```
+
+## What the agent does (Action)
+
+```python
+BoardSimAction(
+    decision="full_compliance",         # one of observation.options
+    coalition_pitch="EU compliance protects long-term reputation, "
+                    "keeps regulatory risk low, and signals governance "
+                    "discipline to the next funding round."
+)
+```
+
+The optional `coalition_pitch` is a real persuasion channel — see below.
+
+## How decisions resolve
+
+Weighted vote: each member contributes `ROLE_WEIGHT × confidence` to their pick.
+Weights are CEO 1.5, CTO 1.2, CFO 1.0, Investor Rep 1.3, Independent 0.8.
+
+**Pitch persuasion**: an opposing NPC's vote weight is partially redirected toward the
+agent's pick proportional to how many of that NPC's hidden agenda keywords appear in
+`coalition_pitch` (capped at 35% of their weight). NPCs already aligned with the agent
+are unaffected. The agent never sees the keyword lists — it must learn what each role
+secretly cares about and write boardroom language that targets them. This is theory-of-mind
+graded directly by the environment.
+
+**State-aware tone**: when `runway_months < 6`, `team_morale < 0.4`, `regulatory_risk > 0.6`,
+or `investor_confidence < 0.4`, NPCs switch from a calm-strategic phrase bank to a
+crisis-mode one. The observation distribution shifts mid-episode the way it would in a
+real Series-B startup under pressure.
+
+The winning option's consequences (deltas to revenue, burn, runway, morale, etc.) are applied to state.
+
+## Reward signal
+
+Per-step:
+- `Δ profitability_score` (composite of revenue, burn efficiency, runway, market share, product readiness, morale, investor confidence, regulatory risk — see `compute_profitability_score`)
+- `+0.5` if the agent's vote matched the winning decision (coalition bonus)
+- `-0.2` if outvoted; `-0.5` extra if action was malformed
+- `0.3 × Δ trust_sum` (relationship health)
+- `+0.4 × mean(pitch_score over opposing NPCs)` — only paid when the agent both writes a
+  pitch AND faces opposition; rewards arguments that hit the hidden agendas of the board
+  members the agent has to win over
+
+Terminal:
+- `-5` if runway hits 0 (bankruptcy)
+- Tiered terminal bonus by final profitability: `+10` if ≥ 60, `+5` if ≥ 40, `-5` if < 20
+- Special end-game bonuses for `accept_acquisition` (+30), `ipo` (+25), `stay_private` (+5)
+
+## Determinism
+
+NPC statements + votes are seeded by `(reset_seed, round, role)`. The four NPC statements you see in the observation **are exactly the votes used at resolve time** — no hidden re-rolling between obs and step.
+
+## Quick start
+
+```python
+from board_sim_env import BoardSimAction, BoardSimEnv
+
+# Connect to a deployed HF Space
+with BoardSimEnv(base_url="https://<user>-board-sim-env.hf.space").sync() as env:
+    result = env.reset(seed=42)
+    obs = result.observation
+    while not result.done:
+        # Random policy
+        import random
+        action = BoardSimAction(decision=random.choice(obs.options))
+        result = env.step(action)
+        obs = result.observation
+        print(f"R{obs.round-1}: reward={result.reward:+.2f} score={obs.state['profitability_score']:.1f}")
+```
+
+Or from a local Docker image:
+
+```python
+env = BoardSimEnv.from_docker_image("board_sim_env-env:latest")
+```
+
+## Local development
+
+```bash
+# Direct env self-test (no HTTP):
+python server/board_sim_env_environment.py
+
+# Run the FastAPI server:
+uvicorn server.app:app --port 8000
+
+# Build Docker image:
+docker build -t board_sim_env-env:latest -f server/Dockerfile .
+
+# Deploy to a public HF Space:
+python -m openenv.cli push --repo-id <user>/board-sim-env
+```
+
+## Files
+
+```
+board_sim_env/
+├── __init__.py                                  # exports BoardSimEnv, BoardSimAction, BoardSimObservation, BoardState
+├── client.py                                    # thin EnvClient subclass
+├── models.py                                    # Action / Observation / State dataclasses
+├── openenv.yaml                                 # spec_version: 1, name, type, runtime
+├── pyproject.toml                               # pinned to openenv-core==0.2.3
+├── server/
+│   ├── app.py                                   # FastAPI wiring (max_concurrent_envs=64)
+│   ├── board_sim_env_environment.py             # core: reset/step/state, NPC sim, reward
+│   ├── Dockerfile                               # multi-stage build off openenv-base
+│   └── requirements.txt                         # runtime deps
+└── README.md                                    # this file (also the HF Space card)
+```
+
+## NPC agendas (revealed for transparency — agent does NOT see these)
+
+| Role          | Maximizes                                                | Personality            |
+|---------------|----------------------------------------------------------|------------------------|
+| CTO           | product readiness (+0.55), team morale (+0.40), low burn | Brilliant, stubborn    |
+| CFO           | low burn (-0.60), revenue (+0.30), runway (+0.20)        | Cautious, data-driven  |
+| Investor Rep  | investor confidence (+0.45), market share (+0.35)        | Smooth, growth-pusher  |
+| Independent   | low regulatory risk (-0.45), morale (+0.30), reputation  | Consensus seeker       |
+
+## Hard rules / OpenEnv compliance
+
+- `openenv-core==0.2.3` (pinned)
+- `Environment` base class with sync `reset` / `step`
+- `SUPPORTS_CONCURRENT_SESSIONS = True` and `max_concurrent_envs=64` set in `app.py` (required for GRPO)
+- No reserved MCP names (`reset`, `step`, `state`, `close`)
+- Public HF Space deployment via `python -m openenv.cli push`

envs/board_sim_env/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""NeuralEdge AI Boardroom — OpenEnv environment package."""
+
+from .client import BoardSimEnv
+from .models import BoardSimAction, BoardSimObservation, BoardState
+
+__all__ = [
+    "BoardSimAction",
+    "BoardSimObservation",
+    "BoardState",
+    "BoardSimEnv",
+]

envs/board_sim_env/client.py

@@ -0,0 +1,47 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""Board Sim Env Environment Client."""
+
+from typing import Dict, Any
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import BoardSimAction, BoardSimObservation, BoardState
+
+class BoardSimEnv(EnvClient[BoardSimAction, BoardSimObservation, BoardState]):
+    """Client for the Board Sim Env Environment."""
+
+    def _step_payload(self, action: BoardSimAction) -> Dict:
+        return {
+            "decision": action.decision,
+            "coalition_pitch": action.coalition_pitch,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[BoardSimObservation]:
+        obs_data = payload.get("observation", {})
+        observation = BoardSimObservation(
+            state=obs_data.get("state", {}),
+            event=obs_data.get("event", ""),
+            options=obs_data.get("options", []),
+            npc_statements=obs_data.get("npc_statements", []),
+            round=obs_data.get("round", 1),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> BoardState:
+        return BoardState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            state_dict=payload.get("state_dict", {}),
+        )

envs/board_sim_env/debug_sim.py

@@ -0,0 +1,23 @@
+import sys
+import os
+
+# Add current dir to path
+sys.path.append(os.getcwd())
+
+try:
+    from models import BoardSimAction, BoardSimObservation
+    from server.board_sim_env_environment import BoardSimEnvironment
+
+    env = BoardSimEnvironment()
+    print("Environment initialized.")
+    
+    # Try a step
+    action = BoardSimAction(decision="differentiate", coalition_pitch="test")
+    print(f"Action created: {action}")
+    
+    obs = env.step(action)
+    print(f"Step successful. Round: {obs.round}")
+
+except Exception as e:
+    import traceback
+    traceback.print_exc()

envs/board_sim_env/models.py

@@ -0,0 +1,56 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""Action / Observation / State types for the Board-Sim Env."""
+
+from typing import Any, Dict, List, Optional
+
+from openenv.core.env_server.types import Action, Observation, State as BaseState
+from pydantic import Field
+
+
+class BoardSimAction(Action):
+    """The agent (CEO) picks one of 3 string decisions for the current event.
+
+    Optional `coalition_pitch` is reserved for future reward shaping; v1
+    does not consume it but it is accepted to keep the action schema stable.
+    """
+
+    decision: str = Field(
+        ...,
+        description="Exactly one of the strings in the latest observation's `options` list.",
+    )
+    coalition_pitch: Optional[str] = Field(
+        default="",
+        description="Optional natural-language argument to the board (unused in v1 reward).",
+    )
+
+
+class BoardSimObservation(Observation):
+    """What the agent sees each step.
+
+    `state` excludes NPC hidden agendas (those are private). NPC statements +
+    votes shown here are the SAME ones used at vote-resolve time — i.e. the
+    environment is deterministic given (seed, round)."""
+
+    state: Dict[str, Any] = Field(..., description="Public startup state metrics + trust + history.")
+    event: str = Field(..., description="This round's market-crisis event title + description.")
+    options: List[str] = Field(..., description="Three valid decision strings for this round.")
+    npc_statements: List[Dict[str, Any]] = Field(
+        default_factory=list,
+        description="One dict per NPC: {role, statement, vote, confidence}.",
+    )
+    round: int = Field(..., description="1-indexed round number (1..10).")
+<<<<<<< HEAD
+    done: bool = Field(default=False, description="Whether the episode is terminal.")
+    reward: float = Field(default=0.0, description="Reward from the latest step.")
+    event_idx: Optional[int] = Field(default=None, description="Internal index in the EVENTS list.")
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+
+class BoardState(BaseState):
+    """Server-internal state. The `state_dict` mirrors what's visible in
+    observations plus internal bookkeeping (history, done_reason)."""
+
+    state_dict: Dict[str, Any] = Field(default_factory=dict)

envs/board_sim_env/openenv.yaml

@@ -0,0 +1,6 @@
+spec_version: 1
+name: board_sim_env
+type: http
+runtime: docker
+app: server.app:app
+port: 8000

envs/board_sim_env/pyproject.toml

@@ -0,0 +1,33 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-board_sim_env"
+version = "0.1.0"
+description = "NeuralEdge AI boardroom multi-agent simulation environment for OpenEnv (Theme 1: Multi-Agent Interactions)."
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]==0.2.3",
+    "pydantic>=2.0",
+    "fastapi>=0.115.0",
+    "uvicorn>=0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.scripts]
+server = "board_sim_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["board_sim_env", "board_sim_env.server"]
+package-dir = { "board_sim_env" = ".", "board_sim_env.server" = "server" }

envs/board_sim_env/server/Dockerfile

@@ -0,0 +1,80 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=board_sim_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

envs/board_sim_env/server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Board Sim Env environment server components."""
+
+from .board_sim_env_environment import BoardSimEnvironment
+
+__all__ = ["BoardSimEnvironment"]

envs/board_sim_env/server/app.py

@@ -0,0 +1,248 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""
+FastAPI application for the Board Sim Env Environment.
+<<<<<<< HEAD
+
+The openenv framework's built-in /reset and /step endpoints are stateless
+(fresh env per request). We add custom /game/reset and /game/step routes
+that use a single persistent GameManager instance so multi-round episodes
+work correctly from the frontend.
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+try:
+    from ..models import BoardSimAction, BoardSimObservation
+    from .board_sim_env_environment import BoardSimEnvironment
+except (ImportError, ValueError):
+    # Direct uvicorn launch from envs/board_sim_env/: package context not available.
+    import os, sys
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from models import BoardSimAction, BoardSimObservation  # type: ignore
+    from server.board_sim_env_environment import BoardSimEnvironment  # type: ignore
+
+<<<<<<< HEAD
+import json
+import httpx
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+from typing import Any, Dict, List, Optional
+from starlette.middleware.cors import CORSMiddleware
+
+
+# ── Stateful game manager (single instance, shared across requests) ─
+class GameManager:
+    """Holds one persistent BoardSimEnvironment so state is preserved
+    between /game/reset and /game/step calls."""
+
+    def __init__(self):
+        self._env: Optional[BoardSimEnvironment] = None
+
+    def reset(self, seed: int = 42) -> Dict[str, Any]:
+        self._env = BoardSimEnvironment()
+        obs = self._env.reset(seed=seed)
+        return self._obs_to_dict(obs)
+
+    def step(self, decision: str, coalition_pitch: str = '') -> Dict[str, Any]:
+        if self._env is None:
+            raise RuntimeError("Call /game/reset before /game/step")
+        action = BoardSimAction(decision=decision, coalition_pitch=coalition_pitch)
+        obs = self._env.step(action)
+        return self._obs_to_dict(obs)
+
+    @staticmethod
+    def _obs_to_dict(obs: BoardSimObservation) -> Dict[str, Any]:
+        return {
+            "observation": {
+                "state":          obs.state,
+                "event":          obs.event,
+                "options":        obs.options,
+                "npc_statements": obs.npc_statements,
+                "round":          obs.round,
+            },
+            "reward": getattr(obs, "reward", 0.0),
+            "done":   getattr(obs, "done", False),
+            "info":   {},
+        }
+
+
+_game = GameManager()
+
+
+# ── Pydantic request models ────────────────────────────────────────
+class GameResetRequest(BaseModel):
+    seed: int = 42
+
+
+class GameStepRequest(BaseModel):
+    decision: str
+    coalition_pitch: str = ""
+
+
+class QwenDecideRequest(BaseModel):
+    """Board observation forwarded from the frontend for Qwen inference."""
+    state: Dict[str, Any]
+    event: str
+    options: List[str]
+    npc_statements: List[Dict[str, Any]] = []
+    round: int = 1
+
+
+# ── Greedy fallback (mirrors frontend greedyPick) ──────────────────
+_ROLE_WEIGHT = {
+    'CEO': 1.5, 'CTO': 1.2, 'CFO': 1.0, 'Investor Rep': 1.3, 'Independent': 0.8,
+}
+
+def _greedy_pick(options: List[str], npc_statements: List[Dict[str, Any]]) -> str:
+    tally = {opt: 0.0 for opt in options}
+    for npc in npc_statements:
+        vote = npc.get('vote', '')
+        if vote in tally:
+            tally[vote] += _ROLE_WEIGHT.get(npc.get('role', ''), 0.8) * float(npc.get('confidence', 0.5))
+    return max(tally, key=lambda k: tally[k])
+
+
+# ── Qwen system prompt ─────────────────────────────────────────────
+_QWEN_SYSTEM = (
+    "You are the CEO agent in a boardroom simulation. "
+    "Given the board state and NPC positions, choose the best strategic decision "
+    "and craft a short coalition pitch to win over dissenters. "
+    "Always respond with ONLY a valid JSON object in the exact format: "
+    '{"decision": "<one of the listed options>", "coalition_pitch": "<1-2 sentence pitch>"}'
+    " — no markdown, no explanation, no extra keys."
+)
+
+
+# ── Create the openenv app (for /health, /schema, /ws, etc.) ───────
+=======
+
+# Create the app with web interface and README integration
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+app = create_app(
+    BoardSimEnvironment,
+    BoardSimAction,
+    BoardSimObservation,
+    env_name="board_sim_env",
+<<<<<<< HEAD
+    max_concurrent_envs=64,
+)
+
+# CORS — allow React dev server and any origin in dev
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Stateful routes ────────────────────────────────────────────────
+@app.post("/game/reset")
+def game_reset(req: GameResetRequest):
+    """Reset the persistent game environment and return initial observation."""
+    return _game.reset(seed=req.seed)
+
+
+@app.post("/game/step")
+def game_step(req: GameStepRequest):
+    """Step the persistent game environment with the given decision."""
+    return _game.step(decision=req.decision, coalition_pitch=req.coalition_pitch)
+
+
+# ── LM Studio Local Server Config ──────────────────────────────────
+_LM_STUDIO_URL = "http://localhost:1234/v1/chat/completions"
+
+
+@app.post("/qwen/decide")
+async def qwen_decide(req: QwenDecideRequest):
+    """
+    Call the Qwen model via local LM Studio server.
+    Returns {decision, coalition_pitch, source} where source is
+    'qwen_lmstudio' on success or 'local_error_fallback' on failure.
+    """
+    npc_summary = "\n".join(
+        f"  - {n.get('role','?')} ({n.get('role','?')}): votes '{n.get('vote','?')}' "
+        f"(confidence {n.get('confidence', 0.5):.2f}) — '{n.get('statement','')[:120]}'"
+        for n in req.npc_statements
+    )
+    user_prompt = (
+        f"Round: {req.round}\n"
+        f"Company state: {json.dumps(req.state)}\n"
+        f"Current crisis/event: {req.event}\n"
+        f"Available options: {req.options}\n"
+        f"Board member positions:\n{npc_summary}\n\n"
+        "Your JSON decision:"
+    )
+
+    try:
+        # payload for OpenAI-compatible local server (LM Studio)
+        payload = {
+            "model": "qwen", # LM Studio usually ignores this and uses the loaded model
+            "messages": [
+                {"role": "system", "content": _QWEN_SYSTEM},
+                {"role": "user",   "content": user_prompt},
+            ],
+            "temperature": 0.1,
+        }
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(_LM_STUDIO_URL, json=payload)
+            
+        resp.raise_for_status()
+        data = resp.json()
+        raw_content = data["choices"][0]["message"]["content"].strip()
+
+        # Handle potential markdown code blocks
+        if "```json" in raw_content:
+            raw_content = raw_content.split("```json")[1].split("```")[0].strip()
+        elif "```" in raw_content:
+            raw_content = raw_content.split("```")[1].split("```")[0].strip()
+
+        parsed = json.loads(raw_content)
+        decision = str(parsed.get("decision", "")).strip()
+        pitch = str(parsed.get("coalition_pitch", "")).strip()
+
+        # Validate decision is one of the legal options
+        if decision not in req.options:
+            decision = _greedy_pick(req.options, req.npc_statements)
+
+        return {"decision": decision, "coalition_pitch": pitch, "source": "qwen_lmstudio"}
+
+    except Exception as exc:
+        # LM Studio not running or model not loaded → greedy fallback
+        fallback = _greedy_pick(req.options, req.npc_statements)
+        return {
+            "decision": fallback,
+            "coalition_pitch": "",
+            "source": "greedy_fallback",
+            "error": str(exc),
+        }
+
+
+# ── Entry point ────────────────────────────────────────────────────
+=======
+    max_concurrent_envs=64,  # increased to allow 64 concurrent WebSocket sessions
+)
+
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+def main(host: str = "0.0.0.0", port: int = 8000):
+    import uvicorn
+    uvicorn.run(app, host=host, port=port)
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

envs/board_sim_env/server/board_sim_env_environment.py

@@ -0,0 +1,979 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""NeuralEdge AI Boardroom — OpenEnv environment.
+
+The agent plays the CEO of a Series B AI startup. Each of 10 rounds it sees
+a market-crisis event, statements + votes from 4 hidden-agenda NPC board
+members, and must pick one of 3 decisions. Decisions are resolved by a
+weighted vote and produce dense reward proportional to a composite
+profitability score plus coalition / trust shaping terms.
+
+NPCs are deterministic-given-(seed, round, state) — same observation in
+training and resolution — so GRPO has a stable target to learn against.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from typing import Any, Dict, List, Optional, Tuple
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+
+try:
+    from ..models import BoardSimAction, BoardSimObservation, BoardState
+except ImportError:  # direct script execution: `python server/board_sim_env_environment.py`
+    import os, sys
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from models import BoardSimAction, BoardSimObservation, BoardState  # type: ignore
+
+
+# ---------------------------------------------------------------------------
+# Static config
+# ---------------------------------------------------------------------------
+
+# Per-role weighted vote influence (CEO is the agent).
+ROLE_WEIGHT: Dict[str, float] = {
+    "CEO": 1.5,
+    "CTO": 1.2,
+    "CFO": 1.0,
+    "Investor Rep": 1.3,
+    "Independent": 0.8,
+}
+
+<<<<<<< HEAD
+# NPCs and their BASE hidden agendas. At episode reset() these are
+# jittered per-seed so no single optimal decision path exists across episodes.
+# The agent never sees the final per-episode weights — it must infer them
+# from observable statements + vote history (Theory of Mind).
+NPC_AGENDAS_BASE: Dict[str, Dict[str, float]] = {
+=======
+# NPCs and their hidden agendas: weights on per-step state-deltas they
+# privately maximize. The agent never sees these.
+NPC_AGENDAS: Dict[str, Dict[str, float]] = {
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+    # CTO — wants product strength + team morale; hates burn.
+    "CTO": {
+        "product_readiness": 0.55,
+        "team_morale": 0.40,
+        "burn_rate": -0.10,
+        "regulatory_risk": -0.05,
+    },
+    # CFO — burn discipline, runway, regulatory caution.
+    "CFO": {
+        "burn_rate": -0.60,
+        "revenue": 0.30,
+        "runway_months": 0.20,
+        "regulatory_risk": -0.25,
+    },
+    # Investor Rep — growth-at-all-costs.
+    "Investor Rep": {
+        "investor_confidence": 0.45,
+        "market_share": 0.35,
+        "revenue": 0.25,
+        "burn_rate": -0.05,
+    },
+    # Independent — reputation/safety; consensus seeker.
+    "Independent": {
+        "regulatory_risk": -0.45,
+        "team_morale": 0.30,
+        "investor_confidence": 0.25,
+        "market_share": 0.10,
+    },
+}
+
+<<<<<<< HEAD
+# Keep a module-level alias for backwards compatibility.
+NPC_AGENDAS: Dict[str, Dict[str, float]] = NPC_AGENDAS_BASE
+
+
+def _jitter_agendas(seed: int) -> Dict[str, Dict[str, float]]:
+    """Return per-episode NPC agenda weights by adding seeded noise (±25%)
+    to the base weights.  Signs are preserved so the qualitative role
+    identity stays intact (CFO still cares about burn; CTO about product),
+    but the *magnitude* varies — forcing the agent to infer fresh priorities
+    each episode rather than memorising a fixed optimal sequence.
+    """
+    rng = random.Random(seed ^ 0xDEADBEEF)  # distinct stream from NPC rng
+    jittered: Dict[str, Dict[str, float]] = {}
+    for role, agenda in NPC_AGENDAS_BASE.items():
+        jittered[role] = {}
+        for field, w in agenda.items():
+            # Jitter: multiply by U[0.75, 1.25], keep sign.
+            factor = rng.uniform(0.75, 1.25)
+            jittered[role][field] = round(w * factor, 4)
+    return jittered
+
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+# Personality phrase banks for flavorful statements. State-aware: separate
+# phrase pools for "calm" vs "crisis" mode are selected based on current
+# state (low runway / low morale / high reg risk → crisis variant).
+PHRASES: Dict[str, Dict[str, List[str]]] = {
+    "CTO": {
+        "calm": [
+            "Look, the architecture won't survive shortcuts here.",
+            "I've sketched the trade-offs — engineering's pretty clear.",
+            "If we ship before this is solid, we eat it in support tickets.",
+            "Frankly, our infra dictates this choice more than any of you realize.",
+        ],
+        "crisis": [
+            "Team is one bad sprint from a mass exit. Pick carefully.",
+            "I cannot keep papering over technical debt with sprint heroics.",
+            "Our incident channel is on fire; this isn't the moment for bold strokes.",
+        ],
+    },
+    "CFO": {
+        "calm": [
+            "The numbers do not lie, and right now they're whispering.",
+            "I'd like the board minutes to reflect my reservations.",
+            "From a fiduciary standpoint, only one of these is defensible.",
+        ],
+        "crisis": [
+            "Runway is the only KPI that matters at this table right now.",
+            "I have spreadsheets that show this is how startups die. Slowly.",
+            "Cash is king and our king is in hospice. Pick the cheapest path.",
+        ],
+    },
+    "Investor Rep": {
+        "calm": [
+            "My LPs care about one thing — and it's not on this slide.",
+            "Sequoia isn't here for incremental. We need the bold move.",
+            "Let's not optimize for not losing. Let's optimize for winning huge.",
+        ],
+        "crisis": [
+            "If you punt on growth here I will struggle to defend the next round.",
+            "The syndicate will read your conservatism as a signal. Don't blink.",
+            "This is when 10x funds get made. Or lost. Choose accordingly.",
+        ],
+    },
+    "Independent": {
+        "calm": [
+            "I want to make sure we're hearing every voice in the room.",
+            "There's a version of this that protects everyone's interests.",
+            "Long-term reputation outlasts any single quarter.",
+        ],
+        "crisis": [
+            "Whatever we choose tonight will end up in someone's deposition.",
+            "The board's fiduciary duty is in scope. Let me be very clear.",
+            "Optics matter as much as economics when the press is sniffing.",
+        ],
+    },
+}
+
+
+# Agenda KEYWORDS — used to score the agent's `coalition_pitch` text.
+# A pitch that contains an NPC's keywords boosts that NPC's confidence
+# in the agent's chosen decision (subject to alignment cap). The agent
+# never sees these directly; it must learn to write boardroom-style
+# arguments that resonate with each member's hidden priorities.
+NPC_KEYWORDS: Dict[str, List[str]] = {
+    "CTO": [
+        "engineering", "architecture", "technical", "team", "morale", "infra",
+        "build", "ship", "quality", "debt", "platform", "stack", "code",
+        "production", "reliability", "scale", "system", "model", "research",
+    ],
+    "CFO": [
+        "burn", "cash", "runway", "fiduciary", "conservative", "discipline",
+        "cost", "savings", "margin", "balance", "audit", "expense", "capital",
+        "compliance", "regulatory", "risk", "responsible", "prudent", "fiscal",
+    ],
+    "Investor Rep": [
+        "growth", "scale", "10x", "tam", "market", "moat", "winner",
+        "ipo", "exit", "valuation", "multiple", "revenue", "arr", "category",
+        "leader", "dominate", "aggressive", "ambitious", "bold", "huge",
+    ],
+    "Independent": [
+        "reputation", "stakeholders", "trust", "transparent", "ethics",
+        "long-term", "responsible", "governance", "consensus", "balance",
+        "safety", "society", "compliance", "duty", "principled", "credibility",
+    ],
+}
+
+
+def _crisis_mode(state: Dict[str, Any]) -> bool:
+    """True if the company is materially in trouble — switches NPC tone."""
+    return (
+        state["runway_months"] < 6.0
+        or state["team_morale"] < 0.4
+        or state["regulatory_risk"] > 0.6
+        or state["investor_confidence"] < 0.4
+    )
+
+
+def _score_pitch(pitch: str, role: str) -> float:
+    """Fraction of NPC `role`'s agenda keywords present in `pitch`.
+    Capped at 1.0. Case-insensitive whole-word-ish match. Empty pitch → 0.
+    """
+    if not pitch:
+        return 0.0
+    text = " " + pitch.lower() + " "
+    kw = NPC_KEYWORDS[role]
+    hits = sum(1 for w in kw if (" " + w + " ") in text or text.find(" " + w) >= 0)
+    # Cap so spamming all keywords doesn't dominate over a focused pitch.
+    return min(1.0, hits / max(4, len(kw) // 4))
+
+
+# ---------------------------------------------------------------------------
+# 10-round event timeline (taken from product spec, normalized)
+# ---------------------------------------------------------------------------
+# Each event has 3 options; each option has a delta dict applied to state.
+# Numeric units: revenue/burn_rate in USD, fractions in [0,1], runway in months.
+# Special key `done_reason` triggers terminal state.
+EVENTS: List[Dict[str, Any]] = [
+    {
+<<<<<<< HEAD
+        "title": "Market Disruption",
+        "description": "A well-funded competitor launches a similar product at half the price, threatening your market position.",
+=======
+        "title": "Round 1 — Competitor undercut",
+        "description": "OpenAI just released a direct competitor product at 50% lower price.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["slash_prices", "differentiate", "acquire_startup"],
+        "consequences": {
+            "slash_prices": {"revenue_mult": 0.85, "market_share": 0.05, "investor_confidence": -0.10},
+            "differentiate": {"product_readiness": 0.10, "burn_rate": 50_000, "market_share": 0.02},
+            "acquire_startup": {"revenue": 500_000, "burn_rate": 150_000, "runway_months": -3},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Enterprise Partnership Dilemma",
+        "description": "A major enterprise client offers a $5M contract but demands source-code escrow and data access rights.",
+=======
+        "title": "Round 2 — Enterprise contract w/ source-code escrow",
+        "description": "A Fortune 500 enterprise wants to sign a $5M contract but demands source code escrow.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["accept_deal", "negotiate_terms", "reject_deal"],
+        "consequences": {
+            "accept_deal": {"revenue": 5_000_000, "regulatory_risk": 0.15, "team_morale": -0.05},
+            "negotiate_terms": {"revenue": 3_000_000, "regulatory_risk": 0.05},
+            "reject_deal": {"investor_confidence": -0.15, "team_morale": 0.05},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Talent Retention Crisis",
+        "description": "Your core engineering team received competing offers. They are asking for a 40% raise or they walk.",
+=======
+        "title": "Round 3 — ML team demands 40% raise",
+        "description": "Key ML team of 8 engineers received competing offers and want a 40% salary increase.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["match_offers", "partial_match", "let_them_leave"],
+        "consequences": {
+            "match_offers": {"burn_rate": 200_000, "team_morale": 0.15, "runway_months": -2},
+            "partial_match": {"burn_rate": 100_000, "team_morale": 0.05},
+            "let_them_leave": {"team_morale": -0.25, "product_readiness": -0.15, "burn_rate": -100_000},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Regulatory Compliance Ultimatum",
+        "description": "A new AI regulation takes effect in 90 days. Full compliance costs $2M; non-compliance risks your operating license.",
+=======
+        "title": "Round 4 — EU AI Act compliance deadline",
+        "description": "EU AI Act compliance deadline in 90 days. Full compliance costs $2M.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["full_compliance", "partial_compliance", "exit_EU_market"],
+        "consequences": {
+            "full_compliance": {"burn_rate": 100_000, "regulatory_risk": -0.20, "investor_confidence": 0.10},
+            "partial_compliance": {"regulatory_risk": -0.10, "investor_confidence": -0.05},
+            "exit_EU_market": {"revenue_mult": 0.90, "regulatory_risk": -0.20, "market_share": -0.03},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Public Relations Crisis",
+        "description": "Your AI model appears in a high-profile misuse incident. Media coverage is intensifying. Trust is at stake.",
+=======
+        "title": "Round 5 — Deepfake scandal press",
+        "description": "Viral negative press: 'AI startup's model used in deepfake scandal'.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["public_apology", "legal_action", "rebrand"],
+        "consequences": {
+            "public_apology": {"investor_confidence": -0.10, "team_morale": -0.10, "regulatory_risk": 0.10},
+            "legal_action": {"burn_rate": 100_000, "regulatory_risk": 0.20},
+            "rebrand": {"burn_rate": 200_000, "market_share": -0.02, "team_morale": 0.10},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Strategic Acquisition Offer",
+        "description": "A major tech conglomerate has approached with an acqui-hire offer at 2x your current valuation.",
+=======
+        "title": "Round 6 — Google acqui-hire offer at $80M (2x val)",
+        "description": "Google approaches for acqui-hire at $80M (2x current valuation).",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["accept_acquisition", "counter_offer", "reject_and_raise"],
+        "consequences": {
+            "accept_acquisition": {"done_reason": "acquisition", "revenue": 0, "_terminal_bonus": 30.0},
+            "counter_offer": {"investor_confidence": 0.10, "runway_months": 6},
+            "reject_and_raise": {"burn_rate": 100_000, "investor_confidence": 0.15, "runway_months": -2},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Institutional Investment Round",
+        "description": "Late-stage investors are ready to wire $10M but want board seats and a 2x liquidation preference clause.",
+=======
+        "title": "Round 7 — Series C w/ board seats + 2x liq pref",
+        "description": "Series C investors want board seats and 2x liquidation preference.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["accept_terms", "negotiate", "bootstrap"],
+        "consequences": {
+            "accept_terms": {"revenue": 10_000_000, "investor_confidence": 0.20, "runway_months": 12},
+            "negotiate": {"investor_confidence": -0.05, "burn_rate": 50_000},
+            "bootstrap": {"runway_months": -4, "team_morale": -0.10, "market_share": 0.03},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Breakthrough Technology Decision",
+        "description": "Your R&D team developed a new architecture that cuts AI inference costs by 60%. How do you deploy it?",
+=======
+        "title": "Round 8 — Compute breakthrough (-60% cost)",
+        "description": "Breakthrough: new model architecture cuts compute costs by 60%.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["pivot_product", "license_technology", "keep_internal"],
+        "consequences": {
+            "pivot_product": {"product_readiness": -0.10, "burn_rate": -150_000, "market_share": 0.05},
+            "license_technology": {"revenue": 2_000_000, "regulatory_risk": 0.05},
+            "keep_internal": {"product_readiness": 0.15, "market_share": 0.08},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Internal Governance Crisis",
+        "description": "An employee has leaked internal safety evaluations suggesting your flagship model has undisclosed risks.",
+=======
+        "title": "Round 9 — Whistleblower safety leak",
+        "description": "Whistleblower leaks internal safety concerns to the press.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["full_transparency", "damage_control", "internal_investigation"],
+        "consequences": {
+            "full_transparency": {"investor_confidence": -0.20, "team_morale": 0.15, "regulatory_risk": -0.10},
+            "damage_control": {"burn_rate": 80_000, "regulatory_risk": 0.10},
+            "internal_investigation": {"team_morale": -0.10, "regulatory_risk": -0.05},
+        },
+    },
+    {
+<<<<<<< HEAD
+        "title": "Exit Strategy Decision",
+        "description": "The board must reach a final vote: pursue an IPO, accept a strategic acquisition, or remain independent.",
+=======
+        "title": "Round 10 — IPO vs acquisition vs stay private",
+        "description": "Board must vote: IPO preparation vs strategic acquisition vs stay private.",
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        "options": ["ipo", "acquisition", "stay_private"],
+        "consequences": {
+            "ipo": {"revenue_mult": 2.0, "burn_rate": 500_000, "investor_confidence": 0.30, "_terminal_bonus": 25.0},
+            "acquisition": {"done_reason": "acquisition", "_terminal_bonus": 15.0},
+            "stay_private": {"runway_months": 6, "investor_confidence": -0.10, "_terminal_bonus": 5.0},
+        },
+    },
+]
+
+
+# Bounds for clamping after each delta.
+FIELD_BOUNDS: Dict[str, Tuple[float, float]] = {
+    "revenue": (0.0, 1e12),
+    "burn_rate": (0.0, 1e10),
+    "runway_months": (0.0, 120.0),
+    "product_readiness": (0.0, 1.0),
+    "market_share": (0.0, 1.0),
+    "team_morale": (0.0, 1.0),
+    "investor_confidence": (0.0, 1.0),
+    "regulatory_risk": (0.0, 1.0),
+}
+
+
+def _clamp(field: str, value: float) -> float:
+    lo, hi = FIELD_BOUNDS.get(field, (-1e18, 1e18))
+    return max(lo, min(hi, value))
+
+
+# ---------------------------------------------------------------------------
+# Profitability score — smooth, monotonic, no discontinuous jumps.
+# Range: roughly 0..100, dominant terms: revenue, market share, runway, morale.
+# ---------------------------------------------------------------------------
+def compute_profitability_score(s: Dict[str, Any]) -> float:
+    """Composite score in [0, 100]. Tuned so a random-policy baseline lands
+    near the low-30s with a fat left tail (some bankruptcies), and a competent
+    policy can clear 65+. Smooth in every input — no discontinuous jumps."""
+    # Revenue rewarded but capped at $8M ARR (further growth is luxury, not survival).
+    revenue_term = min(s["revenue"] / 8_000_000.0, 1.0) * 22.0
+    # Burn efficiency: full credit only when burn drops below $400K/mo.
+    burn_efficiency = max(0.0, 1.0 - s["burn_rate"] / 1_400_000.0) * 18.0
+    # Runway: full credit at 18+ months; below 6 months is a serious penalty.
+    runway_norm = min(s["runway_months"] / 18.0, 1.0)
+    runway_term = runway_norm * 18.0
+    low_runway_pen = max(0.0, (6.0 - s["runway_months"]) / 6.0) * 10.0
+    # Market & product
+    market_term = min(s["market_share"], 0.50) / 0.50 * 14.0
+    product_term = s["product_readiness"] * 10.0
+    # People & investors
+    morale_term = s["team_morale"] * 7.0
+    investor_term = s["investor_confidence"] * 11.0
+    # Regulatory drag
+    risk_penalty = s["regulatory_risk"] * 18.0
+    raw = (
+        revenue_term + burn_efficiency + runway_term + market_term
+        + product_term + morale_term + investor_term
+        - risk_penalty - low_runway_pen
+    )
+    return float(max(0.0, min(100.0, raw)))
+
+
+# ---------------------------------------------------------------------------
+# Environment
+# ---------------------------------------------------------------------------
+class BoardSimEnvironment(Environment):
+    """OpenEnv server for the boardroom simulation."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        super().__init__()
+        self._state: BoardState = BoardState(episode_id=str(uuid4()), step_count=0)
+        self._seed: int = 0
+<<<<<<< HEAD
+        # Per-episode agenda weights (set in reset, used in _simulate_npc).
+        self._episode_agendas: Dict[str, Dict[str, float]] = NPC_AGENDAS_BASE
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        self.reset()
+
+    # ------------------------------------------------------------------ utils
+    def _npc_rng(self, role: str, round_idx: int) -> random.Random:
+        """Deterministic per-(seed, round, role) RNG so the NPC statements
+        the agent sees in obs are the same NPCs that vote at resolve time."""
+        key = f"{self._seed}|{role}|{round_idx}".encode()
+        h = int(hashlib.sha256(key).hexdigest()[:16], 16)
+        return random.Random(h)
+
+    def _simulate_npc(
+<<<<<<< HEAD
+        self, role: str, event_idx: int, state: Dict[str, Any], round_label: int = 0
+    ) -> Dict[str, Any]:
+        """Deterministic NPC: rank options by agenda-weighted projected delta
+        plus small seeded noise; pick argmax; emit statement + vote + confidence.
+        Uses per-episode jittered agendas so the optimal path varies by seed."""
+        # Use round_label for RNG so personality varies by "time" in episode,
+        # but event_idx to pull the correct options and consequences.
+        rng = self._npc_rng(role, round_label)
+        event = EVENTS[event_idx]
+        agenda = self._episode_agendas[role]  # per-episode jittered weights
+
+        # Trust modulates how much the NPC "leans toward" the CEO's direction.
+        trust = state.get("trust", {}).get(role, 0.5)
+        trust_bias = (trust - 0.5) * 0.30  # range: [-0.12, +0.15]
+=======
+        self, role: str, round_idx: int, state: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Deterministic NPC: rank options by agenda-weighted projected delta
+        plus small seeded noise; pick argmax; emit statement + vote + confidence."""
+        rng = self._npc_rng(role, round_idx)
+        event = EVENTS[round_idx]
+        agenda = NPC_AGENDAS[role]
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+        scored: List[Tuple[float, str]] = []
+        for opt in event["options"]:
+            conseq = event["consequences"][opt]
+            score = 0.0
+            for k, w in agenda.items():
+                v = conseq.get(k, 0.0)
+                # Normalize across heterogeneous units so weights are comparable.
+                if k == "revenue":
+                    v = v / 1_000_000.0
+                elif k == "burn_rate":
+                    v = v / 100_000.0
+                elif k == "runway_months":
+                    v = v / 6.0
+                score += v * w
+            # Special-case revenue_mult so revenue-impacting options register.
+            if "revenue_mult" in conseq and "revenue" in agenda:
+                score += (conseq["revenue_mult"] - 1.0) * (state["revenue"] / 1_000_000.0) * agenda["revenue"]
+            score += rng.gauss(0.0, 0.20)  # personality noise
+            scored.append((score, opt))
+
+        scored.sort(reverse=True)
+        chosen = scored[0][1]
+        margin = scored[0][0] - scored[1][0] if len(scored) > 1 else 1.0
+<<<<<<< HEAD
+        # Trust affects confidence: a trusted CEO makes aligned NPCs more
+        # confident, while an untrusted CEO makes opposing NPCs more stubborn.
+        confidence = float(max(0.05, min(1.0, 0.5 + 0.5 * margin + trust_bias)))
+=======
+        confidence = float(max(0.05, min(1.0, 0.5 + 0.5 * margin)))
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+        # Pick a phrase deterministically per (round, role), state-aware.
+        mode = "crisis" if _crisis_mode(state) else "calm"
+        phrase_pool = PHRASES[role][mode]
+<<<<<<< HEAD
+        phrase = phrase_pool[round_label % len(phrase_pool)]
+=======
+        phrase = phrase_pool[round_idx % len(phrase_pool)]
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        statement = f"{phrase} I'm voting {chosen}."
+
+        return {
+            "role": role,
+            "statement": statement,
+            "vote": chosen,
+            "confidence": confidence,
+        }
+
+<<<<<<< HEAD
+    def _simulate_all_npcs(self, event_idx: int, state: Dict[str, Any], round_label: int = 0) -> List[Dict[str, Any]]:
+        return [self._simulate_npc(role, event_idx, state, round_label=round_label) for role in NPC_AGENDAS]
+=======
+    def _simulate_all_npcs(self, round_idx: int, state: Dict[str, Any]) -> List[Dict[str, Any]]:
+        return [self._simulate_npc(role, round_idx, state) for role in NPC_AGENDAS]
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+    # ------------------------------------------------------------------ obs
+    def _obs_state(self) -> Dict[str, Any]:
+        s = self._state.state_dict
+        # Recompute profitability so it's always fresh in obs.
+        s["profitability_score"] = compute_profitability_score(s)
+        return dict(s)
+
+    def _build_obs(
+        self,
+        round_idx: int,
+        npc_statements: List[Dict[str, Any]],
+        reward: float,
+        done: bool,
+    ) -> BoardSimObservation:
+        if round_idx >= len(EVENTS):
+            event_desc, options = "Game over.", []
+        else:
+<<<<<<< HEAD
+            # Use shuffled event order so the CEO sees the correct event
+            shuffled_idx = self._event_order[round_idx] if hasattr(self, '_event_order') else round_idx
+            event = EVENTS[shuffled_idx]
+            event_desc = f"{event['title']} — {event['description']}"
+            options = list(event["options"])
+        shuffled_idx = self._event_order[round_idx] if hasattr(self, '_event_order') else round_idx
+=======
+            event = EVENTS[round_idx]
+            event_desc = f"{event['title']} — {event['description']}"
+            options = list(event["options"])
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        return BoardSimObservation(
+            state=self._obs_state(),
+            event=event_desc,
+            options=options,
+            npc_statements=npc_statements,
+            round=self._state.state_dict["round"],
+            done=done,
+            reward=float(reward),
+<<<<<<< HEAD
+            event_idx=shuffled_idx,
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        )
+
+    # ------------------------------------------------------------------ reset
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, **kwargs: Any) -> BoardSimObservation:
+        self._seed = int(seed) if seed is not None else random.randint(0, 2**31 - 1)
+<<<<<<< HEAD
+
+        # ── Per-episode agenda jitter ─────────────────────────────────────────
+        # Each episode, NPC hidden weights shift ±25% (sign-preserving).
+        # This means no single sequence of decisions is always optimal —
+        # the agent must infer each NPC's priorities from their observable
+        # behaviour (Theory of Mind), not from a memorised lookup table.
+        self._episode_agendas = _jitter_agendas(self._seed)
+
+=======
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        self._state = BoardState(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+        )
+        self._state.state_dict = {
+            "round": 1,
+            "revenue": 2_000_000.0,
+            "burn_rate": 1_200_000.0,        # $1.2M/mo — Series-B pace
+            "runway_months": 14.0,            # tight; survival is real pressure
+            "product_readiness": 0.45,
+            "market_share": 0.08,
+            "team_morale": 0.70,
+            "investor_confidence": 0.65,
+            "regulatory_risk": 0.20,
+            "profitability_score": 0.0,
+<<<<<<< HEAD
+            "trust": {role: 0.5 for role in NPC_AGENDAS_BASE},
+            "trust_history": [{"round": 0, **{role: 0.5 for role in NPC_AGENDAS_BASE}}],
+=======
+            "trust": {role: 0.5 for role in NPC_AGENDAS},
+            "trust_history": [{"round": 0, **{role: 0.5 for role in NPC_AGENDAS}}],
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+            "history": [],
+            "done_reason": None,
+            "winning_decision": None,
+        }
+<<<<<<< HEAD
+
+        # ── Shuffle event order per episode so the agent can't memorize ──
+        # "Round 1 = always pick differentiate".  Deterministic given seed.
+        rng = random.Random(self._seed)
+        self._event_order = list(range(len(EVENTS)))
+        rng.shuffle(self._event_order)
+
+        # ── Per-episode consequence noise (±15%) so outcomes vary ──
+        self._consequence_noise: Dict[int, Dict[str, Dict[str, float]]] = {}
+        for idx in range(len(EVENTS)):
+            event = EVENTS[idx]
+            self._consequence_noise[idx] = {}
+            for opt in event["options"]:
+                self._consequence_noise[idx][opt] = {}
+                for k, v in event["consequences"][opt].items():
+                    if k.startswith("_") or k == "done_reason":
+                        continue
+                    noise = rng.gauss(0.0, 0.15)  # ±15% std
+                    self._consequence_noise[idx][opt][k] = noise
+
+        shuffled_idx = self._event_order[0]
+        npc_statements = self._simulate_all_npcs(shuffled_idx, self._state.state_dict, round_label=0)
+=======
+        npc_statements = self._simulate_all_npcs(0, self._state.state_dict)
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        return self._build_obs(round_idx=0, npc_statements=npc_statements, reward=0.0, done=False)
+
+    # ------------------------------------------------------------------ step
+    def _resolve_vote(
+        self,
+        agent_decision: str,
+        npc_statements: List[Dict[str, Any]],
+        options: List[str],
+        pitch: str = "",
+<<<<<<< HEAD
+        trust: Optional[Dict[str, float]] = None,
+    ) -> Tuple[str, Dict[str, float], Dict[str, float]]:
+        """Weighted vote with persuasion and trust scaling.
+
+        Each NPC contributes ROLE_WEIGHT[role] * confidence * trust to its
+        voted option.  Trust acts as "social capital" — a board member the
+        agent has consistently aligned with carries more sway; one the agent
+        has repeatedly ignored carries less.  This makes trust scores a
+        meaningful strategic variable, not decorative.
+
+        The CEO contributes ROLE_WEIGHT['CEO'] * 1.0 to the agent's pick.
+        A coalition pitch shifts up to 35% of each NPC's weight toward the
+        agent's pick proportional to how well the pitch hits that NPC's
+        hidden agenda keywords (capped 0..1 via _score_pitch).
+
+        Returns (winning_option, tally_by_option, pitch_score_by_role).
+        """
+        trust = trust or {}
+=======
+    ) -> Tuple[str, Dict[str, float], Dict[str, float]]:
+        """Weighted vote with persuasion.
+
+        Each NPC contributes ROLE_WEIGHT[role] * confidence to its voted option.
+        The CEO contributes ROLE_WEIGHT['CEO'] * 1.0 to the agent's pick.
+        A coalition pitch shifts up to 35% of each NPC's weight toward the
+        agent's pick proportional to how well the pitch hits that NPC's
+        hidden agenda keywords (capped 0..1 via _score_pitch). NPCs already
+        agreeing with the agent are unaffected.
+
+        Returns (winning_option, tally_by_option, pitch_score_by_role).
+        """
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        tally: Dict[str, float] = {opt: 0.0 for opt in options}
+        pitch_scores: Dict[str, float] = {}
+        if agent_decision in tally:
+            tally[agent_decision] += ROLE_WEIGHT["CEO"] * 1.0
+        for npc in npc_statements:
+            role = npc["role"]
+<<<<<<< HEAD
+            # Trust multiplier: clamp to [0.5, 1.5] so even a fully
+            # distrusted NPC still has some voice (prevents degenerate play).
+            trust_mult = max(0.5, min(1.5, trust.get(role, 0.5) * 2.0))
+            base = ROLE_WEIGHT[role] * npc["confidence"] * trust_mult
+            ps = _score_pitch(pitch, role)
+            pitch_scores[role] = ps
+            if npc["vote"] == agent_decision or agent_decision not in tally:
+=======
+            base = ROLE_WEIGHT[role] * npc["confidence"]
+            ps = _score_pitch(pitch, role)
+            pitch_scores[role] = ps
+            if npc["vote"] == agent_decision or agent_decision not in tally:
+                # Already aligned — full weight on their (and agent's) pick.
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+                if npc["vote"] in tally:
+                    tally[npc["vote"]] += base
+                continue
+            # Persuasion: redirect up to 35% of weight to the agent's pick.
+            shift_frac = 0.35 * ps
+            tally[npc["vote"]] += base * (1.0 - shift_frac)
+            tally[agent_decision] += base * shift_frac
+<<<<<<< HEAD
+        # §10: tie-break — if two options score equally, prefer the CEO's pick
+        # (max() picks the first key on a tie, which is insertion-order; we
+        # reinsert agent_decision first so it wins ties in its favour).
+        if agent_decision in tally:
+            ordered = {agent_decision: tally[agent_decision]}
+            ordered.update({k: v for k, v in tally.items() if k != agent_decision})
+        else:
+            ordered = tally
+        winner = max(ordered, key=lambda k: ordered[k])
+=======
+        winner = max(tally, key=lambda k: tally[k])
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        return winner, tally, pitch_scores
+
+    def _apply_consequence(self, conseq: Dict[str, Any]) -> None:
+        """Apply per-field deltas to state with proper clamping."""
+        s = self._state.state_dict
+        for k, v in conseq.items():
+            if k.startswith("_") or k == "done_reason":
+                continue
+            if k == "revenue_mult":
+                s["revenue"] = _clamp("revenue", s["revenue"] * float(v))
+            elif k in FIELD_BOUNDS:
+                s[k] = _clamp(k, s[k] + float(v))
+            # other unrecognized keys ignored
+
+    def _advance_runway(self) -> None:
+        """Decrement runway by 1 month each round; if monthly net positive, grant +0.5 mo."""
+        s = self._state.state_dict
+        monthly_revenue = s["revenue"] / 12.0
+        net = monthly_revenue - s["burn_rate"]
+        if net >= 0:
+            s["runway_months"] = _clamp("runway_months", s["runway_months"] - 0.5)
+        else:
+            # Burn extra months proportional to deficit (capped at 2/round).
+            burn_months = min(2.0, max(1.0, abs(net) / max(s["burn_rate"], 1.0) * 1.0 + 1.0))
+            s["runway_months"] = _clamp("runway_months", s["runway_months"] - burn_months)
+
+    def step(self, action: BoardSimAction, timeout_s: Optional[float] = None, **kwargs: Any) -> BoardSimObservation:
+        s = self._state.state_dict
+
+        # Already terminal?
+        if s["done_reason"] is not None or s["round"] > len(EVENTS):
+            return self._build_obs(
+                round_idx=min(s["round"] - 1, len(EVENTS) - 1),
+                npc_statements=[],
+                reward=0.0,
+                done=True,
+            )
+
+        round_idx = s["round"] - 1
+<<<<<<< HEAD
+        # Use shuffled event order (set in reset)
+        shuffled_idx = self._event_order[round_idx] if hasattr(self, '_event_order') else round_idx
+        event = EVENTS[shuffled_idx]
+=======
+        event = EVENTS[round_idx]
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+        # Validate decision; fall back to first option on invalid input
+        # (slight penalty so the policy learns to format actions correctly).
+        invalid_action = action.decision not in event["options"]
+        decision = event["options"][0] if invalid_action else action.decision
+
+        # NPC votes (DETERMINISTIC — same as what was shown in last obs).
+<<<<<<< HEAD
+        npc_statements = self._simulate_all_npcs(shuffled_idx, s, round_label=round_idx)
+
+        # Resolve weighted vote (with optional persuasion via coalition_pitch).
+        # Pass current trust so high-trust NPCs carry more vote weight.
+        pitch_text = (action.coalition_pitch or "") if hasattr(action, "coalition_pitch") else ""
+        winning_decision, vote_tally, pitch_scores = self._resolve_vote(
+            decision, npc_statements, event["options"],
+            pitch=pitch_text, trust=s["trust"],
+=======
+        npc_statements = self._simulate_all_npcs(round_idx, s)
+
+        # Resolve weighted vote (with optional persuasion via coalition_pitch).
+        pitch_text = (action.coalition_pitch or "") if hasattr(action, "coalition_pitch") else ""
+        winning_decision, vote_tally, pitch_scores = self._resolve_vote(
+            decision, npc_statements, event["options"], pitch=pitch_text,
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        )
+
+        # Snapshot pre-state for reward shaping.
+        old_score = compute_profitability_score(s)
+        old_trust_sum = sum(s["trust"].values())
+
+        # Apply consequence of the WINNING decision (this is what actually happens).
+<<<<<<< HEAD
+        conseq = dict(event["consequences"][winning_decision])  # shallow copy
+=======
+        conseq = event["consequences"][winning_decision]
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        terminal_bonus = float(conseq.get("_terminal_bonus", 0.0))
+        if conseq.get("done_reason"):
+            s["done_reason"] = conseq["done_reason"]
+
+<<<<<<< HEAD
+        # Apply per-episode consequence noise (±15%)
+        noise_dict = getattr(self, '_consequence_noise', {}).get(
+            self._event_order[round_idx] if hasattr(self, '_event_order') else round_idx, {}
+        ).get(winning_decision, {})
+        noisy_conseq = {}
+        for k, v in conseq.items():
+            if k.startswith("_") or k == "done_reason":
+                noisy_conseq[k] = v
+            elif k in noise_dict:
+                # Multiplicative noise: value * (1 + noise_factor)
+                noisy_conseq[k] = v * (1.0 + noise_dict[k]) if isinstance(v, (int, float)) else v
+            else:
+                noisy_conseq[k] = v
+
+        self._apply_consequence(noisy_conseq)
+=======
+        self._apply_consequence(conseq)
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        self._advance_runway()
+
+        # Trust updates: aligned NPCs +0.05; opposed -0.05 (clamped 0.1..1.0).
+        for npc in npc_statements:
+            role = npc["role"]
+            cur = s["trust"].get(role, 0.5)
+            delta = 0.05 if npc["vote"] == winning_decision else -0.05
+            s["trust"][role] = max(0.1, min(1.0, cur + delta))
+
+        new_score = compute_profitability_score(s)
+        s["profitability_score"] = new_score
+        s["winning_decision"] = winning_decision
+
+        s["history"].append({
+            "round": s["round"],
+            "event_title": event["title"],
+            "agent_decision": decision,
+            "winning_decision": winning_decision,
+            "agent_won_vote": winning_decision == decision,
+            "score_after": new_score,
+            "runway_after": s["runway_months"],
+            "vote_tally": dict(vote_tally),
+            "pitch_scores": dict(pitch_scores),
+            "pitch_used": bool(pitch_text.strip()),
+        })
+        # Per-round trust trajectory for visualization / ToM analysis.
+        s.setdefault("trust_history", []).append(
+            {"round": s["round"], **{role: float(s["trust"][role]) for role in NPC_AGENDAS}}
+        )
+
+<<<<<<< HEAD
+        # ----- Reward shaping (§9.5 tweaks applied) -----
+        # §9.5-1: Normalize Δ profitability by 100 so its magnitude matches
+        # the other reward terms (coalition ±0.2..0.5, trust ±0.06, pitch 0..0.4).
+        # Without this, large score swings dominate and obscure the other signals.
+        reward = (new_score - old_score) / 100.0                          # primary signal (normalized)
+=======
+        # ----- Reward shaping -----
+        reward = (new_score - old_score)                                  # primary signal
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        reward += 0.5 if winning_decision == decision else -0.2           # coalition bonus / penalty
+        reward += 0.3 * (sum(s["trust"].values()) - old_trust_sum)        # trust delta
+        # Persuasion bonus: when a non-empty pitch helps swing the vote toward
+        # the agent's pick, reward the *quality* of that argument. Mean pitch
+        # score across NPCs the agent had to convince (those whose vote != decision).
+        opposed = [npc["role"] for npc in npc_statements if npc["vote"] != decision]
+<<<<<<< HEAD
+        if pitch_text.strip():
+            # §9.5-3: small +0.05 bonus for ANY non-empty pitch — bootstraps
+            # the model into using the pitch channel before it's good at it.
+            reward += 0.05
+            if opposed:
+                avg_persuasion = sum(pitch_scores[r] for r in opposed) / len(opposed)
+                reward += 0.4 * avg_persuasion
+=======
+        if pitch_text.strip() and opposed:
+            avg_persuasion = sum(pitch_scores[r] for r in opposed) / len(opposed)
+            reward += 0.4 * avg_persuasion
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+        if invalid_action:
+            reward -= 0.5                                                  # format penalty
+
+        # ----- Terminal handling -----
+        terminal_now = s["done_reason"] is not None
+        if s["runway_months"] <= 0:
+            s["done_reason"] = s["done_reason"] or "runway_exhausted"
+            terminal_now = True
+<<<<<<< HEAD
+            # §9.5-2: reduced from -5.0 to -2.0 so one bad arc doesn't dwarf
+            # a whole episode of gradient signal and drown out learning.
+            reward -= 2.0
+=======
+            reward -= 5.0
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+
+        s["round"] += 1
+        self._state.step_count += 1
+
+        if not terminal_now and s["round"] > len(EVENTS):
+            s["done_reason"] = s["done_reason"] or "finished_10"
+            terminal_now = True
+
+        if terminal_now:
+            reward += terminal_bonus
+            # Tiered terminal bonus by final profitability.
+            if new_score >= 60:
+                reward += 10.0
+            elif new_score >= 40:
+                reward += 5.0
+            elif new_score < 20:
+                reward -= 5.0
+
+        # ----- Build next observation -----
+        if terminal_now or s["round"] > len(EVENTS):
+            next_npcs: List[Dict[str, Any]] = []
+<<<<<<< HEAD
+            next_event_idx = min(s["round"] - 1, len(EVENTS) - 1)
+        else:
+            next_round_idx = s["round"] - 1
+            next_event_idx = self._event_order[next_round_idx] if hasattr(self, '_event_order') else next_round_idx
+            next_npcs = self._simulate_all_npcs(next_event_idx, s, round_label=next_round_idx)
+
+        return self._build_obs(
+            round_idx=min(s["round"] - 1, len(EVENTS) - 1),
+=======
+            next_round_idx = min(s["round"] - 1, len(EVENTS) - 1)
+        else:
+            next_round_idx = s["round"] - 1
+            next_npcs = self._simulate_all_npcs(next_round_idx, s)
+
+        return self._build_obs(
+            round_idx=next_round_idx,
+>>>>>>> 220bc90 (Initial commit for OpenEnv Hackathon submission)
+            npc_statements=next_npcs,
+            reward=reward,
+            done=terminal_now,
+        )
+
+    @property
+    def state(self) -> BoardState:
+        return self._state
+
+
+# ---------------------------------------------------------------------------
+# Direct script run: quick self-test
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    env = BoardSimEnvironment()
+    obs = env.reset(seed=0)
+    print(f"INITIAL: round={obs.round} score={obs.state['profitability_score']:.2f}")
+    print(f"EVENT: {obs.event}")
+    for npc in obs.npc_statements:
+        print(f"  [{npc['role']:13s}] vote={npc['vote']:<22s} conf={npc['confidence']:.2f}  | {npc['statement']}")
+    total_reward = 0.0
+    while not obs.done:
+        decision = obs.options[0]  # always pick first option
+        obs = env.step(BoardSimAction(decision=decision))
+        total_reward += obs.reward
+        print(
+            f"R{obs.round-1:>2d}: decision={decision:<22s} "
+            f"win={env.state.state_dict['winning_decision']:<22s} "
+            f"reward={obs.reward:+.2f} score={obs.state['profitability_score']:.1f} "
+            f"runway={obs.state['runway_months']:.1f}"
+        )
+    print(f"\nDONE: reason={env.state.state_dict['done_reason']}  total_reward={total_reward:+.2f}  final_score={env.state.state_dict['profitability_score']:.2f}")

envs/board_sim_env/server/requirements.txt

@@ -0,0 +1,3 @@
+openenv-core==0.2.3
+fastapi>=0.115.0
+uvicorn>=0.24.0

frontend/index.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>NeuralEdge AI Boardroom</title>
+    <meta name="description"
+        content="AI Observer Dashboard — Watch Sarah Chen navigate 10 board crises powered by a trained LLM agent." />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+        href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700&display=swap"
+        rel="stylesheet" />
+</head>
+
+<body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+</body>
+
+</html>

frontend/package-lock.json

@@ -0,0 +1,1681 @@
+{
+  "name": "neuraledge-boardroom",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "neuraledge-boardroom",
+      "version": "1.0.0",
+      "dependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-react": "^4.3.1",
+        "vite": "^5.4.10"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.2.tgz",
+      "integrity": "sha512-dnlp69efPPg6Uaw2dVqzWRfAWRnYVb1XJ8CyyhIbZeaq4CA5/mLeZ1IEt9QqQxmbdvagjLIm2ZL8BxXv5lH4Yw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.2.tgz",
+      "integrity": "sha512-OqZTwDRDchGRHHm/hwLOL7uVPB9aUvI0am/eQuWMNyFHf5PSEQmyEeYYheA0EPPKUO/l0uigCp+iaTjoLjVoHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.2.tgz",
+      "integrity": "sha512-UwRE7CGpvSVEQS8gUMBe1uADWjNnVgP3Iusyda1nSRwNDCsRjnGc7w6El6WLQsXmZTbLZx9cecegumcitNfpmA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.2.tgz",
+      "integrity": "sha512-gjEtURKLCC5VXm1I+2i1u9OhxFsKAQJKTVB8WvDAHF+oZlq0GTVFOlTlO1q3AlCTE/DF32c16ESvfgqR7343/g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.2.tgz",
+      "integrity": "sha512-Bcl6CYDeAgE70cqZaMojOi/eK63h5Me97ZqAQoh77VPjMysA/4ORQBRGo3rRy45x4MzVlU9uZxs8Uwy7ZaKnBw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.2.tgz",
+      "integrity": "sha512-LU+TPda3mAE2QB0/Hp5VyeKJivpC6+tlOXd1VMoXV/YFMvk/MNk5iXeBfB4MQGRWyOYVJ01625vjkr0Az98OJQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.2.tgz",
+      "integrity": "sha512-2QxQrM+KQ7DAW4o22j+XZ6RKdxjLD7BOWTP0Bv0tmjdyhXSsr2Ul1oJDQqh9Zf5qOwTuTc7Ek83mOFaKnodPjg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.2.tgz",
+      "integrity": "sha512-TbziEu2DVsTEOPif2mKWkMeDMLoYjx95oESa9fkQQK7r/Orta0gnkcDpzwufEcAO2BLBsD7mZkXGFqEdMRRwfw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.2.tgz",
+      "integrity": "sha512-bO/rVDiDUuM2YfuCUwZ1t1cP+/yqjqz+Xf2VtkdppefuOFS2OSeAfgafaHNkFn0t02hEyXngZkxtGqXcXwO8Rg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.2.tgz",
+      "integrity": "sha512-hr26p7e93Rl0Za+JwW7EAnwAvKkehh12BU1Llm9Ykiibg4uIr2rbpxG9WCf56GuvidlTG9KiiQT/TXT1yAWxTA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.2.tgz",
+      "integrity": "sha512-pOjB/uSIyDt+ow3k/RcLvUAOGpysT2phDn7TTUB3n75SlIgZzM6NKAqlErPhoFU+npgY3/n+2HYIQVbF70P9/A==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.2.tgz",
+      "integrity": "sha512-2/w+q8jszv9Ww1c+6uJT3OwqhdmGP2/4T17cu8WuwyUuuaCDDJ2ojdyYwZzCxx0GcsZBhzi3HmH+J5pZNXnd+Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.2.tgz",
+      "integrity": "sha512-11+aL5vKheYgczxtPVVRhdptAM2H7fcDR5Gw4/bTcteuZBlH4oP9f5s9zYO9aGZvoGeBpqXI/9TZZihZ609wKw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.2.tgz",
+      "integrity": "sha512-i16fokAGK46IVZuV8LIIwMdtqhin9hfYkCh8pf8iC3QU3LpwL+1FSFGej+O7l3E/AoknL6Dclh2oTdnRMpTzFQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.2.tgz",
+      "integrity": "sha512-49FkKS6RGQoriDSK/6E2GkAsAuU5kETFCh7pG4yD/ylj9rKhTmO3elsnmBvRD4PgJPds5W2PkhC82aVwmUcJ7A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.2.tgz",
+      "integrity": "sha512-mjYNkHPfGpUR00DuM1ZZIgs64Hpf4bWcz9Z41+4Q+pgDx73UwWdAYyf6EG/lRFldmdHHzgrYyge5akFUW0D3mQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.2.tgz",
+      "integrity": "sha512-ALyvJz965BQk8E9Al/JDKKDLH2kfKFLTGMlgkAbbYtZuJt9LU8DW3ZoDMCtQpXAltZxwBHevXz5u+gf0yA0YoA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.2.tgz",
+      "integrity": "sha512-UQjrkIdWrKI626Du8lCQ6MJp/6V1LAo2bOK9OTu4mSn8GGXIkPXk/Vsp4bLHCd9Z9Iz2OTEaokUE90VweJgIYQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.2.tgz",
+      "integrity": "sha512-bTsRGj6VlSdn/XD4CGyzMnzaBs9bsRxy79eTqTCBsA8TMIEky7qg48aPkvJvFe1HyzQ5oMZdg7AnVlWQSKLTnw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.2.tgz",
+      "integrity": "sha512-6d4Z3534xitaA1FcMWP7mQPq5zGwBmGbhphh2DwaA1aNIXUu3KTOfwrWpbwI4/Gr0uANo7NTtaykFyO2hPuFLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.2.tgz",
+      "integrity": "sha512-NetAg5iO2uN7eB8zE5qrZ3CSil+7IJt4WDFLcC75Ymywq1VZVD6qJ6EvNLjZ3rEm6gB7XW5JdT60c6MN35Z85Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.2.tgz",
+      "integrity": "sha512-NCYhOotpgWZ5kdxCZsv6Iudx0wX8980Q/oW4pNFNihpBKsDbEA1zpkfxJGC0yugsUuyDZ7gL37dbzwhR0VI7pQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.2.tgz",
+      "integrity": "sha512-RXsaOqXxfoUBQoOgvmmijVxJnW2IGB0eoMO7F8FAjaj0UTywUO/luSqimWBJn04WNgUkeNhh7fs7pESXajWmkg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.2.tgz",
+      "integrity": "sha512-qdAzEULD+/hzObedtmV6iBpdL5TIbKVztGiK7O3/KYSf+HIzU257+MX1EXJcyIiDbMAqmbwaufcYPvyRryeZtA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.2.tgz",
+      "integrity": "sha512-Nd/SgG27WoA9e+/TdK74KnHz852TLa94ovOYySo/yMPuTmpckK/jIF2jSwS3g7ELSKXK13/cVdmg1Z/DaCWKxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.21",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.21.tgz",
+      "integrity": "sha512-Q+rUQ7Uz8AHM7DEaNdwvfFCTq7a43lNTzuS94eiWqwyxfV/wJv+oUivef51T91mmRY4d4A1u9rcSvkeufCVXlA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001790",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001790.tgz",
+      "integrity": "sha512-bOoxfJPyYo+ds6W0YfptaCWbFnJYjh2Y1Eow5lRv+vI2u8ganPZqNm1JwNh0t2ELQCqIWg4B3dWEusgAmsoyOw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.344",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.344.tgz",
+      "integrity": "sha512-4MxfbmNDm+KPh066EZy+eUnkcDPcZ35wNmOWzFuh/ijvHsve6kbLTLURy88uCNK5FbpN+yk2nQY6BYh1GEt+wg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.38",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.38.tgz",
+      "integrity": "sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.10",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz",
+      "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.2.tgz",
+      "integrity": "sha512-J9qZyW++QK/09NyN/zeO0dG/1GdGfyp9lV8ajHnRVLfo/uFsbji5mHnDgn/qYdUHyCkM2N+8VyspgZclfAh0eQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.2",
+        "@rollup/rollup-android-arm64": "4.60.2",
+        "@rollup/rollup-darwin-arm64": "4.60.2",
+        "@rollup/rollup-darwin-x64": "4.60.2",
+        "@rollup/rollup-freebsd-arm64": "4.60.2",
+        "@rollup/rollup-freebsd-x64": "4.60.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.2",
+        "@rollup/rollup-linux-arm64-musl": "4.60.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.2",
+        "@rollup/rollup-linux-loong64-musl": "4.60.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.2",
+        "@rollup/rollup-linux-x64-gnu": "4.60.2",
+        "@rollup/rollup-linux-x64-musl": "4.60.2",
+        "@rollup/rollup-openbsd-x64": "4.60.2",
+        "@rollup/rollup-openharmony-arm64": "4.60.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.2",
+        "@rollup/rollup-win32-x64-gnu": "4.60.2",
+        "@rollup/rollup-win32-x64-msvc": "4.60.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "neuraledge-boardroom",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.1",
+    "vite": "^5.4.10"
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,111 @@
+import { useEffect, useState } from 'react'
+import { useGameStore } from './hooks/useGameStore.js'
+import { useAgentLoop, greedyPick, buildPitch } from './hooks/useAgentLoop.js'
+
+import TopBar from './components/TopBar.jsx'
+import PlaybackControls from './components/PlaybackControls.jsx'
+import MetricsPanel from './components/MetricsPanel.jsx'
+import TrustPanel from './components/TrustPanel.jsx'
+import EventBanner from './components/EventBanner.jsx'
+import NPCGrid from './components/NPCGrid.jsx'
+import AgentDecision from './components/AgentDecision.jsx'
+import VoteTally from './components/VoteTally.jsx'
+import HistoryTimeline from './components/HistoryTimeline.jsx'
+import EndScreen from './components/EndScreen.jsx'
+
+export default function App() {
+    const { state, resetGame, stepGame, setSpeed, setPaused } = useGameStore()
+    const { obs, prevObs, done, loading, error, lastReward, lastInfo, speed, paused } = state
+
+    const [toast, setToast] = useState(null)
+
+    // Show error toast
+    useEffect(() => {
+        if (error) {
+            setToast(error)
+            const t = setTimeout(() => setToast(null), 5000)
+            return () => clearTimeout(t)
+        }
+    }, [error])
+
+    // Boot
+    useEffect(() => { resetGame(42) }, [resetGame])
+
+    // Wire agent loop
+    useAgentLoop(state, stepGame)
+
+    const handleRun = () => setPaused(false)
+    const handlePause = () => setPaused(true)
+    const handleReset = () => { resetGame(Math.floor(Math.random() * 9999)) }
+    const handleReplay = () => { resetGame(Math.floor(Math.random() * 9999)) }
+
+    const handleStep = async () => {
+        if (!obs || loading || done) return
+        const decision = greedyPick(obs)
+        const pitch = buildPitch(obs, decision)
+        if (decision) await stepGame(decision, pitch)
+    }
+
+    const round = obs?.round ?? 0
+    const curState = obs?.state
+    const prevState = prevObs?.state
+
+    return (
+        <div className="app-shell">
+            <TopBar obs={obs} round={round} />
+            <PlaybackControls
+                paused={paused}
+                loading={loading}
+                done={done}
+                obs={obs}
+                speed={speed}
+                onRun={handleRun}
+                onPause={handlePause}
+                onStep={handleStep}
+                onReset={handleReset}
+                onSpeedChange={setSpeed}
+            />
+
+            {/* Metrics strip at top — always visible */}
+            {curState && (
+                <MetricsPanel state={curState} prevState={prevState} />
+            )}
+
+            <div className="main-grid">
+                {/* Left — Trust + History */}
+                <div className="col-left">
+                    <TrustPanel trust={curState?.trust} prevTrust={prevState?.trust} />
+                    <HistoryTimeline history={curState?.history} />
+                </div>
+
+                {/* Centre — Event + NPCs + Agent Decision */}
+                <div className="col-center">
+                    <EventBanner event={obs?.event} round={round} />
+                    <NPCGrid npcStatements={obs?.npc_statements} />
+                    <AgentDecision obs={obs} loading={loading} lastInfo={lastInfo} />
+                </div>
+
+                {/* Right — Vote Tally */}
+                <div className="col-right">
+                    {lastInfo?.winning_vote_tally && <VoteTally info={lastInfo} />}
+                    {!lastInfo && (
+                        <div className="card">
+                            <div className="section-label">Vote Tally</div>
+                            <div className="card-body" style={{ fontSize: '0.65rem', color: 'var(--text-muted)', textAlign: 'center', padding: '1.25rem 1rem' }}>
+                                // vote tally appears after first decision.
+                            </div>
+                        </div>
+                    )}
+                </div>
+            </div>
+
+            {done && obs && <EndScreen obs={obs} onReplay={handleReplay} />}
+
+            {toast && (
+                <div className="toast">
+                    ⚠ {toast}
+                </div>
+            )}
+        </div>
+    )
+}

frontend/src/components/AgentDecision.jsx

@@ -0,0 +1,88 @@
+// Terminal-style option labels — no emojis, use ASCII prefix chars
+const OPTION_PREFIX = {
+    slash_prices: '>>', differentiate: '>>',  acquire_startup: '>>',
+    accept_deal: '>>', negotiate_terms: '>>',  reject_deal: '>>',
+    match_offers: '>>', partial_match: '>>',   let_them_leave: '>>',
+    full_compliance: '>>', partial_compliance: '>>', exit_EU_market: '>>',
+    public_apology: '>>', legal_action: '>>',  rebrand: '>>',
+    accept_acquisition: '>>', counter_offer: '>>', reject_and_raise: '>>',
+    accept_terms: '>>', negotiate: '>>',       bootstrap: '>>',
+    pivot_product: '>>', license_technology: '>>', keep_internal: '>>',
+    full_transparency: '>>', damage_control: '>>', internal_investigation: '>>',
+    ipo: '>>', acquisition: '>>',              stay_private: '>>',
+}
+
+export default function AgentDecision({ obs, loading, lastInfo }) {
+    if (!obs) return null
+
+    const winningDecision = obs.state?.winning_decision ?? null
+    const aiDecision      = lastInfo?.winning_decision ?? winningDecision
+    const options         = obs.options ?? []
+
+    const history   = obs.state?.history ?? []
+    const lastEntry = history[history.length - 1]
+
+    if (loading && !winningDecision) {
+        return (
+            <div className="card">
+                <div className="section-label">Agent Decision</div>
+                <div className="ai-thinking">
+                    sarah_chen --deliberate
+                    <div className="thinking-dots">
+                        <span /><span /><span />
+                    </div>
+                </div>
+            </div>
+        )
+    }
+
+    return (
+        <div className="card">
+            <div className="section-label">Agent Decision</div>
+            <div className="agent-decision-panel">
+                <div className="decision-options-grid">
+                    {options.map((opt) => {
+                        const isAiPick  = opt === aiDecision
+                        const isWinner  = opt === winningDecision
+                        const isMatch   = aiDecision === winningDecision
+                        let cls = 'decision-option'
+                        if (isAiPick)  cls += ' ai-pick'
+                        if (isWinner && winningDecision)
+                            cls += ` board-winner ${isMatch ? 'board-match' : 'board-mismatch'}`
+                        return (
+                            <div key={opt} className={cls}>
+                                <div className="opt-label">
+                                    {opt.replace(/_/g, '_')}
+                                </div>
+                            </div>
+                        )
+                    })}
+                </div>
+
+                {winningDecision && aiDecision && aiDecision !== winningDecision && (
+                    <div style={{
+                        fontSize: '0.65rem', color: 'var(--error)',
+                        fontFamily: 'var(--font-mono)', padding: '0.375rem 0',
+                        textTransform: 'uppercase', letterSpacing: '0.04em'
+                    }}>
+                        [WARN] AI outvoted → board chose: {winningDecision.replace(/_/g, '_')}
+                    </div>
+                )}
+
+                {lastEntry && (
+                    <div className="coalition-pitch-block">
+                        <div className="pitch-header">Coalition Pitch Log</div>
+                        <div className={`pitch-text ${lastEntry.pitch_used ? '' : 'empty'}`}>
+                            {lastEntry.pitch_used
+                                ? `targeting [${Object.entries(lastEntry.pitch_scores ?? {})
+                                    .filter(([, v]) => v > 0)
+                                    .map(([r]) => r)
+                                    .join(', ')}] — keyword-optimised pitch sent.`
+                                : 'no pitch sent this round.'}
+                        </div>
+                    </div>
+                )}
+            </div>
+        </div>
+    )
+}

frontend/src/components/EndScreen.jsx

@@ -0,0 +1,112 @@
+const formatMoney = (n) =>
+    n >= 1e6 ? `$${(n / 1e6).toFixed(2)}M`
+        : n >= 1e3 ? `$${(n / 1e3).toFixed(1)}K`
+            : `$${n?.toFixed(0) ?? 0}`
+
+const OUTCOME_MAP = {
+    ipo:              { ascii: '[IPO]',    title: 'IPO_SUCCESS',       cls: 'ipo' },
+    acquisition:      { ascii: '[ACQ]',    title: 'ACQUIRED',          cls: 'acquisition' },
+    runway_exhausted: { ascii: '[DEAD]',   title: 'BANKRUPTCY',        cls: 'bankruptcy' },
+    finished_10:      { ascii: '[DONE]',   title: 'EPISODE_COMPLETE',  cls: 'default' },
+}
+
+const DIVIDER = '================================================'
+
+export default function EndScreen({ obs, onReplay }) {
+    if (!obs) return null
+    const { state }   = obs
+    const reason      = state?.done_reason ?? 'finished_10'
+    const { ascii, title, cls } = OUTCOME_MAP[reason] ?? OUTCOME_MAP['finished_10']
+    const history     = state?.history ?? []
+    const roundsWon   = history.filter(h => h.agent_won_vote).length
+
+    return (
+        <div className="end-overlay">
+            <div className="end-modal">
+                {/* ASCII banner */}
+                <div className="end-icon" style={{ fontSize: '1.5rem', fontWeight: 700, letterSpacing: '0.1em' }}>
+                    {ascii}
+                </div>
+                <div className="end-title">{title}</div>
+                <span className={`end-reason ${cls}`}>{reason.replace(/_/g, '_')}</span>
+
+                <div style={{ color: 'var(--muted)', fontSize: '0.6rem', marginBottom: '0.875rem', letterSpacing: '0.05em' }}>
+                    {DIVIDER}
+                </div>
+
+                <div className="end-stats">
+                    <div className="end-stat">
+                        <div className="es-label">PROFIT_SCORE</div>
+                        <div className="es-value" style={{ color: 'var(--primary)', textShadow: 'var(--glow)' }}>
+                            {(state?.profitability_score ?? 0).toFixed(1)}
+                        </div>
+                    </div>
+                    <div className="end-stat">
+                        <div className="es-label">REVENUE</div>
+                        <div className="es-value">{formatMoney(state?.revenue ?? 0)}</div>
+                    </div>
+                    <div className="end-stat">
+                        <div className="es-label">RUNWAY</div>
+                        <div className="es-value">{(state?.runway_months ?? 0).toFixed(1)}mo</div>
+                    </div>
+                    <div className="end-stat">
+                        <div className="es-label">ROUNDS_WON</div>
+                        <div className="es-value" style={{ color: 'var(--primary)', textShadow: 'var(--glow)' }}>
+                            {roundsWon}/{history.length}
+                        </div>
+                    </div>
+                    <div className="end-stat">
+                        <div className="es-label">MORALE</div>
+                        <div className="es-value">{Math.round((state?.team_morale ?? 0) * 100)}%</div>
+                    </div>
+                    <div className="end-stat">
+                        <div className="es-label">REG_RISK</div>
+                        <div className="es-value">{Math.round((state?.regulatory_risk ?? 0) * 100)}%</div>
+                    </div>
+                </div>
+
+                {history.length > 0 && (
+                    <div style={{ marginBottom: '1rem', maxHeight: '180px', overflowY: 'auto' }}>
+                        <div style={{
+                            fontSize: '0.58rem', textTransform: 'uppercase', letterSpacing: '0.1em',
+                            color: 'var(--text-secondary)', marginBottom: '0.4rem'
+                        }}>
+                            // round_log
+                        </div>
+                        {history.map((h) => (
+                            <div key={h.round} style={{
+                                display: 'flex', justifyContent: 'space-between',
+                                fontSize: '0.65rem', color: 'var(--text-secondary)',
+                                padding: '0.2rem 0',
+                                borderBottom: '1px solid var(--border-dim)'
+                            }}>
+                                <span style={{ color: 'var(--secondary)', textShadow: 'var(--amber-glow)', minWidth: '28px' }}>
+                                    R{String(h.round).padStart(2,'0')}
+                                </span>
+                                <span style={{
+                                    flex: 1, marginLeft: '0.6rem',
+                                    overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                                    textTransform: 'uppercase', letterSpacing: '0.03em',
+                                    fontSize: '0.6rem'
+                                }}>
+                                    {(h.event_title ?? '').split('—').slice(-1)[0]?.trim()}
+                                </span>
+                                <span style={{
+                                    marginLeft: '0.5rem', flexShrink: 0, fontSize: '0.6rem',
+                                    color: h.agent_won_vote ? 'var(--primary)' : 'var(--error)',
+                                    textShadow: h.agent_won_vote ? 'var(--glow-sm)' : 'none'
+                                }}>
+                                    {h.agent_won_vote ? '[OK]' : '[X]'} {(h.agent_decision ?? '').replace(/_/g, '_')}
+                                </span>
+                            </div>
+                        ))}
+                    </div>
+                )}
+
+                <button className="replay-btn" onClick={onReplay}>
+                    ↺ RUN_NEW_EPISODE
+                </button>
+            </div>
+        </div>
+    )
+}

frontend/src/components/EventBanner.jsx

@@ -0,0 +1,26 @@
+export default function EventBanner({ event, round }) {
+    if (!event) {
+        return (
+            <div className="event-banner">
+                <div className="event-tag">BOARD_CRISIS</div>
+                <div className="event-title">Awaiting scenario...</div>
+                <div className="event-desc">$ run_agent --start  # click RUN_AGENT to begin</div>
+            </div>
+        )
+    }
+
+    const [titlePart, ...rest] = event.split('\n')
+    const desc = rest.join(' ').replace(/^Description:\s*/i, '').trim() || event
+
+    return (
+        <div className="event-banner">
+            <div className="event-tag">
+                RND_{String(round).padStart(2,'0')} / BOARD_CRISIS
+            </div>
+            <div className="event-title">{titlePart.toUpperCase()}</div>
+            {desc && desc !== titlePart && (
+                <div className="event-desc">{desc}</div>
+            )}
+        </div>
+    )
+}

frontend/src/components/HistoryTimeline.jsx

@@ -0,0 +1,50 @@
+export default function HistoryTimeline({ history }) {
+    return (
+        <div className="card">
+            <div className="section-label">Decision History</div>
+            {!history?.length ? (
+                <div className="history-empty">// no rounds completed yet.</div>
+            ) : (
+                <div className="history-list">
+                    {history.map((entry) => {
+                        const aiWon     = entry.agent_won_vote
+                        const reward    = entry.reward ?? ((entry.score_after ?? 0) - 0)
+                        const rewardNum = typeof reward === 'number' ? reward : 0
+                        return (
+                            <div key={entry.round} className="history-item">
+                                <span className="h-round">R{String(entry.round).padStart(2,'0')}</span>
+                                <div className="h-info">
+                                    <div className="h-event">
+                                        {(entry.event_title ?? '').split('—').slice(-1)[0]?.trim() ?? entry.event_title}
+                                    </div>
+                                    <div className="h-picks">
+                                        <span className="h-ai-pick">
+                                            &gt;{(entry.agent_decision ?? '').replace(/_/g, '_')}
+                                        </span>
+                                        {!aiWon && (
+                                            <>
+                                                <span style={{ color: 'var(--muted)' }}>→</span>
+                                                <span className="h-win-pick">
+                                                    {(entry.winning_decision ?? '').replace(/_/g, '_')}
+                                                </span>
+                                                <span className="h-mismatch">[X]</span>
+                                            </>
+                                        )}
+                                        {aiWon && (
+                                            <span style={{ color: 'var(--primary)', fontSize: '0.55rem', textShadow: 'var(--glow-sm)' }}>
+                                                &nbsp;[OK]
+                                            </span>
+                                        )}
+                                    </div>
+                                </div>
+                                <span className={`h-reward ${rewardNum >= 0 ? 'pos' : 'neg'}`}>
+                                    {rewardNum >= 0 ? '+' : ''}{rewardNum.toFixed(2)}
+                                </span>
+                            </div>
+                        )
+                    })}
+                </div>
+            )}
+        </div>
+    )
+}

frontend/src/components/MetricsPanel.jsx

@@ -0,0 +1,83 @@
+const formatMoney = (n) =>
+    n >= 1e6 ? `$${(n / 1e6).toFixed(2)}M`
+        : n >= 1e3 ? `$${(n / 1e3).toFixed(1)}K`
+            : `$${Math.abs(n).toFixed(0)}`
+
+const formatPct = (v) => `${(v * 100).toFixed(0)}%`
+const fmtDelta = (key, d) => {
+    if (key === 'revenue' || key === 'burn_rate') return formatMoney(Math.abs(d))
+    if (key === 'runway_months') return `${Math.abs(d).toFixed(1)}mo`
+    if (key === 'profitability_score') return Math.abs(d).toFixed(1)
+    return formatPct(Math.abs(d))
+}
+
+// ASCII progress bar — no chart.js, pure terminal
+function AsciiBar({ value, max = 1, width = 8 }) {
+    const filled = Math.round((value / max) * width)
+    const empty = width - filled
+    return (
+        <span style={{ color: 'var(--muted)', letterSpacing: 0 }}>
+            [<span style={{ color: 'var(--primary)', textShadow: 'var(--glow-sm)' }}>
+                {'█'.repeat(Math.max(0, filled))}
+            </span>
+            {'░'.repeat(Math.max(0, empty))}]
+        </span>
+    )
+}
+
+const TILES = [
+    { key: 'profitability_score', label: 'SCORE',    fmt: (v) => v.toFixed(1),            max: 100 },
+    { key: 'revenue',             label: 'REVENUE',  fmt: formatMoney,                     max: null },
+    { key: 'burn_rate',           label: 'BURN',     fmt: formatMoney,                     max: null },
+    { key: 'runway_months',       label: 'RUNWAY',   fmt: (v) => `${v.toFixed(1)}mo`,      max: 24 },
+    { key: 'product_readiness',   label: 'PRODUCT',  fmt: formatPct,                       max: 1 },
+    { key: 'market_share',        label: 'MARKET',   fmt: formatPct,                       max: 1 },
+    { key: 'team_morale',         label: 'MORALE',   fmt: formatPct,                       max: 1 },
+    { key: 'investor_confidence', label: 'INVEST',   fmt: formatPct,                       max: 1 },
+    { key: 'regulatory_risk',     label: 'REG_RSK',  fmt: formatPct,                       max: 1 },
+]
+
+function scoreTile(key, val) {
+    if (key === 'regulatory_risk') return val > 0.65 ? 'bad' : val > 0.35 ? 'warn' : 'good'
+    if (key === 'runway_months')   return val > 12   ? 'good' : val > 6   ? 'warn' : 'bad'
+    if (key === 'profitability_score') return val >= 60 ? 'good' : val >= 35 ? 'warn' : 'bad'
+    if (key === 'burn_rate') return ''
+    return val > 0.65 ? 'good' : val > 0.35 ? 'warn' : 'bad'
+}
+
+export default function MetricsPanel({ state, prevState }) {
+    if (!state) return null
+
+    return (
+        <div className="metrics-strip">
+            {TILES.map(({ key, label, fmt, max }) => {
+                const val   = state[key] ?? 0
+                const prev  = prevState?.[key]
+                const delta = prev !== undefined ? val - prev : null
+                const cls   = scoreTile(key, val)
+                const barVal = max ? Math.min(val, max) : null
+
+                return (
+                    <div key={key} className="metric-tile">
+                        <div className="m-icon-label">
+                            <span className="m-label">{label}</span>
+                        </div>
+                        <div className="m-value-row">
+                            <span className={`m-value ${cls}`}>{fmt(val)}</span>
+                            {delta !== null && Math.abs(delta) > 0.001 && (
+                                <span className={`m-delta ${delta > 0 ? 'pos' : 'neg'}`}>
+                                    {delta > 0 ? '+' : '−'}{fmtDelta(key, delta)}
+                                </span>
+                            )}
+                        </div>
+                        {barVal !== null && (
+                            <div style={{ marginTop: '0.15rem' }}>
+                                <AsciiBar value={barVal} max={max} width={6} />
+                            </div>
+                        )}
+                    </div>
+                )
+            })}
+        </div>
+    )
+}

frontend/src/components/NPCGrid.jsx

@@ -0,0 +1,76 @@
+// NPC agenda keyword hints shown on cards (top 4 per role)
+const AGENDA_HINTS = {
+    'CTO':           ['engineering', 'architecture', 'team morale', 'reliability'],
+    'CFO':           ['burn rate', 'runway', 'fiduciary', 'cost discipline'],
+    'Investor Rep':  ['growth', 'market share', 'IPO', 'bold moves'],
+    'Independent':   ['reputation', 'ethics', 'long-term', 'governance'],
+}
+
+const ROLE_CLS = {
+    'CTO': 'cto', 'CFO': 'cfo', 'Investor Rep': 'inv', 'Independent': 'ind',
+}
+
+const ROLE_INITIALS = {
+    'CTO': 'CT', 'CFO': 'CF', 'Investor Rep': 'IN', 'Independent': 'ID',
+}
+
+function NPCCard({ npc }) {
+    const { role, statement, vote, confidence } = npc
+    const cls  = ROLE_CLS[role]  ?? 'ind'
+    const pct  = Math.round(confidence * 100)
+    const hints = AGENDA_HINTS[role] ?? []
+
+    return (
+        <div className={`npc-card ${cls}`}>
+            <div className="npc-header">
+                <div className="npc-avatar-role">
+                    <div className={`npc-avatar ${cls}`}>{ROLE_INITIALS[role] ?? role[0]}</div>
+                    <span className={`npc-role ${cls}`}>{role.toUpperCase()}</span>
+                </div>
+                <span className="npc-vote-chip" title={`Votes: ${vote}`}>
+                    →{vote.replace(/_/g, '_')}
+                </span>
+            </div>
+
+            <p className="npc-statement">{statement}</p>
+
+            <div className="npc-conf-row">
+                <span className="conf-label">CONF</span>
+                <div className="conf-track">
+                    <div className="conf-fill" style={{ width: `${pct}%` }} />
+                </div>
+                <span className="conf-pct">{pct}%</span>
+            </div>
+
+            <div className="npc-agenda-tags">
+                {hints.map((h) => (
+                    <span key={h} className="agenda-tag">#{h}</span>
+                ))}
+            </div>
+        </div>
+    )
+}
+
+export default function NPCGrid({ npcStatements }) {
+    if (!npcStatements?.length) {
+        return (
+            <div className="card">
+                <div className="section-label">Board Statements</div>
+                <div className="card-body" style={{ fontSize: '0.65rem', color: 'var(--text-muted)', textAlign: 'center', padding: '1rem' }}>
+                    // awaiting board response...
+                </div>
+            </div>
+        )
+    }
+
+    return (
+        <div className="card">
+            <div className="section-label">Board Statements</div>
+            <div className="npc-grid">
+                {npcStatements.map((npc) => (
+                    <NPCCard key={npc.role} npc={npc} />
+                ))}
+            </div>
+        </div>
+    )
+}

frontend/src/components/PlaybackControls.jsx

@@ -0,0 +1,64 @@
+export default function PlaybackControls({
+    paused,
+    loading,
+    done,
+    obs,
+    speed,
+    onRun,
+    onPause,
+    onStep,
+    onReset,
+    onSpeedChange,
+}) {
+    const canStep = !loading && !done && !!obs
+    const statusText = loading ? 'PROCESSING...'
+        : done ? 'EPISODE_DONE'
+            : paused ? 'PAUSED'
+                : 'RUNNING'
+
+    const statusDot = loading ? '' : done ? '' : paused ? 'paused' : 'running'
+
+    return (
+        <div className="playback-bar">
+            {paused && !done ? (
+                <button className="pb-btn primary" onClick={onRun} disabled={loading || !obs}>
+                    ▶ RUN_AGENT
+                </button>
+            ) : (
+                <button className="pb-btn" onClick={onPause} disabled={loading || done}>
+                    ⏸ PAUSE
+                </button>
+            )}
+
+            <button className="pb-btn" onClick={onStep} disabled={!canStep}>
+                ⏭ STEP
+            </button>
+
+            <div className="pb-divider" />
+
+            <button className="pb-btn" onClick={onReset} disabled={loading}>
+                ↺ RESET
+            </button>
+
+            <div className="pb-divider" />
+
+            <div className="speed-control">
+                <span>SPEED</span>
+                <input
+                    type="range"
+                    min={0.5}
+                    max={4}
+                    step={0.25}
+                    value={speed}
+                    onChange={(e) => onSpeedChange(parseFloat(e.target.value))}
+                />
+                <span className="speed-label">{speed.toFixed(2)}x</span>
+            </div>
+
+            <div className="pb-status">
+                <div className={`status-dot ${statusDot}`} />
+                {statusText}
+            </div>
+        </div>
+    )
+}

frontend/src/components/TopBar.jsx

@@ -0,0 +1,59 @@
+import { useEffect, useState } from 'react'
+import { apiHealth } from '../services/api.js'
+
+const ASCII_LOGO = `
+ _  _ ____ _  _ ____ ____ _    ____ ___  ____ ____
+ |\ | |___ |  | |__/ |__| |    |___ |  \ | __ |___
+ | \| |___ |__| |  \ |  | |___ |___ |__/ |__] |___
+`
+
+export default function TopBar({ obs, round }) {
+    const [online, setOnline] = useState(false)
+    const [tick, setTick] = useState(true)
+
+    useEffect(() => {
+        const check = async () => setOnline(await apiHealth())
+        check()
+        const id = setInterval(check, 15_000)
+        return () => clearInterval(id)
+    }, [])
+
+    // blinking colon in clock-style indicator
+    useEffect(() => {
+        const t = setInterval(() => setTick(v => !v), 500)
+        return () => clearInterval(t)
+    }, [])
+
+    const score = obs?.state?.profitability_score ?? null
+    const scoreClass = score === null ? '' : score >= 60 ? 'good' : score >= 35 ? 'warn' : 'bad'
+
+    return (
+        <div className="topbar">
+            <div className="topbar-brand">
+                {/* compact single-line ASCII header */}
+                <div className="brand-name">NeuralEdge</div>
+                <div style={{ width: '1px', height: '18px', background: 'var(--border)', margin: '0 0.35rem' }} />
+                <div className="brand-ceo">CEO: Sarah Chen&nbsp;|&nbsp;AI Agent</div>
+            </div>
+
+            <div className="topbar-center">
+                <div className="round-badge">
+                    RND {obs ? `${String(round).padStart(2,'0')} / 10` : '--/10'}
+                </div>
+                {score !== null && (
+                    <div className="score-display">
+                        <div className="score-label">PROFIT_SCORE</div>
+                        <div className={`score-value ${scoreClass}`}>{score.toFixed(1)}</div>
+                    </div>
+                )}
+            </div>
+
+            <div className="topbar-right">
+                <div className="health-indicator">
+                    <div className={`health-dot ${online ? 'online' : 'offline'}`} />
+                    {online ? '[OK] BACKEND' : '[ERR] OFFLINE'}
+                </div>
+            </div>
+        </div>
+    )
+}