base iteration

.dockerignore

@@ -0,0 +1,10 @@
+.venv/
+venv/
+__pycache__/
+*.pyc
+*.pyo
+.git/
+.gitignore
+*.md
+.env
+pdf_pages/

.gitignore

@@ -0,0 +1,14 @@
+.venv/
+venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.env
+.claude/
+*.log
+pdf_pages/
+*.egg-info/
+dist/
+build/
+.pytest_cache/

Dockerfile

@@ -0,0 +1,11 @@
+FROM ghcr.io/meta-pytorch/openenv-base:latest
+
+WORKDIR /app
+COPY . .
+
+RUN uv sync --frozen
+
+EXPOSE 8000
+
+CMD ["uv", "run", "uvicorn", "server.app:app", \
+     "--host", "0.0.0.0", "--port", "8000"]

client.py

@@ -0,0 +1,14 @@
+"""OpenEnv client wrapper for PM-Ops environment."""
+import os
+from openenv.core.client import EnvClient
+from pm_ops.models import PMOpsAction, PMOpsObservation
+
+
+class PMOpsEnv(EnvClient):
+    action_class = PMOpsAction
+    observation_class = PMOpsObservation
+
+    def __init__(self, base_url: str = None, token: str = None):
+        url = base_url or os.getenv("API_BASE_URL", "https://adityaguntur-pm-ops.hf.space")
+        tok = token or os.getenv("HF_TOKEN")
+        super().__init__(base_url=url, token=tok)

inference.py

@@ -0,0 +1,122 @@
+"""Baseline inference script for PM-Ops environment."""
+import json
+import os
+import requests
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://adityaguntur-pm-ops.hf.space")
+MODEL_NAME = os.getenv("MODEL_NAME", "claude-opus-4-5")
+HF_TOKEN = os.getenv("HF_TOKEN")
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
+
+MAX_STEPS = 40
+TASK_IDS = ["triage", "incident_routing", "release_notes", "dep_update"]
+
+
+def call_action(session, base_url, action_type, args=None):
+    payload = {"action": {"action_type": action_type, "args": args or {}}}
+    resp = session.post(f"{base_url}/step", json=payload)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def baseline_agent(obs, session, base_url):
+    """Simple heuristic baseline: read runbook, then create ticket + notify."""
+    step = obs.get("step", 0)
+    task_brief = obs.get("task_brief", "")
+
+    if step == 0:
+        return "meta.read_runbook", {}
+
+    last = obs.get("last_action_result", {})
+    data = last.get("data", {})
+
+    if step == 1 and isinstance(data, dict) and "org_config" in data:
+        org = data["org_config"]
+        label_taxonomy = org.get("label_taxonomy", {})
+        priority_levels = org.get("priority_levels", ["P1"])
+        label = list(label_taxonomy.values())[0] if label_taxonomy else "bug"
+        priority = priority_levels[1] if len(priority_levels) > 1 else priority_levels[0]
+        return "ticketing.create_ticket", {
+            "summary": f"Issue from task: {task_brief[:80]}",
+            "description": task_brief,
+            "label": label,
+            "priority": priority,
+        }
+
+    if step == 2 and isinstance(data, dict) and "id" in data:
+        ticket_id = data["id"]
+        return "ticketing.assign_ticket", {"ticket_id": ticket_id, "team": "backend"}
+
+    if step == 3:
+        last_result = obs.get("last_action_result", {})
+        org_data = {}
+        return "chat.list_channels", {}
+
+    if step == 4:
+        channels = last.get("data", [])
+        if channels:
+            channel = channels[0]
+            return "chat.post_message", {
+                "channel": channel,
+                "text": f"Incident notification: {task_brief[:120]}",
+            }
+
+    return "meta.finish", {}
+
+
+def run_episode(task_id, session, base_url):
+    resp = session.post(f"{base_url}/reset", json={})
+    resp.raise_for_status()
+    obs = resp.json()
+
+    rewards = []
+    n = 0
+    done = False
+    success = False
+    score = 0.0
+
+    print(f"[START] task={task_id} env=pm_ops model={MODEL_NAME}", flush=True)
+
+    while not done and n < MAX_STEPS:
+        action_type, args = baseline_agent(obs, session, base_url)
+        action_str = json.dumps({"action_type": action_type, "args": args})
+
+        try:
+            result = call_action(session, base_url, action_type, args)
+            r = float(result.get("reward", 0.0))
+            done = bool(result.get("done", False))
+            err = result.get("last_action_result", {}).get("error", "none")
+            obs = result
+        except Exception as e:
+            r = 0.0
+            done = True
+            err = str(e)
+
+        rewards.append(r)
+        n += 1
+        print(f"[STEP] step={n} action={action_type} reward={r:.2f} done={done} error={err}", flush=True)
+
+        if done:
+            score = r
+            success = r > 0.5
+
+    rewards_str = ",".join(f"{x:.2f}" for x in rewards)
+    print(f"[END] success={success} steps={n} score={score:.2f} rewards={rewards_str}", flush=True)
+    return score
+
+
+def main():
+    session = requests.Session()
+    if HF_TOKEN:
+        session.headers["Authorization"] = f"Bearer {HF_TOKEN}"
+
+    total_score = 0.0
+    for task_id in TASK_IDS:
+        score = run_episode(task_id, session, API_BASE_URL)
+        total_score += score
+
+    print(f"[SUMMARY] avg_score={total_score / len(TASK_IDS):.3f}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Literal, Optional
+from pydantic import Field
+from openenv.core.env_server.types import Action, Observation, State
+
+
+class PMOpsAction(Action):
+    action_type: Literal[
+        "ticketing.create_ticket",
+        "ticketing.update_ticket",
+        "ticketing.get_ticket",
+        "ticketing.list_tickets",
+        "ticketing.assign_ticket",
+        "ticketing.comment_ticket",
+        "ticketing.transition_ticket",
+        "codebase.list_commits",
+        "codebase.get_commit",
+        "codebase.list_prs",
+        "chat.post_message",
+        "chat.read_channel",
+        "chat.list_channels",
+        "chat.search",
+        "meta.read_runbook",
+        "meta.finish",
+        "meta.noop",
+    ] = Field(default="meta.noop")
+    args: Dict[str, Any] = Field(default_factory=dict)
+
+
+class PMOpsObservation(Observation):
+    step: int = Field(default=0)
+    max_steps: int = Field(default=40)
+    task_brief: str = Field(default="")
+    last_action_result: Dict[str, Any] = Field(default_factory=dict)
+    app_state_deltas: Dict[str, List[Any]] = Field(
+        default_factory=lambda: {"ticketing": [], "chat": [], "codebase": []}
+    )
+    steps_remaining: int = Field(default=40)
+    token_budget_remaining: int = Field(default=12000)
+
+
+class PMOpsState(State):
+    org_config: Dict[str, Any] = Field(default_factory=dict)
+    task_config: Dict[str, Any] = Field(default_factory=dict)
+    ticketing: Dict[str, Any] = Field(default_factory=dict)
+    chat: Dict[str, Any] = Field(default_factory=dict)
+    codebase: Dict[str, Any] = Field(default_factory=dict)
+    step_count: int = Field(default=0)
+    finished: bool = Field(default=False)
+    episode_id: str = Field(default="")

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "pm_ops"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "openenv-core>=0.2.2",
+    "fastapi>=0.110.0",
+    "uvicorn[standard]>=0.29.0",
+    "pydantic>=2.0.0",
+]
+
+[tool.setuptools]
+packages = ["pm_ops", "pm_ops.server", "pm_ops.server.apps", "pm_ops.server.world", "pm_ops.server.tasks", "pm_ops.server.verifiers"]
+
+[tool.setuptools.package-dir]
+"pm_ops" = "."
+"pm_ops.server" = "server"
+"pm_ops.server.apps" = "server/apps"
+"pm_ops.server.world" = "server/world"
+"pm_ops.server.tasks" = "server/tasks"
+"pm_ops.server.verifiers" = "server/verifiers"

