fix: add activity gate to graders, expand README, improve inference

- Add activity gate to medium/hard/expert graders so do-nothing policies
score 0.0 instead of getting free points from "no harm" dimensions
- Expand README with research foundation (5 papers), 22 capabilities
matrix, grader design section, and activity gate documentation
- Improve inference system prompt with structured decision procedure,
permanent failure awareness, and parallelism emphasis
- Increase HISTORY_WINDOW from 4 to 6 for better expert task context
- Add retry logic for transient LLM API failures
- Add 7 degenerate policy tests proving grader calibration
- Add 12 expert task walkthrough tests (0.948 grader score)
- Update baseline scores from fresh inference run
- Add debug_*.py to .gitignore

Tests: 160 passing (was 139)

.gitignore

@@ -40,3 +40,6 @@ htmlcov/
 # Distribution
 *.whl
 *.tar.gz
+
+# Debug scripts
+debug_*.py

README.md

@@ -17,7 +17,65 @@ An OpenEnv environment where an LLM agent acts as a **project coordinator**, man
 
 ## Motivation
 
-Agent orchestration is the #1 enterprise AI trend — yet LLMs are terrible at it. Research documents 14+ failure modes in multi-agent systems (MAST taxonomy), up to 17x error amplification in unstructured networks (Spark to Fire), and only 25% baseline correctness with GPT-4o (ChatDev). This environment provides a controlled, deterministic testbed for training and evaluating LLM orchestration capabilities across three real-world scenarios: software development, CI/CD deployment, and production incident response.
+Agent orchestration is the #1 enterprise AI trend — yet LLMs are terrible at it. Research documents 14+ failure modes in multi-agent systems (MAST taxonomy), up to 17x error amplification in unstructured networks (Spark to Fire), and only 25% baseline correctness with GPT-4o (ChatDev). This environment provides a controlled, deterministic testbed for training and evaluating LLM orchestration capabilities across four real-world scenarios forming a narrative arc: **build** a feature (Easy), **ship** it (Medium), **fix** the outage (Hard), and **orchestrate** your day (Expert).
+
+**Novel domain:** Zero orchestration environments exist in OpenEnv today. This fills the biggest gap in the ecosystem — coordination, delegation, parallelism, failure recovery, and cost management are untested by any existing environment.
+
+## Research Foundation
+
+This environment is grounded in 5 recent research papers:
+
+| Paper | Key Finding | How It Shaped Our Design |
+|-------|-------------|--------------------------|
+| **MAST Taxonomy** ([arxiv 2503.13657](https://arxiv.org/abs/2503.13657)) | 14 failure modes across 150+ multi-agent traces; GPT-4o achieves only 25% on ChatDev | Our tasks test 8 of 14 MAST failure modes (spec violation, role violation, step repetition, info withholding, premature termination, incomplete verification) |
+| **Spark to Fire** ([arxiv 2603.04474](https://arxiv.org/abs/2603.04474)) | 17.2x error amplification in unstructured agent networks; hub injection → 100% infection | Hard task DAG topology creates realistic cascade potential; failure recovery rewards incentivize early intervention |
+| **AgentErrorBench** ([arxiv 2509.25370](https://arxiv.org/abs/2509.25370)) | Targeted RL feedback improves error recovery by up to 26% across 5 failure categories | Dense per-step rewards target each error category; permanent vs. transient failure classification forces root-cause reasoning |
+| **MARBLE / MultiAgentBench** ([ACL 2025](https://aclanthology.org/2025.acl-long.421/)) | 3-agent teams optimize coordination-performance balance; excessive iterations degrade coordination | Capacity limit of 3 concurrent tasks; milestone-based grading; DAG-based task structure |
+| **DAAO** ([arxiv 2509.11079](https://arxiv.org/html/2509.11079v1)) | Task difficulty should dynamically determine orchestration strategy; 11% accuracy improvement | Our 4 tasks require fundamentally different strategies, not just more nodes |
+
+## Capabilities Tested (22 Total)
+
+Each difficulty level introduces **qualitatively different reasoning**, not just more nodes:
+
+| # | Capability | Easy | Med | Hard | Expert | What It Tests |
+|---|---|:---:|:---:|:---:|:---:|---|
+| 1 | Dependency comprehension | ✓ | ✓ | ✓ | ✓ | Read DAG, understand what blocks what |
+| 2 | Correct delegation | ✓ | ✓ | ✓ | ✓ | Match subtask type → agent capability |
+| 3 | Sequential ordering | ✓ | ✓ | ✓ | ✓ | Don't delegate before prerequisites complete |
+| 4 | Wait discipline | ✓ | ✓ | ✓ | ✓ | Wait when nothing is delegatable |
+| 5 | Output synthesis | ✓ | ✓ | ✓ | ✓ | Combine outputs into final deliverable |
+| 6 | Parallelism detection | | ✓ | ✓ | ✓ | Run independent subtasks concurrently |
+| 7 | Failure recovery | | ✓ | ✓ | ✓ | Retry after agent failure |
+| 8 | Capacity management | | ✓ | ✓ | ✓ | Stay within max concurrent task limit |
+| 9 | Time pressure planning | | ✓ | ✓ | ✓ | Must parallelize to meet deadline |
+| 10 | Cost awareness | | ✓ | ✓ | ✓ | Don't blindly retry expensive agents |
+| 11 | Agent selection under overlap | | | ✓ | ✓ | Multiple agents for same task — pick best |
+| 12 | Adaptation to agent dropout | | | ✓ | ✓ | Re-plan when agent goes offline |
+| 13 | Conflicting info aggregation | | | ✓ | ✓ | Two tracks produce different findings |
+| 14 | SLA milestone awareness | | | ✓ | ✓ | Hit deadlines or face escalating penalties |
+| 15 | Patience under pressure | | | ✓ | | Wait for monitoring — resist premature synthesis |
+| 16 | Priority reasoning | | | ✓ | ✓ | Side-channel tasks mustn't block critical path |
+| 17 | Error classification | | | ✓ | ✓ | Distinguish permanent vs. transient failure |
+| 18 | Multi-objective optimization | | | | ✓ | Balance competing pillar scores |
+| 19 | Cross-domain conflict resolution | | | | ✓ | Reconcile health vs career vs personal |
+| 20 | Agent cost-benefit analysis | | | ✓ | ✓ | When is the cheap agent actually more expensive? |
+| 21 | Cascading delay awareness | | | | ✓ | Speed degradation means earlier delegation = critical |
+| 22 | Multi-conflict episodes | | | | ✓ | Two distinct conflict resolution points |
+
+**Difficulty progression:** Easy = DAG comprehension (1-5). Medium = parallelism + recovery + budgets (6-10). Hard = chaos adaptation + error classification (11-17). Expert = multi-objective optimization across life domains (18-22).
+
+## Grader Design
+
+Each task has a multi-dimensional grader returning a score in [0.0, 1.0] with a detailed breakdown. Graders analyze the **episode event log** (process matters, not just outcome) and are fully **deterministic** — same actions = same score.
+
+| Task | Dimensions | Key Metrics |
+|------|-----------|-------------|
+| Easy | 4 | completion (85%), parallelism bonus (10%), episode complete (5%), invalid penalty |
+| Medium | 6 | completion (40%), parallelism (20%), failure recovery (20%), time efficiency (10%), cost efficiency (10%) |
+| Hard | 10 | completion (20%), recovery (15%), error classification (10%), capacity (10%), parallelism (10%), cost (10%), conflict resolution (10%), SLA compliance (10%), monitoring patience (5%) |
+| Expert | 10 | completion (15%), health pillar (12%), career pillar (10%), conflict resolution (20%), cost (8%), parallelism (10%), time (5%), error classification (8%), SLA (8%), communication (4%) |
+
+**Activity-gated scoring:** Dimensions that reward "no harm" (error classification, capacity discipline, cost efficiency) scale with actual activity via `min(1.0, completed / threshold)`. A do-nothing policy scores 0.0, not free points.
 
 ## Action Space
 
@@ -101,12 +159,16 @@ End-of-episode: +0.20 (all complete + synthesized), +0.10 * time_efficiency, +0.
 
 ## Baseline Scores
 
-| Task | Score | Model |
-|------|-------|-------|
-| Easy | 0.900 | Qwen/Qwen3-32B |
-| Medium | 0.633 | Qwen/Qwen3-32B |
-| Hard | 0.808 | Qwen/Qwen3-32B |
-| Expert | 0.802 | Qwen/Qwen3-32B |
+Scores from running the baseline inference script with Qwen3-32B via OpenRouter:
+
+| Task | Score | Subtasks | Key Challenge |
+|------|-------|----------|---------------|
+| Easy | 0.900 | 6/6 | DAG comprehension + optional parallelism |
+| Medium | 0.626 | 9/9 | 3-way fan-out + security scan failure recovery |
+| Hard | 0.724 | 10/10 | Permanent failure trap + agent dropout + SLA pressure |
+| Expert | 0.747 | 14/14 | Multi-objective optimization + 2 permanent failure traps |
+
+Scores reflect the LLM's orchestration ability: easy tasks are near-perfect, while medium/hard/expert require parallelism planning, failure recovery, and cost optimization that challenge even frontier models.
 
 ## Setup
 
@@ -169,7 +231,7 @@ workflow_orchestrator/
 │   ├── agent_pool.py         # Simulated agent state machines
 │   ├── reward_calculator.py  # Dense reward computation
 │   ├── graders.py            # Per-task grading functions
-│   ├── task_registry.py      # Easy/medium/hard task configurations
+│   ├── task_registry.py      # Easy/medium/hard/expert task configurations
 │   └── observation_formatter.py  # Text rendering for LLM consumption
-└── tests/                    # 137 passing tests
+└── tests/                    # 160+ passing tests
 ```

baseline_scores.json

@@ -1 +1 @@
-{"easy": 0.9, "medium": 0.6325, "hard": 0.6625, "expert": 0.7467}
+{"easy": 0.9, "medium": 0.6263, "hard": 0.7239, "expert": 0.7467}

inference.py

@@ -45,7 +45,7 @@ MAX_TOKENS: int = 4096  # High ceiling for verbose models; concise models just u
 MAX_STEPS: int = 50
 SUCCESS_SCORE_THRESHOLD: float = 0.1
 TASK_TIMEOUT_S: int = 600  # 10 min per task; total 4 tasks fits in 20 min hackathon limit
-HISTORY_WINDOW: int = 4  # Last 4 turns — enough for context without bloating input tokens
+HISTORY_WINDOW: int = 6  # Last 6 turns — expert task needs longer context to avoid repeating mistakes
 
 VALID_ACTIONS: set[str] = {"delegate", "retry", "wait", "synthesize", "abort"}
 
@@ -63,15 +63,21 @@ ACTIONS (as JSON):
 {"action_type": "synthesize"}
 {"action_type": "abort", "subtask_id": "<id>"}
 
-RULES:
-1. delegate: Assign a READY subtask to an IDLE agent whose capabilities include the subtask type.
-2. retry: Re-assign a FAILED subtask. If error says "permanent failure" or "lacks required tooling", you MUST pick a DIFFERENT agent.
-3. wait: ONLY use when no READY subtasks exist OR all capable agents are busy.
-4. synthesize: ONLY when ALL subtasks are COMPLETED.
-5. NEVER wait when READY subtasks and idle capable agents exist — delegate instead.
-6. Maximize parallelism: delegate multiple ready subtasks across steps before waiting.
-7. Prefer cheaper agents (lower cost_per_step) when multiple can handle the same task type.
-8. After a fix is validated, wait 2 steps to monitor stability before synthesizing.
+DECISION PROCEDURE (follow this exact order):
+1. If ALL subtasks are COMPLETED → synthesize immediately (unless you need monitoring waits).
+2. If any subtask is FAILED → retry it NOW with a capable IDLE agent.
+   CRITICAL: If error says "permanent failure" or "lacks required tooling", the SAME agent will ALWAYS fail. You MUST pick a DIFFERENT agent with the same capability. Never retry the same agent on a permanent failure.
+3. If any subtask is READY and a capable IDLE agent exists → delegate it.
+   - When MULTIPLE subtasks are READY, delegate them ALL across consecutive steps before waiting.
+   - Prefer cheaper agents (lower cost_per_step) when multiple agents can do the same task.
+4. ONLY wait when no subtasks are READY or all capable agents are busy working.
+5. After validate_fix completes, wait 2 steps for monitoring before synthesizing.
+
+KEY PRINCIPLES:
+- MAXIMIZE PARALLELISM: If 3 subtasks are ready and 3 agents are idle, delegate all 3 in 3 consecutive steps.
+- NEVER wait when there is a READY subtask and an IDLE capable agent — this wastes a step.
+- Check the HINT line — it tells you what to do next.
+- Match subtask TYPE to agent CAPABILITIES (not just any agent).
 
 Respond with a single JSON object. Nothing else."""
 
@@ -259,19 +265,24 @@ def parse_llm_action(response_text: str) -> Dict[str, Any]:
 
 
 def _call_llm(messages: List[Dict[str, str]]) -> str:
-    """Synchronous LLM call — designed to be run via asyncio.to_thread()."""
-    try:
-        completion = llm.chat.completions.create(
-            model=MODEL_NAME,
-            messages=messages,
-            temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-            stream=False,
-        )
-        return completion.choices[0].message.content or ""
-    except Exception as exc:
-        print(f"[DEBUG] LLM call failed: {exc}", flush=True)
-        return ""
+    """Synchronous LLM call with retry — designed to be run via asyncio.to_thread()."""
+    import time
+
+    for attempt in range(2):
+        try:
+            completion = llm.chat.completions.create(
+                model=MODEL_NAME,
+                messages=messages,
+                temperature=TEMPERATURE,
+                max_tokens=MAX_TOKENS,
+                stream=False,
+            )
+            return completion.choices[0].message.content or ""
+        except Exception as exc:
+            print(f"[DEBUG] LLM call failed (attempt {attempt + 1}): {exc}", flush=True)
+            if attempt == 0:
+                time.sleep(2)
+    return ""
 
 
 # ── Task runner ──

server/graders.py

@@ -203,6 +203,10 @@ def grade_medium(log: EpisodeLog) -> GradeResult:
     completed = count_completed_subtasks(log)
     completion = (completed / 9) * 0.40
 
+    # Activity gate: cost efficiency should scale with actual activity.
+    # Reaching 3+ completions (33% of subtasks) earns full credit.
+    activity = min(1.0, completed / 3)
+
     parallelism = 0.20 if fan_out_parallelism_detected(
         log, ["run_linter", "run_unit_tests", "run_security_scan"]
     ) else 0.0
@@ -217,7 +221,7 @@ def grade_medium(log: EpisodeLog) -> GradeResult:
     budget_total = get_total_budget(log)
     cost_eff = 0.0
     if budget_total and budget_total > 0:
-        cost_eff = 0.10 * max(0.0, 1.0 - budget_used / budget_total)
+        cost_eff = 0.10 * max(0.0, 1.0 - budget_used / budget_total) * activity
 
     invalid_count = count_invalid_actions(log)
     penalty = min(0.10, invalid_count * 0.03)
@@ -247,6 +251,12 @@ def grade_hard(log: EpisodeLog) -> GradeResult:
     completed = count_completed_subtasks(log)
     completion = (completed / 10) * 0.20
 
+    # Activity gate: dimensions that reward "no harm" (error classification,
+    # capacity discipline, cost efficiency) should scale with actual activity.
+    # A do-nothing policy (0 completions) gets 0 on these dimensions.
+    # Reaching 3+ completions (30% of subtasks) earns full credit.
+    activity = min(1.0, completed / 3)
+
     # Recovery: 0.15 split across two designed failure scenarios
     # - enrich_logs: investigator_alpha permanently fails (must use different agent)
     # - deploy_hotfix: deployer goes offline at step 12 (must use senior_engineer)
@@ -258,9 +268,9 @@ def grade_hard(log: EpisodeLog) -> GradeResult:
     recovery = 0.15 * (recovery_count / 2) if recovery_count > 0 else 0.0
 
     perm_retries = count_retries_on_permanent_failure(log)
-    error_class = 0.10 * max(0.0, 1.0 - 0.5 * perm_retries)
+    error_class = 0.10 * max(0.0, 1.0 - 0.5 * perm_retries) * activity
 
-    capacity = 0.10 if zero_capacity_violations(log) else 0.0
+    capacity = (0.10 if zero_capacity_violations(log) else 0.0) * activity
 
     parallelism = 0.10 * compute_parallel_efficiency(log)
 
@@ -268,7 +278,7 @@ def grade_hard(log: EpisodeLog) -> GradeResult:
     budget_total = get_total_budget(log)
     cost_eff = 0.0
     if budget_total and budget_total > 0:
-        cost_eff = 0.10 * max(0.0, 1.0 - budget_used / budget_total)
+        cost_eff = 0.10 * max(0.0, 1.0 - budget_used / budget_total) * activity
 
     conflict = 0.10 if both_findings_aggregated(log) else 0.0
 
@@ -382,6 +392,10 @@ def grade_expert(log: EpisodeLog) -> GradeResult:
     completed = count_completed_subtasks(log)
     breakdown["completion"] = (completed / 14) * 0.15
 
+    # Activity gate: "no harm" dimensions scale with actual activity.
+    # Reaching 4+ completions (29% of subtasks) earns full credit.
+    activity = min(1.0, completed / 4)
+
     # 2. Health pillar: 12%
     health_score = 0.0
     if subtask_completed_check(log, "assess_sleep_energy"):
@@ -412,13 +426,13 @@ def grade_expert(log: EpisodeLog) -> GradeResult:
         conflict_score += 0.3
     breakdown["conflict_resolution"] = conflict_score * 0.20
 
-    # 5. Cost efficiency: 8%
+    # 5. Cost efficiency: 8% (gated by activity)
     budget_used = get_total_budget_used(log)
     cost_ratio = budget_used / 55.0 if 55.0 > 0 else 0
     if cost_ratio <= 0.75:
-        breakdown["cost_efficiency"] = 0.08
+        breakdown["cost_efficiency"] = 0.08 * activity
     elif cost_ratio <= 1.0:
-        breakdown["cost_efficiency"] = (1.0 - cost_ratio) / 0.25 * 0.08
+        breakdown["cost_efficiency"] = (1.0 - cost_ratio) / 0.25 * 0.08 * activity
     else:
         breakdown["cost_efficiency"] = 0.0
 
@@ -441,9 +455,9 @@ def grade_expert(log: EpisodeLog) -> GradeResult:
     else:
         breakdown["time_efficiency"] = 0.0
 
-    # 8. Error classification: 8%
+    # 8. Error classification: 8% (gated by activity)
     perm_retries = count_retries_on_permanent_failure(log)
-    breakdown["error_classification"] = max(0.0, 1.0 - 0.5 * perm_retries) * 0.08
+    breakdown["error_classification"] = max(0.0, 1.0 - 0.5 * perm_retries) * 0.08 * activity
 
     # 9. SLA compliance: 8%
     sla_milestones = {"plan_day_schedule": 8, "resolve_priority_conflict": 16, "synthesize_day_report": 23}

tests/test_environment.py

@@ -479,9 +479,10 @@ class TestHardTaskEdgeCases:
             _wait(env)
         log = _episode_store["hard"]
         result = grade_hard(log)
-        # Even doing nothing scores 0.3: error_classification(0.1) +
-        # capacity_discipline(0.1) + cost_efficiency(0.1) from "no harm done"
-        assert result.score <= 0.35
+        # With activity gate, doing nothing scores 0.0: "no harm" dimensions
+        # (error_classification, capacity_discipline, cost_efficiency) are
+        # gated by min(1.0, completed/3) which is 0.0 when nothing is completed.
+        assert result.score <= 0.05
         assert result.breakdown["completion"] == 0.0
         assert result.breakdown["recovery"] == 0.0
         assert result.breakdown["sla_compliance"] == 0.0
@@ -500,3 +501,244 @@ class TestHardTaskEdgeCases:
         assert state.subtask_statuses["root_cause_analysis"] != "completed"
         # Total reward should be negative due to SLA + unnecessary_wait penalties
         assert env._total_reward < 0
+
+
+# ── Expert task walkthrough ──
+
+
+class TestExpertTaskWalkthrough:
+    """Full walkthrough of the expert task (Life OS Daily Orchestration).
+
+    The 18-step sequence was verified against the seeded RNG (seed=45) to
+    produce deterministic outcomes. It completes all 14 subtasks, achieves
+    full parallelism across all 3 fan-out points, meets all 3 SLA milestones,
+    avoids permanent failure traps, and routes around the personal_agent
+    dropout at step 10.
+
+    Grader score: 0.948 (8/10 dimensions at 100%).
+    """
+
+    def _run_known_good_sequence(self):
+        """Execute the known-good 18-step expert task walkthrough.
+
+        Returns (env, final_obs) so callers can make assertions.
+
+        Step-by-step plan:
+        - S0: morning_check_in -> personal_agent (speed=1, completes immediately)
+        - S1: assess_career_deadlines -> career_agent (speed=2, stays in_progress)
+        - S2: assess_sleep_energy -> health_agent (speed=1)
+              PARALLELISM: [assess_career_deadlines, assess_sleep_energy]
+              Both complete; career_agent finishes career_deadlines
+        - S3: assess_personal_commitments -> personal_agent (speed=1, completes)
+              All 3 assessments done -> plan_day_schedule ready
+        - S4: plan_day_schedule -> companion (speed=2, stays in_progress)
+        - S5: wait (companion completes plan_day_schedule at step 5; SLA met)
+        - S6: process_inbox -> executive_assistant (speed=2, stays in_progress)
+        - S7: start_focus_session -> focus_agent (speed=1)
+              PARALLELISM: [process_inbox, start_focus_session]
+              Both complete; career_agent degrades (speed 2->4) this step
+        - S8: deep_work_block -> companion (speed=2, stays in_progress)
+        - S9: handle_urgent_request -> executive_assistant (speed=2)
+              PARALLELISM: [deep_work_block, handle_urgent_request]
+              companion completes deep_work_block; exec_asst still working
+        - S10: midday_health_check -> health_agent (speed=1)
+               PARALLELISM: [handle_urgent_request, midday_health_check]
+               Both complete; personal_agent drops out (idle, no impact)
+               -> resolve_priority_conflict ready
+        - S11: resolve_priority_conflict -> companion (speed=2, stays in_progress)
+        - S12: wait (companion completes; SLA met at step 12 < 16)
+        - S13: afternoon_execution -> companion (speed=2, stays in_progress)
+        - S14: notify_stakeholders -> mail_agent (speed=1, FAILS: roll > reliability)
+               PARALLELISM: [afternoon_execution, notify_stakeholders]
+               companion completes afternoon_execution; mail_agent fails
+        - S15: retry notify_stakeholders -> mail_agent (attempt=1, succeeds)
+        - S16: synthesize_day_report -> mail_agent (speed=1, completes)
+               SLA met at step 16 < 23
+        - S17: synthesize (all 14 done, episode ends with bonus)
+        """
+        env, obs = _make_env("expert")
+
+        # Phase 1: Morning check-in
+        _delegate(env, "morning_check_in", "personal_agent")
+
+        # Phase 2: Three assessments with parallelism
+        _delegate(env, "assess_career_deadlines", "career_agent")
+        _delegate(env, "assess_sleep_energy", "health_agent")
+        _delegate(env, "assess_personal_commitments", "personal_agent")
+
+        # Phase 3: Plan day schedule (companion only viable first-attempt agent)
+        _delegate(env, "plan_day_schedule", "companion")
+        _wait(env)
+
+        # Phase 4: Focus + Inbox with parallelism
+        _delegate(env, "process_inbox", "executive_assistant")
+        _delegate(env, "start_focus_session", "focus_agent")
+
+        # Phase 5: Deep work + Urgent request with parallelism
+        _delegate(env, "deep_work_block", "companion")
+        _delegate(env, "handle_urgent_request", "executive_assistant")
+
+        # Phase 6: Midday health check (avoid wellness_monitor!)
+        _delegate(env, "midday_health_check", "health_agent")
+
+        # Phase 7: Conflict resolution (only companion viable)
+        _delegate(env, "resolve_priority_conflict", "companion")
+        _wait(env)
+
+        # Phase 8: Afternoon + Notify with parallelism
+        _delegate(env, "afternoon_execution", "companion")
+        _delegate(env, "notify_stakeholders", "mail_agent")  # fails attempt 0
+
+        # Phase 9: Retry notify, then final report
+        _retry(env, "notify_stakeholders", "mail_agent")  # attempt 1 succeeds
+        _delegate(env, "synthesize_day_report", "mail_agent")
+
+        # Phase 10: Synthesize
+        obs = _synthesize(env)
+
+        return env, obs
+
+    def test_all_14_subtasks_complete(self) -> None:
+        """All 14 subtasks should be completed after the walkthrough."""
+        env, obs = self._run_known_good_sequence()
+        assert obs.done is True
+        assert len(obs.completed_outputs) == 14
+        assert env._dag.is_all_completed()
+
+    def test_episode_terminates_with_positive_reward(self) -> None:
+        """Synthesize should trigger done and large positive total reward."""
+        env, obs = self._run_known_good_sequence()
+        assert obs.done is True
+        assert obs.reward > 0  # end bonus included
+        assert env._total_reward > 2.5  # verified: ~2.988
+
+    def test_time_and_budget(self) -> None:
+        """Verify time remaining and budget match expected values."""
+        env, obs = self._run_known_good_sequence()
+        assert obs.time_remaining == 7  # 25 - 18 steps
+        assert env._pool.get_budget_used() == pytest.approx(44.0, abs=0.1)
+
+    def test_failure_and_recovery(self) -> None:
+        """mail_agent fails notify_stakeholders attempt 0, recovers on retry."""
+        env, obs = self._run_known_good_sequence()
+        assert env._failures_occurred == 1
+        assert env._failures_recovered == 1
+
+    def test_parallelism_detected(self) -> None:
+        """Should detect parallelism across multiple fan-out points."""
+        env, obs = self._run_known_good_sequence()
+        # Morning assessments, focus+inbox, deep+urgent, urgent+health,
+        # afternoon+notify = 5+ parallelism events
+        assert env._parallelism_events >= 5
+
+    def test_personal_agent_offline_after_dropout(self) -> None:
+        """personal_agent should be offline after step 10 dropout event."""
+        env, obs = self._run_known_good_sequence()
+        assert env._pool.is_online("personal_agent") is False
+
+    def test_career_agent_degraded(self) -> None:
+        """career_agent speed should be 4 after degradation at step 7."""
+        env, obs = self._run_known_good_sequence()
+        agent_infos = env._pool.get_agent_infos()
+        career = [a for a in agent_infos if a.name == "career_agent"][0]
+        assert career.speed == 4
+
+    def test_zero_capacity_violations(self) -> None:
+        """No capacity violations in the known-good sequence."""
+        env, obs = self._run_known_good_sequence()
+        assert env._capacity_violations == 0
+
+    def test_grader_score_above_threshold(self) -> None:
+        """Grader should score >= 0.94 for the known-good walkthrough."""
+        from server.graders import grade_expert
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+        result = grade_expert(log)
+        assert result.score >= 0.94
+        assert result.score <= 1.0
+
+    def test_grader_all_dimensions_present(self) -> None:
+        """All 10 grader dimensions should be present and non-negative."""
+        from server.graders import grade_expert
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+        result = grade_expert(log)
+
+        expected_keys = [
+            "completion", "health_pillar", "career_pillar",
+            "conflict_resolution", "cost_efficiency", "parallelism",
+            "time_efficiency", "error_classification", "sla_compliance",
+            "communication",
+        ]
+        for key in expected_keys:
+            assert key in result.breakdown, f"Missing grader dimension: {key}"
+            assert result.breakdown[key] >= 0.0, f"{key} is negative"
+
+    def test_grader_perfect_dimensions(self) -> None:
+        """Verify the known-good walkthrough scores perfectly on 8 of 10 dimensions."""
+        from server.graders import grade_expert
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+        result = grade_expert(log)
+
+        # 100% dimensions
+        assert result.breakdown["completion"] == pytest.approx(0.15, abs=0.001)
+        assert result.breakdown["health_pillar"] == pytest.approx(0.12, abs=0.001)
+        assert result.breakdown["career_pillar"] == pytest.approx(0.10, abs=0.001)
+        assert result.breakdown["conflict_resolution"] == pytest.approx(0.20, abs=0.001)
+        assert result.breakdown["parallelism"] == pytest.approx(0.10, abs=0.001)
+        assert result.breakdown["error_classification"] == pytest.approx(0.08, abs=0.001)
+        assert result.breakdown["sla_compliance"] == pytest.approx(0.08, abs=0.001)
+        assert result.breakdown["communication"] == pytest.approx(0.04, abs=0.001)
+
+        # Partial dimensions (cost efficiency ~0.064, time efficiency ~0.014)
+        assert result.breakdown["cost_efficiency"] > 0.05
+        assert result.breakdown["time_efficiency"] > 0.01
+
+    def test_sla_milestones_all_met(self) -> None:
+        """All 3 SLA milestones should be met."""
+        from server.graders import count_sla_milestones_met
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+
+        sla_milestones = {
+            "plan_day_schedule": 8,
+            "resolve_priority_conflict": 16,
+            "synthesize_day_report": 23,
+        }
+        met = count_sla_milestones_met(log, sla_milestones)
+        assert met == 3
+
+    def test_permanent_failure_traps_avoided(self) -> None:
+        """Sequence never assigns wellness_monitor to health_alert or
+        executive_assistant to conflict_resolution."""
+        from server.graders import count_retries_on_permanent_failure
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+
+        assert count_retries_on_permanent_failure(log) == 0
+
+    def test_conflict_resolution_by_companion(self) -> None:
+        """resolve_priority_conflict should be completed by companion."""
+        from server.graders import subtask_completed_by_agent
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+
+        assert subtask_completed_by_agent(log, "resolve_priority_conflict", "companion")
+
+    def test_midday_health_not_by_wellness_monitor(self) -> None:
+        """midday_health_check should NOT be completed by wellness_monitor."""
+        from server.graders import subtask_not_completed_by_agent
+
+        env, obs = self._run_known_good_sequence()
+        log = _episode_store["expert"]
+
+        assert subtask_not_completed_by_agent(
+            log, "midday_health_check", ["wellness_monitor"]
+        )

tests/test_graders.py

@@ -14,6 +14,7 @@ from server.graders import (
     fan_out_parallelism_detected,
     grade,
     grade_easy,
+    grade_expert,
     grade_hard,
     grade_medium,
     monitoring_completed,
@@ -233,3 +234,105 @@ class TestGradeDispatcher:
         log = _make_log("unknown")
         with pytest.raises(KeyError):
             grade("unknown", log)
+
+
+# ── Degenerate policy tests ──
+# Prove that graders are well-calibrated: doing nothing scores near 0,
+# and known-good walkthroughs always outscore degenerate policies.
+
+
+class TestDegeneratePolicies:
+    """Verify that a do-nothing policy (all waits) scores near 0 on every task.
+
+    This validates the activity gate mechanism: dimensions that reward "no harm"
+    (error classification, capacity discipline, cost efficiency) scale with
+    actual task completion, preventing free points for inaction.
+    """
+
+    @staticmethod
+    def _run_do_nothing(task_id: str) -> GradeResult:
+        """Run a do-nothing policy (all waits) and return grader result."""
+        from server.environment import OrchestratorEnvironment, _episode_store
+        from models import OrchestratorAction
+
+        time_budgets = {"easy": 15, "medium": 16, "hard": 22, "expert": 25}
+        env = OrchestratorEnvironment()
+        env.reset(task_id=task_id)
+        for _ in range(time_budgets[task_id]):
+            env.step(OrchestratorAction(action_type="wait"))
+        return grade(task_id, _episode_store[task_id])
+
+    def test_do_nothing_easy_scores_zero(self) -> None:
+        result = self._run_do_nothing("easy")
+        assert result.score == 0.0
+
+    def test_do_nothing_medium_scores_near_zero(self) -> None:
+        result = self._run_do_nothing("medium")
+        assert result.score <= 0.05
+
+    def test_do_nothing_hard_scores_near_zero(self) -> None:
+        result = self._run_do_nothing("hard")
+        assert result.score <= 0.05
+
+    def test_do_nothing_expert_scores_near_zero(self) -> None:
+        result = self._run_do_nothing("expert")
+        assert result.score <= 0.05
+
+    def test_known_good_easy_outscores_degenerate(self) -> None:
+        """Known-good easy walkthrough must score higher than do-nothing."""
+        from server.environment import OrchestratorEnvironment, _episode_store
+        from models import OrchestratorAction
+
+        degenerate = self._run_do_nothing("easy")
+
+        # Run known-good easy walkthrough
+        env = OrchestratorEnvironment()
+        env.reset(task_id="easy")
+        seq = [
+            ("delegate", "technical_design", "tech_lead"),
+            ("delegate", "implement_backend", "backend_dev"),
+            ("delegate", "implement_frontend", "frontend_dev"),
+            ("delegate", "write_tests", "qa_engineer"),
+            ("delegate", "run_tests", "backend_dev"),
+            ("delegate", "review_and_merge", "tech_lead"),
+            ("synthesize", None, None),
+        ]
+        for action_type, sid, agent in seq:
+            env.step(OrchestratorAction(
+                action_type=action_type, subtask_id=sid, agent_name=agent,
+            ))
+        good = grade("easy", _episode_store["easy"])
+        assert good.score > degenerate.score + 0.5
+
+    def test_known_good_hard_outscores_degenerate(self) -> None:
+        """Known-good hard walkthrough must score higher than do-nothing."""
+        from server.environment import OrchestratorEnvironment, _episode_store
+        from models import OrchestratorAction
+
+        degenerate = self._run_do_nothing("hard")
+
+        # Run known-good hard walkthrough (14 steps)
+        env = OrchestratorEnvironment()
+        env.reset(task_id="hard")
+        steps = [
+            ("delegate", "alert_triage", "triage_analyst"),
+            ("delegate", "enrich_logs", "investigator_alpha"),
+            ("delegate", "check_dashboards", "monitor"),
+            ("retry", "enrich_logs", "investigator_beta"),
+            ("delegate", "check_dependencies", "investigator_alpha"),
+            ("delegate", "notify_stakeholders", "communicator"),
+            ("delegate", "root_cause_analysis", "senior_engineer"),
+            ("delegate", "deploy_hotfix", "deployer"),
+            ("delegate", "update_status_page", "communicator"),
+            ("delegate", "validate_fix", "senior_engineer"),
+            ("delegate", "monitor_recovery", "monitor"),
+            ("wait", None, None),
+            ("wait", None, None),
+            ("synthesize", None, None),
+        ]
+        for action_type, sid, agent in steps:
+            env.step(OrchestratorAction(
+                action_type=action_type, subtask_id=sid, agent_name=agent,
+            ))
+        good = grade("hard", _episode_store["hard"])
+        assert good.score > degenerate.score + 0.5