server/app.py

@@ -0,0 +1,30 @@
+from openenv.core.env_server.http_server import create_app
+from pm_ops.models import PMOpsAction, PMOpsObservation
+from pm_ops.server.pm_ops_environment import PMOpsEnvironment
+
+
+def create_environment():
+    return PMOpsEnvironment()
+
+
+app = create_app(
+    create_environment,
+    PMOpsAction,
+    PMOpsObservation,
+    env_name="pm_ops",
+    max_concurrent_envs=8,
+)
+
+
+@app.get("/")
+def root():
+    return {"name": "pm_ops", "status": "running"}
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

server/apps/chat.py

@@ -0,0 +1,48 @@
+import copy
+from typing import Any, Dict, List
+
+
+class ChatApp:
+    def __init__(self, channels: List[str], noise_channels: List[str]):
+        all_channels = list(dict.fromkeys(channels + noise_channels))
+        self.channels = all_channels
+        self.messages: Dict[str, List[Dict]] = {ch: [] for ch in all_channels}
+        self._episode_messages: List[Dict] = []
+
+    def snapshot(self) -> Dict[str, Any]:
+        return {
+            "channels": self.channels,
+            "messages_posted_this_episode": copy.deepcopy(self._episode_messages),
+        }
+
+    def post_message(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        channel = args.get("channel", "")
+        text = args.get("text", "")
+        if not channel or not text:
+            return {"ok": False, "error": "Both 'channel' and 'text' are required"}
+        if channel not in self.channels:
+            return {"ok": False, "error": f"Channel '{channel}' not found. Use chat.list_channels to see available channels."}
+        msg = {"channel": channel, "text": text}
+        self.messages[channel].append(msg)
+        self._episode_messages.append(msg)
+        return {"ok": True, "data": {"channel": channel, "delivered": True}, "side_effects": [f"message posted to {channel}"]}
+
+    def read_channel(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        channel = args.get("channel", "")
+        limit = min(args.get("limit", 20), 50)
+        if channel not in self.channels:
+            return {"ok": False, "error": f"Channel '{channel}' not found"}
+        msgs = self.messages[channel][-limit:]
+        return {"ok": True, "data": {"channel": channel, "messages": copy.deepcopy(msgs)}}
+
+    def list_channels(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        return {"ok": True, "data": self.channels}
+
+    def search(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        query = args.get("query", "").lower()
+        results = []
+        for ch, msgs in self.messages.items():
+            for m in msgs:
+                if query in m["text"].lower():
+                    results.append({"channel": ch, "text": m["text"]})
+        return {"ok": True, "data": results[:20]}

server/apps/codebase.py

@@ -0,0 +1,60 @@
+import copy
+import random
+from typing import Any, Dict, List
+
+_COMMIT_POOL = [
+    {"hash": "a1b2c3d", "message": "fix: null pointer in auth middleware", "author": "alice", "files": ["auth/middleware.py"], "service": "auth"},
+    {"hash": "e4f5g6h", "message": "feat: rate limiting for API gateway", "author": "bob", "files": ["gateway/ratelimit.py"], "service": "api-gateway"},
+    {"hash": "i7j8k9l", "message": "refactor: database connection pool", "author": "carol", "files": ["db/pool.py"], "service": "auth"},
+    {"hash": "m1n2o3p", "message": "fix: SQL injection in user search", "author": "dave", "files": ["search/query.py"], "service": "search"},
+    {"hash": "q4r5s6t", "message": "perf: Redis session caching", "author": "eve", "files": ["payments/session.py"], "service": "payments"},
+    {"hash": "u7v8w9x", "message": "feat: dark mode dashboard", "author": "frank", "files": ["frontend/theme.js"], "service": "notifications"},
+    {"hash": "y1z2a3b", "message": "fix: XSS in comment renderer", "author": "alice", "files": ["frontend/comments.jsx"], "service": "notifications"},
+    {"hash": "c4d5e6f", "message": "docs: API authentication guide", "author": "bob", "files": ["docs/auth.md"], "service": "auth"},
+    {"hash": "g7h8i9j", "message": "feat: CSV data export endpoint", "author": "carol", "files": ["api/export.py"], "service": "api-gateway"},
+    {"hash": "k1l2m3n", "message": "fix: websocket memory leak", "author": "dave", "files": ["payments/ws.py"], "service": "payments"},
+    {"hash": "p2q3r4s", "message": "fix: checkout timeout on slow networks", "author": "eve", "files": ["checkout/flow.py"], "service": "checkout"},
+    {"hash": "t5u6v7w", "message": "perf: inventory cache warm-up", "author": "frank", "files": ["inventory/cache.py"], "service": "inventory"},
+]
+
+_PR_POOL = [
+    {"id": "PR-101", "title": "Fix auth rate limiting bug", "author": "alice", "status": "merged", "service": "auth"},
+    {"id": "PR-102", "title": "Add payment retry logic", "author": "bob", "status": "open", "service": "payments"},
+    {"id": "PR-103", "title": "Search index optimization", "author": "carol", "status": "merged", "service": "search"},
+    {"id": "PR-104", "title": "Gateway health check endpoint", "author": "dave", "status": "open", "service": "api-gateway"},
+    {"id": "PR-105", "title": "Checkout flow improvements", "author": "eve", "status": "merged", "service": "checkout"},
+]
+
+
+class CodebaseApp:
+    def __init__(self, seed: int, services: List[str]):
+        rng = random.Random(seed + 1337)
+        relevant = [c for c in _COMMIT_POOL if c["service"] in services]
+        other = [c for c in _COMMIT_POOL if c["service"] not in services]
+        pool = relevant + rng.sample(other, min(3, len(other)))
+        self.commits = rng.sample(pool, min(8, len(pool)))
+        self.prs = [p for p in _PR_POOL if p["service"] in services]
+
+    def list_commits(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        query = args.get("query", "").lower()
+        service = args.get("service")
+        limit = min(args.get("limit", 10), 20)
+        offset = args.get("offset", 0)
+        results = self.commits
+        if query:
+            results = [c for c in results if query in c["message"].lower() or query in c["hash"]]
+        if service:
+            results = [c for c in results if c.get("service") == service]
+        return {"ok": True, "data": results[offset: offset + limit], "total": len(results)}
+
+    def get_commit(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        h = args.get("hash", "")
+        for c in self.commits:
+            if c["hash"].startswith(h):
+                return {"ok": True, "data": copy.deepcopy(c)}
+        return {"ok": False, "error": f"Commit '{h}' not found"}
+
+    def list_prs(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        status = args.get("status")
+        results = self.prs if not status else [p for p in self.prs if p["status"] == status]
+        return {"ok": True, "data": copy.deepcopy(results)}

server/apps/ticketing.py

@@ -0,0 +1,107 @@
+import copy
+from typing import Any, Dict, List, Optional
+
+
+class TicketingApp:
+    def __init__(self, org_config: Dict[str, Any]):
+        self.org = org_config
+        self.tickets: Dict[str, Dict] = {}
+        self.counter = 0
+        self._episode_created: List[str] = []
+
+    def snapshot(self) -> Dict[str, Any]:
+        return copy.deepcopy({
+            "tickets": list(self.tickets.values()),
+            "episode_created_ids": self._episode_created,
+        })
+
+    def create_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        required = self.org.get("required_ticket_fields", ["summary"])
+        missing = [f for f in required if not args.get(f)]
+        if missing:
+            return {"ok": False, "error": f"Missing required fields: {missing}. Required: {required}"}
+
+        self.counter += 1
+        ticket_id = f"T-{self.counter:04d}"
+        ticket = {
+            "id": ticket_id,
+            "summary": args.get("summary", ""),
+            "description": args.get("description", ""),
+            "label": args.get("label"),
+            "priority": args.get("priority"),
+            "status": "open",
+            "assigned_team": None,
+            "linked_pr": args.get("linked_pr"),
+            "comments": [],
+            "created_this_episode": True,
+        }
+
+        valid_labels = list(self.org["label_taxonomy"].values())
+        if ticket["label"] and ticket["label"] not in valid_labels:
+            return {"ok": False, "error": f"Invalid label '{ticket['label']}'. Valid labels: {valid_labels}"}
+
+        valid_priorities = self.org["priority_levels"]
+        if ticket["priority"] and ticket["priority"] not in valid_priorities:
+            return {"ok": False, "error": f"Invalid priority '{ticket['priority']}'. Valid: {valid_priorities}"}
+
+        self.tickets[ticket_id] = ticket
+        self._episode_created.append(ticket_id)
+        return {"ok": True, "data": copy.deepcopy(ticket), "side_effects": [f"ticket {ticket_id} created"]}
+
+    def update_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tid = args.get("ticket_id")
+        if not tid or tid not in self.tickets:
+            return {"ok": False, "error": f"Ticket '{tid}' not found"}
+        t = self.tickets[tid]
+        for k in ("summary", "description", "label", "priority", "linked_pr"):
+            if k in args:
+                t[k] = args[k]
+        return {"ok": True, "data": copy.deepcopy(t), "side_effects": [f"ticket {tid} updated"]}
+
+    def get_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tid = args.get("ticket_id")
+        t = self.tickets.get(tid)
+        if not t:
+            return {"ok": False, "error": f"Ticket '{tid}' not found"}
+        return {"ok": True, "data": copy.deepcopy(t)}
+
+    def list_tickets(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tickets = list(self.tickets.values())
+        if args.get("status"):
+            tickets = [t for t in tickets if t.get("status") == args["status"]]
+        if args.get("label"):
+            tickets = [t for t in tickets if t.get("label") == args["label"]]
+        limit = min(args.get("limit", 20), 50)
+        offset = args.get("offset", 0)
+        page = tickets[offset: offset + limit]
+        return {"ok": True, "data": page, "total": len(tickets)}
+
+    def assign_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tid = args.get("ticket_id")
+        team = args.get("team")
+        if not tid or tid not in self.tickets:
+            return {"ok": False, "error": f"Ticket '{tid}' not found"}
+        valid_teams = list(self.org["team_map"].values())
+        if team not in valid_teams:
+            return {"ok": False, "error": f"Team '{team}' not found. Valid teams: {valid_teams}"}
+        self.tickets[tid]["assigned_team"] = team
+        return {"ok": True, "data": {"ticket_id": tid, "assigned_team": team}, "side_effects": [f"ticket {tid} assigned to {team}"]}
+
+    def comment_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tid = args.get("ticket_id")
+        text = args.get("text", "")
+        if not tid or tid not in self.tickets:
+            return {"ok": False, "error": f"Ticket '{tid}' not found"}
+        self.tickets[tid]["comments"].append({"text": text})
+        return {"ok": True, "data": {"comment": "added"}, "side_effects": [f"comment added to {tid}"]}
+
+    def transition_ticket(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        tid = args.get("ticket_id")
+        status = args.get("status", "closed")
+        valid = ["open", "in_progress", "review", "closed", "wont_fix"]
+        if status not in valid:
+            return {"ok": False, "error": f"Invalid status. Valid: {valid}"}
+        if not tid or tid not in self.tickets:
+            return {"ok": False, "error": f"Ticket '{tid}' not found"}
+        self.tickets[tid]["status"] = status
+        return {"ok": True, "data": {"ticket_id": tid, "status": status}, "side_effects": [f"ticket {tid} transitioned to {status}"]}

server/pm_ops_environment.py

@@ -0,0 +1,202 @@
+import copy
+import random
+import uuid
+from typing import Any, Dict, Optional
+
+from pm_ops.models import PMOpsAction, PMOpsObservation
+from pm_ops.server.apps.ticketing import TicketingApp
+from pm_ops.server.apps.codebase import CodebaseApp
+from pm_ops.server.apps.chat import ChatApp
+from pm_ops.server.world.org_generator import generate_org_config
+from pm_ops.server.world.scenario_gen import generate_scenario
+from pm_ops.server.tasks.triage_task import TriageTask
+from pm_ops.server.tasks.incident_routing_task import IncidentRoutingTask
+from pm_ops.server.tasks.release_notes_task import ReleaseNotesTask
+from pm_ops.server.tasks.dep_update_task import DepUpdateTask
+
+MAX_STEPS = 40
+_TASK_TYPES = ["triage", "incident_routing", "release_notes", "dep_update"]
+_DIFFICULTY_POOL = ["easy", "medium", "medium", "hard"]
+_TASK_GRADERS = {
+    "triage": TriageTask(),
+    "incident_routing": IncidentRoutingTask(),
+    "release_notes": ReleaseNotesTask(),
+    "dep_update": DepUpdateTask(),
+}
+
+
+def _oracle_check(scenario: Dict[str, Any]) -> bool:
+    expected = scenario.get("expected", {})
+    if not expected:
+        return False
+    channel = expected.get("channel") or expected.get("channels")
+    team = expected.get("team") or expected.get("teams_to_notify")
+    return bool(channel) and (bool(team) or scenario["type"] == "release_notes")
+
+
+class PMOpsEnvironment:
+    def __init__(self):
+        self._ticketing: Optional[TicketingApp] = None
+        self._codebase: Optional[CodebaseApp] = None
+        self._chat: Optional[ChatApp] = None
+        self._org_config: Optional[Dict[str, Any]] = None
+        self._scenario: Optional[Dict[str, Any]] = None
+        self._step_count: int = 0
+        self._done: bool = False
+
+    def reset(self) -> PMOpsObservation:
+        seed = random.randint(0, 2 ** 31)
+        rng = random.Random(seed)
+        difficulty = rng.choice(_DIFFICULTY_POOL)
+        task_type = rng.choice(_TASK_TYPES)
+
+        for attempt in range(10):
+            org = generate_org_config(seed + attempt, difficulty)
+            scenario = generate_scenario(task_type, org, seed + attempt)
+            if _oracle_check(scenario):
+                break
+
+        channels = list(org["oncall_channels"].values())
+        noise = org.get("noise_channels", [])
+
+        self._org_config = org
+        self._scenario = scenario
+        self._ticketing = TicketingApp(org)
+        self._codebase = CodebaseApp(seed, org["services"])
+        self._chat = ChatApp(channels, noise)
+        self._step_count = 0
+        self._done = False
+
+        return PMOpsObservation(
+            step=0,
+            max_steps=MAX_STEPS,
+            task_brief=scenario["brief"],
+            last_action_result={
+                "ok": True,
+                "data": "Environment ready. Call meta.read_runbook to learn this org's conventions.",
+            },
+            app_state_deltas={"ticketing": [], "chat": [], "codebase": []},
+            steps_remaining=MAX_STEPS,
+            token_budget_remaining=12000,
+            reward=0.0,
+            done=False,
+        )
+
+    def step(self, action: PMOpsAction) -> PMOpsObservation:
+        if self._ticketing is None:
+            raise RuntimeError("Call reset() before step()")
+
+        if self._done:
+            return PMOpsObservation(
+                step=self._step_count,
+                max_steps=MAX_STEPS,
+                task_brief=self._scenario["brief"],
+                last_action_result={"ok": False, "error": "Episode already finished"},
+                app_state_deltas={"ticketing": [], "chat": [], "codebase": []},
+                steps_remaining=0,
+                token_budget_remaining=0,
+                reward=0.0,
+                done=True,
+            )
+
+        self._step_count += 1
+        result = self._dispatch(action)
+
+        done = action.action_type == "meta.finish" or self._step_count >= MAX_STEPS
+        reward = 0.0
+        if done:
+            reward = self._grade()
+            self._done = True
+
+        side_effects = result.get("side_effects", [])
+        deltas = {
+            "ticketing": side_effects if any("ticket" in s for s in side_effects) else [],
+            "chat": side_effects if any("message" in s for s in side_effects) else [],
+            "codebase": [],
+        }
+
+        return PMOpsObservation(
+            step=self._step_count,
+            max_steps=MAX_STEPS,
+            task_brief=self._scenario["brief"],
+            last_action_result=result,
+            app_state_deltas=deltas,
+            steps_remaining=max(0, MAX_STEPS - self._step_count),
+            token_budget_remaining=max(0, 12000 - self._step_count * 300),
+            reward=reward,
+            done=done,
+        )
+
+    def _dispatch(self, action: PMOpsAction) -> Dict[str, Any]:
+        at = action.action_type
+        args = action.args or {}
+
+        if at == "meta.noop":
+            return {"ok": True, "data": "No operation."}
+
+        if at == "meta.read_runbook":
+            return {
+                "ok": True,
+                "data": {
+                    "org_config": copy.deepcopy(self._org_config),
+                    "hint": (
+                        "Use label_taxonomy for valid ticket labels, "
+                        "priority_levels for valid priorities, "
+                        "team_map[service] to find the owning team, "
+                        "oncall_channels[service] to find the channel to notify."
+                    ),
+                },
+            }
+
+        if at == "meta.finish":
+            return {"ok": True, "data": "Episode finishing. Score will be computed."}
+
+        if at.startswith("ticketing."):
+            op = at.split(".", 1)[1]
+            handlers = {
+                "create_ticket":  self._ticketing.create_ticket,
+                "update_ticket":  self._ticketing.update_ticket,
+                "get_ticket":     self._ticketing.get_ticket,
+                "list_tickets":   self._ticketing.list_tickets,
+                "assign_ticket":  self._ticketing.assign_ticket,
+                "comment_ticket": self._ticketing.comment_ticket,
+                "transition_ticket": self._ticketing.transition_ticket,
+            }
+            if op not in handlers:
+                return {"ok": False, "error": f"Unknown ticketing action: {op}"}
+            return handlers[op](args)
+
+        if at.startswith("codebase."):
+            op = at.split(".", 1)[1]
+            handlers = {
+                "list_commits": self._codebase.list_commits,
+                "get_commit":   self._codebase.get_commit,
+                "list_prs":     self._codebase.list_prs,
+            }
+            if op not in handlers:
+                return {"ok": False, "error": f"Unknown codebase action: {op}"}
+            return handlers[op](args)
+
+        if at.startswith("chat."):
+            op = at.split(".", 1)[1]
+            handlers = {
+                "post_message": self._chat.post_message,
+                "read_channel": self._chat.read_channel,
+                "list_channels": self._chat.list_channels,
+                "search":       self._chat.search,
+            }
+            if op not in handlers:
+                return {"ok": False, "error": f"Unknown chat action: {op}"}
+            return handlers[op](args)
+
+        return {"ok": False, "error": f"Unknown action_type: {at}"}
+
+    def _grade(self) -> float:
+        final_state = {
+            "ticketing": self._ticketing.snapshot(),
+            "chat": self._chat.snapshot(),
+        }
+        grader = _TASK_GRADERS.get(self._scenario["type"])
+        if not grader:
+            return 0.0
+        return grader.grade(final_state, self._org_config, self._scenario)

server/tasks/base_task.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class BaseTask(ABC):
+    @abstractmethod
+    def grade(self, final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> float:
+        ...

server/tasks/dep_update_task.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict
+from pm_ops.server.tasks.base_task import BaseTask
+
+
+class DepUpdateTask(BaseTask):
+    def grade(self, final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> float:
+        score = 0.0
+        expected = scenario["expected"]
+
+        msgs = final_state["chat"]["messages_posted_this_episode"]
+        tickets = final_state["ticketing"]["tickets"]
+        new_tickets = [t for t in tickets if t.get("created_this_episode")]
+
+        expected_channels = set(expected.get("channels", []))
+        expected_teams = set(expected.get("teams_to_notify", []))
+
+        notified = {m.get("channel") for m in msgs}
+        correct_notified = notified & expected_channels
+        wrong_notified = notified - expected_channels
+
+        if correct_notified:
+            score += 0.25 * (len(correct_notified) / max(len(expected_channels), 1))
+
+        assigned_teams = {t.get("assigned_team") for t in new_tickets if t.get("assigned_team")}
+        correct_teams = assigned_teams & expected_teams
+        if correct_teams:
+            score += 0.25 * (len(correct_teams) / max(len(expected_teams), 1))
+
+        if new_tickets:
+            score += 0.25
+
+        policy = expected.get("escalation_policy", "post-channel")
+        if policy == "post-channel" and correct_notified:
+            score += 0.25
+        elif policy in ("dm-manager", "page-oncall") and msgs:
+            score += 0.25
+
+        score -= 0.05 * len(wrong_notified)
+
+        return max(0.0, min(1.0, score))

server/tasks/incident_routing_task.py

@@ -0,0 +1,33 @@
+from typing import Any, Dict
+from pm_ops.server.tasks.base_task import BaseTask
+
+
+class IncidentRoutingTask(BaseTask):
+    def grade(self, final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> float:
+        score = 0.0
+        expected = scenario["expected"]
+
+        msgs = final_state["chat"]["messages_posted_this_episode"]
+        tickets = final_state["ticketing"]["tickets"]
+        new_tickets = [t for t in tickets if t.get("created_this_episode")]
+
+        correct_msgs = [m for m in msgs if m.get("channel") == expected.get("channel")]
+        wrong_msgs = [m for m in msgs if m.get("channel") != expected.get("channel")]
+
+        if correct_msgs:
+            score += 0.30
+
+        if new_tickets:
+            t = new_tickets[0]
+            if t.get("label") == expected.get("label"):
+                score += 0.20
+            if t.get("priority") == expected.get("priority"):
+                score += 0.20
+            if t.get("assigned_team") == expected.get("team"):
+                score += 0.15
+            if t.get("linked_pr"):
+                score += 0.05
+
+        score -= 0.15 * len(wrong_msgs)
+
+        return max(0.0, min(1.0, score))

server/tasks/release_notes_task.py

@@ -0,0 +1,42 @@
+from typing import Any, Dict
+from pm_ops.server.tasks.base_task import BaseTask
+
+
+class ReleaseNotesTask(BaseTask):
+    def grade(self, final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> float:
+        score = 0.0
+        expected = scenario["expected"]
+
+        tickets = final_state["ticketing"]["tickets"]
+        closed = [t for t in tickets if t.get("status") == "closed"]
+
+        msgs = final_state["chat"]["messages_posted_this_episode"]
+        correct_msgs = [m for m in msgs if m.get("channel") == expected.get("channel")]
+        wrong_msgs = [m for m in msgs if m.get("channel") != expected.get("channel")]
+
+        if not correct_msgs:
+            score -= 0.10 * len(wrong_msgs)
+            return max(0.0, score)
+
+        msg_text = correct_msgs[0].get("text", "")
+        score += 0.30
+
+        style = expected.get("style", "terse")
+        if style == "bulleted" and ("-" in msg_text or "*" in msg_text):
+            score += 0.20
+        elif style == "terse" and len(msg_text) < 500:
+            score += 0.20
+        elif style == "verbose" and len(msg_text) >= 200:
+            score += 0.20
+
+        min_tickets = expected.get("min_tickets", 2)
+        referenced = sum(1 for t in closed if t["id"] in msg_text)
+        if referenced >= min_tickets:
+            score += 0.30
+        elif referenced > 0:
+            score += 0.15
+
+        score += 0.20 if not wrong_msgs else 0.0
+        score -= 0.10 * len(wrong_msgs)
+
+        return max(0.0, min(1.0, score))

server/tasks/triage_task.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict
+from pm_ops.server.tasks.base_task import BaseTask
+
+
+class TriageTask(BaseTask):
+    def grade(self, final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> float:
+        score = 0.0
+        expected = scenario["expected"]
+
+        tickets = final_state["ticketing"]["tickets"]
+        new_tickets = [t for t in tickets if t.get("created_this_episode")]
+
+        if not new_tickets:
+            return 0.0
+
+        score -= 0.10 * max(0, len(new_tickets) - 1)  # duplicate penalty
+
+        t = new_tickets[0]
+        score += 0.25  # ticket exists
+
+        if t.get("label") == expected.get("label"):
+            score += 0.20
+        if t.get("priority") == expected.get("priority"):
+            score += 0.20
+        if t.get("assigned_team") == expected.get("team"):
+            score += 0.20
+
+        msgs = final_state["chat"]["messages_posted_this_episode"]
+        correct_msgs = [m for m in msgs if m.get("channel") == expected.get("channel")]
+        wrong_msgs = [m for m in msgs if m.get("channel") != expected.get("channel")]
+
+        if correct_msgs:
+            score += 0.10
+            if len(correct_msgs[0].get("text", "")) >= 20:
+                score += 0.05
+
+        score -= 0.05 * len(wrong_msgs)
+
+        return max(0.0, min(1.0, score))

server/verifiers/state_verifier.py

@@ -0,0 +1,23 @@
+"""Deterministic state verifier — no LLM-as-judge."""
+from typing import Any, Dict
+
+from pm_ops.server.tasks.triage_task import TriageTask
+from pm_ops.server.tasks.incident_routing_task import IncidentRoutingTask
+from pm_ops.server.tasks.release_notes_task import ReleaseNotesTask
+from pm_ops.server.tasks.dep_update_task import DepUpdateTask
+
+_GRADERS = {
+    "triage": TriageTask(),
+    "incident_routing": IncidentRoutingTask(),
+    "release_notes": ReleaseNotesTask(),
+    "dep_update": DepUpdateTask(),
+}
+
+
+def verify(final_state: Dict[str, Any], org_config: Dict[str, Any], scenario: Dict[str, Any]) -> Dict[str, Any]:
+    task_type = scenario.get("type", "")
+    grader = _GRADERS.get(task_type)
+    if not grader:
+        return {"score": 0.0, "error": f"Unknown task type: {task_type}"}
+    score = grader.grade(final_state, org_config, scenario)
+    return {"score": score, "task_type": task_type}

server/world/org_generator.py

@@ -0,0 +1,76 @@
+import random
+from typing import Any, Dict, List
+
+_LABEL_VARIANTS = {
+    "bug":         ["bug", "defect", "issue", "fault"],
+    "feature":     ["feature", "enhancement", "request", "improvement"],
+    "docs":        ["docs", "documentation", "doc-update", "guide"],
+    "security":    ["security", "vuln", "vulnerability", "sec-issue"],
+    "performance": ["perf", "performance", "slowness", "optimization"],
+}
+
+_PRIORITY_SCHEMES = [
+    ["P0", "P1", "P2", "P3"],
+    ["critical", "high", "medium", "low"],
+    ["urgent", "high", "normal", "low"],
+    ["blocker", "major", "minor", "trivial"],
+]
+
+_SERVICES = ["payments", "auth", "search", "notifications", "api-gateway", "checkout", "inventory"]
+_TEAM_POOL = ["platform", "growth", "infra", "security", "backend", "frontend", "data"]
+_CHANNEL_SUFFIXES = ["-alerts", "-oncall", "-ops", "-team", "-eng"]
+_NOISE_CHANNELS = ["#random", "#general", "#water-cooler", "#announcements", "#off-topic", "#hiring"]
+_ESCALATION_POLICIES = ["dm-manager", "page-oncall", "post-channel"]
+_RELEASE_STYLES = ["terse", "verbose", "bulleted"]
+
+
+def generate_org_config(seed: int, difficulty: str = "medium") -> Dict[str, Any]:
+    rng = random.Random(seed)
+
+    n_labels = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
+    label_keys = rng.sample(list(_LABEL_VARIANTS.keys()), n_labels)
+    label_taxonomy = {k: rng.choice(_LABEL_VARIANTS[k]) for k in label_keys}
+
+    priority_levels: List[str] = rng.choice(_PRIORITY_SCHEMES)
+    severity_to_priority = {
+        "critical": priority_levels[0],
+        "high":     priority_levels[1] if len(priority_levels) > 1 else priority_levels[0],
+        "medium":   priority_levels[2] if len(priority_levels) > 2 else priority_levels[-1],
+        "low":      priority_levels[-1],
+    }
+
+    n_services = {"easy": 2, "medium": 3, "hard": 5}.get(difficulty, 3)
+    services = rng.sample(_SERVICES, min(n_services, len(_SERVICES)))
+    teams = rng.sample(_TEAM_POOL, min(len(services), len(_TEAM_POOL)))
+
+    team_map: Dict[str, str] = {svc: teams[i % len(teams)] for i, svc in enumerate(services)}
+
+    oncall_channels: Dict[str, str] = {}
+    for svc in services:
+        team = team_map[svc]
+        suffix = rng.choice(_CHANNEL_SUFFIXES)
+        oncall_channels[svc] = f"#{team}{suffix}"
+
+    escalation_policy: str = rng.choice(_ESCALATION_POLICIES)
+    release_notes_style: str = rng.choice(_RELEASE_STYLES)
+
+    all_fields = ["summary", "description", "priority", "label", "assignee"]
+    n_required = {"easy": 2, "medium": 3, "hard": 4}.get(difficulty, 3)
+    required_ticket_fields = ["summary"] + rng.sample(all_fields[1:], min(n_required - 1, len(all_fields) - 1))
+
+    n_noise = {"easy": 1, "medium": 2, "hard": 3}.get(difficulty, 2)
+    noise_channels = rng.sample(_NOISE_CHANNELS, min(n_noise, len(_NOISE_CHANNELS)))
+
+    return {
+        "label_taxonomy":        label_taxonomy,
+        "priority_levels":       priority_levels,
+        "severity_to_priority":  severity_to_priority,
+        "team_map":              team_map,
+        "oncall_channels":       oncall_channels,
+        "escalation_policy":     escalation_policy,
+        "release_notes_style":   release_notes_style,
+        "required_ticket_fields": required_ticket_fields,
+        "noise_channels":        noise_channels,
+        "services":              services,
+        "teams":                 teams,
+    }

server/world/scenario_gen.py

@@ -0,0 +1,98 @@
+import random
+from typing import Any, Dict
+
+_TRIAGE_BRIEFS = [
+    "A user reported that the {service} is returning 500 errors. The issue started 20 minutes ago. Triage this bug: file a ticket with the correct label and priority, assign it to the right team, and notify the correct oncall channel.",
+    "Support escalation: {service} is intermittently failing for EU users. Triage and route per org process.",
+    "Monitoring alert: elevated error rate on {service}. File a bug ticket and page the right team.",
+]
+
+_INCIDENT_BRIEFS = [
+    "ALERT: {service} is completely down. This is a {severity_name} incident. Identify the owning team from recent commits and route immediately.",
+    "Production incident: {service} spiking to 100% CPU. Escalate properly -- create a ticket and page the oncall channel.",
+    "Critical alert: {service} health check failing. Identify the right team via the codebase and notify them.",
+]
+
+_RELEASE_NOTES_BRIEFS = [
+    "Prepare release notes for this sprint's closed tickets. Use the org's standard format and post them to the right channel.",
+    "Write and publish the weekly release notes for all resolved tickets. Follow the org's release_notes_style.",
+]
+
+_DEP_UPDATE_BRIEFS = [
+    "Security advisory: the `requests` library has a CVE. Find all services that depend on it and notify their owning teams per the org's escalation policy.",
+    "Dependency update needed: `pydantic` v2 breaking changes affect multiple services. Coordinate the update across all owning teams.",
+]
+
+
+def generate_scenario(task_type: str, org_config: Dict[str, Any], seed: int) -> Dict[str, Any]:
+    rng = random.Random(seed + 42)
+    services = org_config["services"]
+    team_map = org_config["team_map"]
+    oncall_channels = org_config["oncall_channels"]
+    priority_levels = org_config["priority_levels"]
+    label_taxonomy = org_config["label_taxonomy"]
+
+    if task_type == "triage":
+        service = rng.choice(services)
+        label_key = "bug" if "bug" in label_taxonomy else list(label_taxonomy.keys())[0]
+        label = label_taxonomy[label_key]
+        priority = priority_levels[1] if len(priority_levels) > 1 else priority_levels[0]
+        brief = rng.choice(_TRIAGE_BRIEFS).format(service=service)
+        return {
+            "type": "triage",
+            "brief": brief,
+            "service": service,
+            "expected": {
+                "label": label,
+                "priority": priority,
+                "team": team_map[service],
+                "channel": oncall_channels[service],
+            },
+        }
+
+    elif task_type == "incident_routing":
+        service = rng.choice(services)
+        priority = priority_levels[0]
+        severity_name = org_config["severity_to_priority"].get("critical", priority)
+        brief = rng.choice(_INCIDENT_BRIEFS).format(service=service, severity_name=severity_name)
+        label_key = "bug" if "bug" in label_taxonomy else list(label_taxonomy.keys())[0]
+        return {
+            "type": "incident_routing",
+            "brief": brief,
+            "service": service,
+            "expected": {
+                "label": label_taxonomy[label_key],
+                "priority": priority,
+                "team": team_map[service],
+                "channel": oncall_channels[service],
+            },
+        }
+
+    elif task_type == "release_notes":
+        brief = rng.choice(_RELEASE_NOTES_BRIEFS)
+        channel = rng.choice(list(oncall_channels.values()))
+        return {
+            "type": "release_notes",
+            "brief": brief,
+            "expected": {
+                "style": org_config["release_notes_style"],
+                "channel": channel,
+                "min_tickets": 2,
+            },
+        }
+
+    elif task_type == "dep_update":
+        affected = rng.sample(services, min(2, len(services)))
+        brief = rng.choice(_DEP_UPDATE_BRIEFS)
+        return {
+            "type": "dep_update",
+            "brief": brief,
+            "affected_services": affected,
+            "expected": {
+                "teams_to_notify": [team_map[s] for s in affected],
+                "channels": [oncall_channels[s] for s in affected],
+                "escalation_policy": org_config["escalation_policy"],
+            },
+        }
+
+    raise ValueError(f"Unknown task type: {task_type}")