feat: implement repaired p1 parameterization

README.md

@@ -24,8 +24,8 @@ Implementation status:
 - docs are aligned to fresh `P1` wiring in this repo
 - shared models, baselines, and server/client entry points now reflect the locked `P1` contract
 - the current environment uses `constellaration` for low-fidelity `run` steps and high-fidelity `submit` evaluation
-- the current 3-knob parameterization has been verified as blocked on P1 triangularity under the real verifier path
-- the next runtime work is parameterization repair, then fixtures, manual playtesting, heuristic refresh, and deployment evidence
+- the repaired 4-knob low-dimensional family is now wired into the runtime path
+- the next runtime work is measured sweep validation, fixtures, manual playtesting, heuristic refresh, and deployment evidence
 
 ## Execution Status
 
@@ -40,11 +40,11 @@ Implementation status:
 - [x] Add a runnable Northflank smoke workflow and note
 - [x] Pass the Northflank smoke test on the H100 workspace
 - [x] Verify the current 3-knob family against the real low-fidelity verifier
-- [ ] Add a custom low-dimensional boundary builder with an explicit triangularity control knob
-- [ ] Split boundary construction from boundary evaluation in `server/physics.py`
-- [ ] Update the action contract from 3 knobs to the repaired low-dimensional family
-- [ ] Add explicit VMEC failure semantics to the environment contract
-- [ ] Label low-fi `run` truth vs high-fi `submit` truth in observations and task docs
+- [x] Add a custom low-dimensional boundary builder with an explicit triangularity control knob
+- [x] Split boundary construction from boundary evaluation in `server/physics.py`
+- [x] Update the action contract from 3 knobs to the repaired low-dimensional family
+- [x] Add explicit VMEC failure semantics to the environment contract
+- [x] Label low-fi `run` truth vs high-fi `submit` truth in observations and task docs
 - [ ] Add tracked `P1` fixtures under `server/data/p1/`
 - [ ] Run manual playtesting and record the first reward pathology
 - [ ] Refresh the heuristic baseline for the real verifier path
@@ -53,10 +53,10 @@ Implementation status:
 ## Known Gaps
 
 - The current 3-knob family is structurally blocked on P1 triangularity with the real verifier path. A sampled low-fidelity sweep kept `average_triangularity` at roughly `+0.004975` and `p1_feasibility` at roughly `1.00995`, with zero feasible samples. That means reward tuning is secondary until the parameterization is repaired.
-- `BASELINE_PARAMS` is not a near-feasible anchor on the real verifier path. The current low-fidelity measurement is roughly `p1_feasibility=1.01`, `average_triangularity=+0.005`, and `edge_iota_over_nfp=0.059`, so fixture discovery has to happen after parameterization repair, not before.
+- The repaired family now uses frozen exact seeds with explicit triangularity control. Those seeds are near-boundary references, not yet tracked fixtures.
 - The repaired low-dimensional family still needs measured ranges and deltas. Do not narrate guessed `rotational_transform` bounds, `triangularity_scale` deltas, or a larger budget as validated facts until they are measured on the repaired environment.
 - `run` uses low-fidelity `constellaration` metrics, while `submit` re-evaluates the current design with high-fidelity `skip_qi`; do not present step-time metrics as final submission metrics.
-- The environment still needs explicit VMEC failure semantics. Failed evaluations should cost budget, produce a visible failure observation, and apply a documented penalty; they should not be silently swallowed.
+- VMEC failure semantics are now explicit in the runtime path. Failed evaluations cost budget, produce a visible failure observation, and apply a penalty.
 - Budget exhaustion now returns a smaller terminal reward than explicit `submit`; keep that asymmetry when tuning reward so agents still prefer deliberate submission.
 - The real-verifier baseline rerun showed the old heuristic is no longer useful as-is: over 5 seeded episodes, both agents stayed at `0.0` mean best score and the heuristic underperformed random on reward. The heuristic needs redesign after the repaired parameterization and manual playtesting.
 
@@ -117,17 +117,13 @@ uv sync --extra notebooks
 
 ## Immediate Next Steps
 
-1. Repair the low-dimensional boundary parameterization so it can actually move P1 triangularity.
-2. Split boundary construction from boundary evaluation in `server/physics.py`.
-3. Add explicit VMEC failure semantics to the environment loop.
-4. Update the environment contract to the repaired low-dimensional family and label low-fi vs high-fi truth clearly in observations.
-5. Run a small measured sweep on the repaired family to choose useful ranges, deltas, and reset seeds.
-6. Add tracked `P1` fixtures under `server/data/p1`.
-7. Run manual playtest episodes and record the first real reward pathology, if any.
-8. Refresh the heuristic baseline using manual playtest evidence, then save one comparison trace.
-9. Use the passing Northflank H100 setup to produce remote traces and comparisons from the real verifier path.
-10. Deploy the environment to HF Space.
-11. Add the Colab notebook under `training/notebooks`.
+1. Run a small measured sweep on the repaired family to choose useful ranges, deltas, and reset seeds.
+2. Add tracked `P1` fixtures under `server/data/p1`.
+3. Run manual playtest episodes and record the first real reward pathology, if any.
+4. Refresh the heuristic baseline using manual playtest evidence, then save one comparison trace.
+5. Use the passing Northflank H100 setup to produce remote traces and comparisons from the real verifier path.
+6. Deploy the environment to HF Space.
+7. Add the Colab notebook under `training/notebooks`.
 
 These are implementation steps, not another planning phase.
 

TODO.md

@@ -28,11 +28,11 @@ Priority source:
 - [x] post-terminal guard in `step()`
 - [x] `constellaration` verifier wiring
 - [x] verify the current 3-knob family against the real low-fidelity verifier
-- [ ] repair the low-dimensional parameterization so triangularity is controllable
-- [ ] split boundary building from boundary evaluation
-- [ ] update the action schema from 3 knobs to the repaired low-dimensional family
-- [ ] add explicit VMEC failure semantics
-- [ ] label low-fi vs high-fi truth in the observation/task surface
+- [x] repair the low-dimensional parameterization so triangularity is controllable
+- [x] split boundary building from boundary evaluation
+- [x] update the action schema from 3 knobs to the repaired low-dimensional family
+- [x] add explicit VMEC failure semantics
+- [x] label low-fi vs high-fi truth in the observation/task surface
 - [ ] tracked `P1` fixtures
 - [ ] manual playtest log
 - [x] settle the non-submit terminal reward policy
@@ -108,7 +108,7 @@ flowchart TD
   [server/app.py](server/app.py),
   [README.md](README.md)
 
-- [ ] Repair the low-dimensional boundary family
+- [x] Repair the low-dimensional boundary family
   Goal:
   add an explicit triangularity control knob or equivalent low-dimensional control so the environment can actually approach P1 feasibility
   Files:
@@ -119,7 +119,7 @@ flowchart TD
   Related:
   [P1 Environment Contract](docs/P1_ENV_CONTRACT_V1.md)
 
-- [ ] Split boundary construction from boundary evaluation
+- [x] Split boundary construction from boundary evaluation
   Goal:
   make the verifier boundary-based and keep parameterization-specific logic in the environment adapter layer
   Files:
@@ -127,7 +127,7 @@ flowchart TD
   Related:
   [P1 Environment Contract](docs/P1_ENV_CONTRACT_V1.md)
 
-- [ ] Add explicit VMEC failure semantics
+- [x] Add explicit VMEC failure semantics
   Goal:
   failed evaluations must cost budget, return a visible failure observation, and apply a documented penalty without silent fallback
   Files:
@@ -136,7 +136,7 @@ flowchart TD
   Related:
   [P1 Environment Contract](docs/P1_ENV_CONTRACT_V1.md)
 
-- [ ] Label low-fi vs high-fi truth in the observation/task surface
+- [x] Label low-fi vs high-fi truth in the observation/task surface
   Goal:
   make it obvious whether a metric came from a low-fidelity `run` step or a high-fidelity `submit`
   Files:

baselines/README.md

@@ -7,7 +7,7 @@ Random and heuristic baselines will live here.
 - [x] baseline comparison script exists
 - [x] baseline comparison rerun completed on the real verifier path
 - [x] verified that the current 3-knob family is blocked on P1 triangularity under the real verifier path
-- [ ] repair the low-dimensional parameterization before further heuristic work
+- [x] repair the low-dimensional parameterization before further heuristic work
 - [ ] wait for measured repaired-family ranges and reset seeds before retuning the heuristic
 - [ ] heuristic refreshed after the real-verifier rerun
 - [ ] near-boundary fixture-backed baseline start chosen for manual playtesting

baselines/heuristic_agent.py

@@ -1,26 +1,12 @@
-"""Heuristic baseline agent for the stellarator design environment.
-
-Strategy: guided perturbations informed by domain knowledge.
-1. Push elongation upward to improve triangularity.
-2. Nudge rotational transform upward to stay on the iota side of feasibility.
-3. Submit before exhausting budget.
-"""
+"""Heuristic baseline agent for the stellarator design environment."""
 
 from __future__ import annotations
 
 import sys
 
-from fusion_lab.models import StellaratorAction
+from fusion_lab.models import StellaratorAction, StellaratorObservation
 from server.environment import StellaratorEnvironment
 
-STRATEGY: list[tuple[str, str, str]] = [
-    ("elongation", "increase", "medium"),
-    ("elongation", "increase", "small"),
-    ("rotational_transform", "increase", "small"),
-    ("aspect_ratio", "decrease", "small"),
-    ("rotational_transform", "increase", "small"),
-]
-
 
 def heuristic_episode(
     env: StellaratorEnvironment, seed: int | None = None
@@ -29,43 +15,74 @@ def heuristic_episode(
     total_reward = 0.0
     trace: list[dict[str, object]] = [{"step": 0, "score": obs.p1_score}]
 
-    for parameter, direction, magnitude in STRATEGY:
-        if obs.done or obs.budget_remaining <= 1:
-            break
-
-        action = StellaratorAction(
-            intent="run",
-            parameter=parameter,
-            direction=direction,
-            magnitude=magnitude,
-        )
+    while not obs.done:
+        action = _choose_action(obs)
         obs = env.step(action)
         total_reward += obs.reward or 0.0
         trace.append(
             {
                 "step": len(trace),
-                "action": f"{parameter} {direction} {magnitude}",
+                "action": _action_label(action),
                 "score": obs.p1_score,
                 "best_score": obs.best_score,
                 "reward": obs.reward,
+                "failure": obs.evaluation_failed,
             }
         )
 
-    if not obs.done:
-        submit = StellaratorAction(intent="submit")
-        obs = env.step(submit)
-        total_reward += obs.reward or 0.0
-        trace.append(
-            {
-                "step": len(trace),
-                "action": "submit",
-                "score": obs.p1_score,
-                "best_score": obs.best_score,
-                "reward": obs.reward,
-            }
+    return total_reward, trace
+
+
+def _choose_action(obs: StellaratorObservation) -> StellaratorAction:
+    if obs.constraints_satisfied:
+        if obs.budget_remaining <= 2:
+            return StellaratorAction(intent="submit")
+        return StellaratorAction(
+            intent="run",
+            parameter="elongation",
+            direction="decrease",
+            magnitude="small",
         )
 
-    return total_reward, trace
+    if obs.evaluation_failed:
+        return StellaratorAction(intent="restore_best")
+
+    if obs.average_triangularity > -0.5:
+        return StellaratorAction(
+            intent="run",
+            parameter="triangularity_scale",
+            direction="increase",
+            magnitude="small",
+        )
+
+    if obs.edge_iota_over_nfp < 0.3:
+        return StellaratorAction(
+            intent="run",
+            parameter="rotational_transform",
+            direction="increase",
+            magnitude="small",
+        )
+
+    if obs.aspect_ratio > 4.0:
+        return StellaratorAction(
+            intent="run",
+            parameter="aspect_ratio",
+            direction="decrease",
+            magnitude="small",
+        )
+
+    return StellaratorAction(
+        intent="run",
+        parameter="elongation",
+        direction="decrease",
+        magnitude="small",
+    )
+
+
+def _action_label(action: StellaratorAction) -> str:
+    if action.intent != "run":
+        return action.intent
+    return f"{action.parameter} {action.direction} {action.magnitude}"
 
 
 def main(n_episodes: int = 20) -> None:

baselines/random_agent.py

@@ -8,7 +8,12 @@ import sys
 from fusion_lab.models import StellaratorAction
 from server.environment import StellaratorEnvironment
 
-PARAMETERS = ["aspect_ratio", "elongation", "rotational_transform"]
+PARAMETERS = [
+    "aspect_ratio",
+    "elongation",
+    "rotational_transform",
+    "triangularity_scale",
+]
 DIRECTIONS = ["increase", "decrease"]
 MAGNITUDES = ["small", "medium", "large"]
 

docs/FUSION_DELIVERABLES_MAP.md

@@ -14,9 +14,9 @@ Use this map to sequence execution, not to reopen already-locked task choices.
 - [x] Northflank smoke workflow and note are committed
 - [x] Northflank smoke test has passed on the team H100
 - [x] current 3-knob family has been verified as blocked on P1 triangularity
-- [ ] repaired low-dimensional boundary builder is implemented
-- [ ] explicit VMEC failure semantics are implemented
-- [ ] low-fi `run` truth vs high-fi `submit` truth is labeled clearly
+- [x] repaired low-dimensional boundary builder is implemented
+- [x] explicit VMEC failure semantics are implemented
+- [x] low-fi `run` truth vs high-fi `submit` truth is labeled clearly
 - [ ] tracked fixtures are checked in
 - [ ] manual playtest evidence exists
 - [ ] heuristic baseline has been refreshed for the real verifier path

docs/FUSION_DESIGN_LAB_PLAN_V2.md

@@ -7,7 +7,7 @@
 ## 0. Current Branch Status
 
 - [x] `P1` task family is locked
-- [x] 3-knob rotating-ellipse `P1` contract is implemented in code
+- [x] repaired 4-knob low-dimensional `P1` contract is implemented in code
 - [x] real `constellaration` verifier wiring is in place
 - [x] low-fidelity `run` plus high-fidelity `submit` split is documented
 - [x] post-terminal `step()` guard is in place
@@ -15,9 +15,9 @@
 - [x] Northflank smoke workflow and note are committed
 - [x] Northflank smoke test has passed on the team H100
 - [x] current 3-knob family has been checked against the real low-fidelity verifier
-- [ ] parameterization repair is implemented so triangularity is controllable
-- [ ] explicit VMEC failure semantics are implemented
-- [ ] low-fi `run` truth vs high-fi `submit` truth is labeled clearly in the environment surface
+- [x] parameterization repair is implemented so triangularity is controllable
+- [x] explicit VMEC failure semantics are implemented
+- [x] low-fi `run` truth vs high-fi `submit` truth is labeled clearly in the environment surface
 - [ ] tracked `P1` fixtures are added
 - [ ] manual playtest evidence is recorded
 - [ ] heuristic baseline is refreshed for the real verifier path
@@ -25,7 +25,7 @@
 
 Current caution:
 
-- the current 3-knob family is structurally blocked on the official triangularity constraint under the real verifier path, so parameterization repair is now the first blocker before fixture discovery or manual playtesting
+- the repaired family is now live, but the exact ranges, deltas, and reset seeds still need a measured sweep before they should be treated as stable defaults
 
 ## 1. Submission Thesis
 

docs/FUSION_NEXT_12_HOURS_CHECKLIST.md

@@ -9,7 +9,7 @@ Do not expand scope beyond one stable task. Training is supporting evidence, not
 ## Current Branch Status
 
 - [x] `P1` task is locked
-- [x] 3-knob rotating-ellipse `P1` contract is implemented in the working tree
+- [x] repaired 4-knob low-dimensional `P1` contract is implemented in the working tree
 - [x] baselines and API surface have been moved to the `P1` contract
 - [x] add a post-terminal guard in `step()`
 - [x] replace the synthetic evaluator with `constellaration`
@@ -17,15 +17,15 @@ Do not expand scope beyond one stable task. Training is supporting evidence, not
 - [x] commit the Northflank smoke workflow and note
 - [x] pass the Northflank smoke test on the team H100
 - [x] verify that the current 3-knob family is blocked on P1 triangularity under the real verifier path
-- [ ] repair the low-dimensional parameterization
-- [ ] add explicit VMEC failure semantics
-- [ ] label low-fi `run` truth vs high-fi `submit` truth in the task surface
+- [x] repair the low-dimensional parameterization
+- [x] add explicit VMEC failure semantics
+- [x] label low-fi `run` truth vs high-fi `submit` truth in the task surface
 - [ ] add tracked fixtures and manual playtest evidence
 - [ ] refresh the heuristic baseline after the real-verifier rerun
 
 Current caution:
 
-- do not assume the current 3-knob family is a viable playtest start; parameterization repair comes before fixture discovery, manual playtesting, and heuristic refresh
+- do not assume the first repaired defaults are final; run a measured sweep before treating ranges, deltas, or reset seeds as stable
 
 ## Plan V2 Inheritance
 

docs/P1_ENV_CONTRACT_V1.md

@@ -1,6 +1,6 @@
 # P1 Environment Contract V1
 
-**Status:** Technical revision plan over a partial implementation
+**Status:** Technical contract with partial implementation now landed
 **Role:** Supporting spec for the `P1` environment contract
 **SSOT relationship:** This file refines [FUSION_DESIGN_LAB_PLAN_V2.md](FUSION_DESIGN_LAB_PLAN_V2.md). If this file conflicts with the planning SSOT, update both in the same task.
 
@@ -17,7 +17,7 @@ The central change is now explicit:
 
 - the current upstream 3-knob rotating-ellipse family is blocked on P1 triangularity under the real verifier path
 - the next environment contract must repair parameterization before more reward iteration or heuristic work
-- the current repo still exposes the old 3-knob surface and needs to be revised to this 4-knob target
+- the runtime now exposes the repaired 4-knob target, but measured sweep validation and fixture calibration are still pending
 
 ## Verified Blocker
 
@@ -62,9 +62,9 @@ Keep three layers separate:
 
 Current repo state:
 
-- the live code still exposes `evaluate_params(...)`
-- boundary construction and evaluation are not yet split cleanly
-- the verifier rewrite in this file is still pending
+- the live code now exposes a boundary builder plus boundary-based evaluator
+- explicit failure results are returned when VMEC evaluation fails
+- measured sweep validation is still pending
 
 Target functions:
 
@@ -129,11 +129,11 @@ This keeps the environment human-playable and aligned with the historical low-di
 
 Current repo state:
 
-- the live action schema still exposes only:
+- the live action schema now exposes:
   - `aspect_ratio`
   - `elongation`
   - `rotational_transform`
-- the fourth low-dimensional control is still pending
+  - `triangularity_scale`
 
 ## Observation Contract
 
@@ -167,8 +167,8 @@ The minimum requirement is that a reader can tell whether a metric came from low
 
 Current repo state:
 
-- the live observation surface still presents a single `p1_score` / `p1_feasibility` view
-- the environment and `/task` surface still need an explicit low-fi vs high-fi distinction
+- the live observation surface now exposes evaluation fidelity and failure state
+- the exact naming can still be refined after playtesting, but low-fi vs high-fi is no longer implicit
 
 ## Reward V0
 

docs/P1_PARAMETERIZATION_DEEPDIVE.md

@@ -1,7 +1,7 @@
 # P1 Parameterization Deep-Dive
 
 **Date:** 2026-03-07
-**Status:** Findings complete. Partial implementation exists; parameterization repair pending.
+**Status:** Findings complete. Parameterization repair is implemented; measured sweep follow-up is pending.
 
 This document records the investigation into why the current 3-knob rotating-ellipse
 environment cannot produce P1-feasible designs, what the original winning session

fusion_lab/models.py

@@ -6,15 +6,22 @@ from openenv.core import Action, Observation, State
 from pydantic import BaseModel, Field
 
 ActionIntent = Literal["run", "submit", "restore_best"]
-ParameterName = Literal["aspect_ratio", "elongation", "rotational_transform"]
+ParameterName = Literal[
+    "aspect_ratio",
+    "elongation",
+    "rotational_transform",
+    "triangularity_scale",
+]
 DirectionName = Literal["increase", "decrease"]
 MagnitudeName = Literal["small", "medium", "large"]
+EvaluationFidelityName = Literal["low", "high"]
 
 
-class RotatingEllipseParams(BaseModel):
+class LowDimBoundaryParams(BaseModel):
     aspect_ratio: float
     elongation: float
     rotational_transform: float
+    triangularity_scale: float
 
 
 class StellaratorAction(Action):
@@ -34,6 +41,9 @@ class StellaratorObservation(Observation):
     p1_score: float = 0.0
     p1_feasibility: float = 0.0
     vacuum_well: float = 0.0
+    evaluation_fidelity: EvaluationFidelityName = "low"
+    evaluation_failed: bool = False
+    failure_reason: str = ""
     step_number: int = 0
     budget_remaining: int = 6
     best_score: float = 0.0
@@ -43,18 +53,20 @@ class StellaratorObservation(Observation):
 
 
 class StellaratorState(State):
-    current_params: RotatingEllipseParams = Field(
-        default_factory=lambda: RotatingEllipseParams(
-            aspect_ratio=3.5,
-            elongation=1.5,
-            rotational_transform=0.4,
+    current_params: LowDimBoundaryParams = Field(
+        default_factory=lambda: LowDimBoundaryParams(
+            aspect_ratio=3.6,
+            elongation=1.4,
+            rotational_transform=1.6,
+            triangularity_scale=0.55,
         )
     )
-    best_params: RotatingEllipseParams = Field(
-        default_factory=lambda: RotatingEllipseParams(
-            aspect_ratio=3.5,
-            elongation=1.5,
-            rotational_transform=0.4,
+    best_params: LowDimBoundaryParams = Field(
+        default_factory=lambda: LowDimBoundaryParams(
+            aspect_ratio=3.6,
+            elongation=1.4,
+            rotational_transform=1.6,
+            triangularity_scale=0.55,
         )
     )
     initial_score: float = 0.0

server/app.py

@@ -16,7 +16,10 @@ app = create_fastapi_app(
 @app.get("/task")
 def task_summary() -> dict[str, object]:
     return {
-        "description": "Optimize the P1 benchmark with a rotating-ellipse parameterization.",
+        "description": (
+            "Optimize the P1 benchmark with a custom low-dimensional boundary family "
+            "derived from a rotating-ellipse seed."
+        ),
         "constraints": {
             "aspect_ratio_max": ASPECT_RATIO_MAX,
             "average_triangularity_max": AVERAGE_TRIANGULARITY_MAX,
@@ -25,9 +28,18 @@ def task_summary() -> dict[str, object]:
         "n_field_periods": N_FIELD_PERIODS,
         "budget": BUDGET,
         "actions": ["run", "submit", "restore_best"],
-        "parameters": ["aspect_ratio", "elongation", "rotational_transform"],
+        "parameters": [
+            "aspect_ratio",
+            "elongation",
+            "rotational_transform",
+            "triangularity_scale",
+        ],
         "directions": ["increase", "decrease"],
         "magnitudes": ["small", "medium", "large"],
+        "evaluation_modes": {
+            "run": "low-fidelity constellaration evaluation",
+            "submit": "high-fidelity constellaration evaluation",
+        },
     }
 
 

server/environment.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-from random import Random
 from typing import Any, Final, Optional
 
 from openenv.core import Environment as BaseEnvironment
 
 from fusion_lab.models import (
-    RotatingEllipseParams,
+    LowDimBoundaryParams,
     StellaratorAction,
     StellaratorObservation,
     StellaratorState,
@@ -17,37 +16,58 @@ from server.physics import (
     EDGE_IOTA_OVER_NFP_MIN,
     FEASIBILITY_TOLERANCE,
     EvaluationMetrics,
-    evaluate_params,
+    build_boundary_from_params,
+    evaluate_boundary,
 )
 
 BUDGET: Final[int] = 6
 N_FIELD_PERIODS: Final[int] = 3
 
 PARAMETER_RANGES: Final[dict[str, tuple[float, float]]] = {
-    "aspect_ratio": (2.0, 8.0),
-    "elongation": (1.0, 5.0),
-    "rotational_transform": (0.1, 1.0),
+    "aspect_ratio": (3.2, 3.8),
+    "elongation": (1.2, 1.8),
+    "rotational_transform": (1.2, 1.9),
+    "triangularity_scale": (0.4, 0.7),
 }
 
 PARAMETER_DELTAS: Final[dict[str, dict[str, float]]] = {
-    "aspect_ratio": {"small": 0.1, "medium": 0.3, "large": 0.8},
-    "elongation": {"small": 0.1, "medium": 0.3, "large": 0.8},
-    "rotational_transform": {"small": 0.02, "medium": 0.05, "large": 0.15},
+    "aspect_ratio": {"small": 0.05, "medium": 0.1, "large": 0.2},
+    "elongation": {"small": 0.05, "medium": 0.1, "large": 0.2},
+    "rotational_transform": {"small": 0.05, "medium": 0.1, "large": 0.2},
+    "triangularity_scale": {"small": 0.02, "medium": 0.05, "large": 0.1},
 }
 
-BASELINE_PARAMS: Final[RotatingEllipseParams] = RotatingEllipseParams(
-    aspect_ratio=3.5,
-    elongation=1.5,
-    rotational_transform=0.4,
+RESET_SEEDS: Final[tuple[LowDimBoundaryParams, ...]] = (
+    LowDimBoundaryParams(
+        aspect_ratio=3.6,
+        elongation=1.4,
+        rotational_transform=1.5,
+        triangularity_scale=0.55,
+    ),
+    LowDimBoundaryParams(
+        aspect_ratio=3.4,
+        elongation=1.4,
+        rotational_transform=1.6,
+        triangularity_scale=0.55,
+    ),
+    LowDimBoundaryParams(
+        aspect_ratio=3.8,
+        elongation=1.4,
+        rotational_transform=1.5,
+        triangularity_scale=0.55,
+    ),
 )
 
 TARGET_SPEC: Final[str] = (
-    "Optimize the P1 benchmark using a rotating-ellipse parameterization. "
-    "Constraints: aspect ratio <= 4.0, average triangularity <= -0.5, "
-    "edge rotational transform / n_field_periods >= 0.3. "
+    "Optimize the P1 benchmark using a custom low-dimensional boundary family derived "
+    "from a rotating-ellipse seed. Constraints: aspect ratio <= 4.0, average "
+    "triangularity <= -0.5, edge rotational transform / n_field_periods >= 0.3. "
+    "Run actions use low-fidelity verification. Submit uses high-fidelity verification. "
     "Budget: 6 evaluations."
 )
 
+FAILURE_PENALTY: Final[float] = -2.0
+
 
 class StellaratorEnvironment(
     BaseEnvironment[StellaratorAction, StellaratorObservation, StellaratorState]
@@ -56,6 +76,7 @@ class StellaratorEnvironment(
         super().__init__()
         self._state = StellaratorState()
         self._last_metrics: EvaluationMetrics | None = None
+        self._last_successful_metrics: EvaluationMetrics | None = None
 
     def reset(
         self,
@@ -64,11 +85,7 @@ class StellaratorEnvironment(
         **kwargs: Any,
     ) -> StellaratorObservation:
         params = self._initial_params(seed)
-        metrics = evaluate_params(
-            params,
-            n_field_periods=N_FIELD_PERIODS,
-            fidelity="low",
-        )
+        metrics = self._evaluate_params(params, fidelity="low")
         self._state = StellaratorState(
             episode_id=episode_id,
             step_count=0,
@@ -83,9 +100,10 @@ class StellaratorEnvironment(
             constraints_satisfied=metrics.constraints_satisfied,
         )
         self._last_metrics = metrics
+        self._last_successful_metrics = None if metrics.evaluation_failed else metrics
         return self._build_observation(
             metrics,
-            action_summary="Episode started from the rotating-ellipse baseline.",
+            action_summary="Episode started from a frozen low-dimensional seed.",
         )
 
     def step(
@@ -95,14 +113,13 @@ class StellaratorEnvironment(
         **kwargs: Any,
     ) -> StellaratorObservation:
         if self._state.episode_done or self._state.budget_remaining <= 0:
-            metrics = self._last_metrics or evaluate_params(
+            metrics = self._last_metrics or self._evaluate_params(
                 self._state.current_params,
-                n_field_periods=N_FIELD_PERIODS,
                 fidelity="low",
             )
             return self._build_observation(
                 metrics,
-                action_summary=("Episode already ended. Call reset() before sending more actions."),
+                action_summary="Episode already ended. Call reset() before sending more actions.",
                 reward=0.0,
                 done=True,
             )
@@ -119,10 +136,6 @@ class StellaratorEnvironment(
     def state(self) -> StellaratorState:
         return self._state
 
-    # ------------------------------------------------------------------
-    # Action handlers
-    # ------------------------------------------------------------------
-
     def _handle_run(self, action: StellaratorAction) -> StellaratorObservation:
         if not all([action.parameter, action.direction, action.magnitude]):
             return self._handle_invalid_run()
@@ -134,11 +147,7 @@ class StellaratorEnvironment(
             direction=action.direction,
             magnitude=action.magnitude,
         )
-        metrics = evaluate_params(
-            params,
-            n_field_periods=N_FIELD_PERIODS,
-            fidelity="low",
-        )
+        metrics = self._evaluate_params(params, fidelity="low")
         self._state.current_params = params
         self._state.constraints_satisfied = metrics.constraints_satisfied
         self._update_best(params, metrics)
@@ -148,6 +157,8 @@ class StellaratorEnvironment(
         summary = self._summary_run(action, metrics)
         self._state.history.append(summary)
         self._last_metrics = metrics
+        if not metrics.evaluation_failed:
+            self._last_successful_metrics = metrics
         self._state.episode_done = done
 
         return self._build_observation(
@@ -158,16 +169,14 @@ class StellaratorEnvironment(
         )
 
     def _handle_submit(self) -> StellaratorObservation:
-        metrics = evaluate_params(
-            self._state.current_params,
-            n_field_periods=N_FIELD_PERIODS,
-            fidelity="high",
-        )
+        metrics = self._evaluate_params(self._state.current_params, fidelity="high")
         reward = self._compute_reward(metrics, "submit", done=True)
         summary = self._summary_submit(metrics)
         self._state.history.append(summary)
         self._state.episode_done = True
         self._last_metrics = metrics
+        if not metrics.evaluation_failed:
+            self._last_successful_metrics = metrics
 
         return self._build_observation(
             metrics,
@@ -179,21 +188,16 @@ class StellaratorEnvironment(
     def _handle_restore(self) -> StellaratorObservation:
         self._state.budget_remaining -= 1
         self._state.current_params = self._state.best_params
-        metrics = evaluate_params(
-            self._state.current_params,
-            n_field_periods=N_FIELD_PERIODS,
-            fidelity="low",
-        )
+        metrics = self._evaluate_params(self._state.current_params, fidelity="low")
         self._state.constraints_satisfied = metrics.constraints_satisfied
 
         done = self._state.budget_remaining <= 0
         reward = self._compute_reward(metrics, "restore_best", done)
-        summary = (
-            "Restored the best-known design. "
-            f"Score={metrics.p1_score:.6f}, feasibility={metrics.p1_feasibility:.6f}."
-        )
+        summary = self._summary_restore(metrics)
         self._state.history.append(summary)
         self._last_metrics = metrics
+        if not metrics.evaluation_failed:
+            self._last_successful_metrics = metrics
         self._state.episode_done = done
 
         return self._build_observation(
@@ -205,9 +209,8 @@ class StellaratorEnvironment(
 
     def _handle_invalid_run(self) -> StellaratorObservation:
         self._state.budget_remaining -= 1
-        metrics = self._last_metrics or evaluate_params(
+        metrics = self._last_metrics or self._evaluate_params(
             self._state.current_params,
-            n_field_periods=N_FIELD_PERIODS,
             fidelity="low",
         )
         done = self._state.budget_remaining <= 0
@@ -221,17 +224,23 @@ class StellaratorEnvironment(
             done=done,
         )
 
-    # ------------------------------------------------------------------
-    # Reward V0
-    # ------------------------------------------------------------------
-
     def _compute_reward(
         self,
         metrics: EvaluationMetrics,
         intent: str,
         done: bool,
     ) -> float:
-        previous_metrics = self._last_metrics or metrics
+        previous_metrics = self._reference_metrics(metrics)
+        if metrics.evaluation_failed:
+            reward = FAILURE_PENALTY
+            if intent != "submit":
+                reward -= 0.1
+            if intent == "submit":
+                reward -= 1.0
+            elif done:
+                reward -= 0.5
+            return round(reward, 4)
+
         reward = 0.0
 
         if metrics.constraints_satisfied and not previous_metrics.constraints_satisfied:
@@ -264,10 +273,6 @@ class StellaratorEnvironment(
 
         return round(reward, 4)
 
-    # ------------------------------------------------------------------
-    # Observation builders
-    # ------------------------------------------------------------------
-
     def _build_observation(
         self,
         metrics: EvaluationMetrics,
@@ -278,15 +283,23 @@ class StellaratorEnvironment(
         text_lines = [
             action_summary,
             "",
-            f"max_elongation={metrics.max_elongation:.4f}  |  best_score={self._state.best_score:.6f}",
-            f"aspect_ratio={metrics.aspect_ratio:.4f}  (<= {ASPECT_RATIO_MAX:.1f})",
-            f"average_triangularity={metrics.average_triangularity:.4f}  (<= {AVERAGE_TRIANGULARITY_MAX:.1f})",
-            f"edge_iota_over_nfp={metrics.edge_iota_over_nfp:.4f}  (>= {EDGE_IOTA_OVER_NFP_MIN:.1f})",
-            f"feasibility={metrics.p1_feasibility:.6f}  |  best_feasibility={self._state.best_feasibility:.6f}",
-            f"vacuum_well={metrics.vacuum_well:.4f}",
-            f"constraints={'SATISFIED' if metrics.constraints_satisfied else 'VIOLATED'}",
-            f"step={self._state.step_count}  |  budget={self._state.budget_remaining}/{self._state.budget_total}",
+            f"evaluation_fidelity={metrics.evaluation_fidelity}",
+            f"evaluation_status={'FAILED' if metrics.evaluation_failed else 'OK'}",
         ]
+        if metrics.evaluation_failed:
+            text_lines.append(f"failure_reason={metrics.failure_reason}")
+        text_lines.extend(
+            [
+                f"max_elongation={metrics.max_elongation:.4f}  |  best_score={self._state.best_score:.6f}",
+                f"aspect_ratio={metrics.aspect_ratio:.4f}  (<= {ASPECT_RATIO_MAX:.1f})",
+                f"average_triangularity={metrics.average_triangularity:.4f}  (<= {AVERAGE_TRIANGULARITY_MAX:.1f})",
+                f"edge_iota_over_nfp={metrics.edge_iota_over_nfp:.4f}  (>= {EDGE_IOTA_OVER_NFP_MIN:.1f})",
+                f"feasibility={metrics.p1_feasibility:.6f}  |  best_feasibility={self._state.best_feasibility:.6f}",
+                f"vacuum_well={metrics.vacuum_well:.4f}",
+                f"constraints={'SATISFIED' if metrics.constraints_satisfied else 'VIOLATED'}",
+                f"step={self._state.step_count}  |  budget={self._state.budget_remaining}/{self._state.budget_total}",
+            ]
+        )
 
         return StellaratorObservation(
             diagnostics_text="\n".join(text_lines),
@@ -297,6 +310,9 @@ class StellaratorEnvironment(
             p1_score=metrics.p1_score,
             p1_feasibility=metrics.p1_feasibility,
             vacuum_well=metrics.vacuum_well,
+            evaluation_fidelity=metrics.evaluation_fidelity,
+            evaluation_failed=metrics.evaluation_failed,
+            failure_reason=metrics.failure_reason,
             step_number=self._state.step_count,
             budget_remaining=self._state.budget_remaining,
             best_score=self._state.best_score,
@@ -307,16 +323,18 @@ class StellaratorEnvironment(
             done=done,
         )
 
-    # ------------------------------------------------------------------
-    # Action summaries
-    # ------------------------------------------------------------------
-
     def _summary_run(self, action: StellaratorAction, metrics: EvaluationMetrics) -> str:
         assert action.parameter is not None
         assert action.direction is not None
         assert action.magnitude is not None
-        previous_metrics = self._last_metrics or metrics
-        if metrics.constraints_satisfied:
+        if metrics.evaluation_failed:
+            return (
+                f"Applied {action.parameter} {action.direction} {action.magnitude}. "
+                f"Low-fidelity evaluation failed: {metrics.failure_reason}"
+            )
+
+        previous_metrics = self._reference_metrics(metrics)
+        if metrics.constraints_satisfied and previous_metrics.constraints_satisfied:
             delta = previous_metrics.max_elongation - metrics.max_elongation
             objective_summary = (
                 f"max_elongation changed by {delta:+.4f} to {metrics.max_elongation:.4f}."
@@ -327,10 +345,13 @@ class StellaratorEnvironment(
                 f"feasibility changed by {delta:+.6f} to {metrics.p1_feasibility:.6f}."
             )
         return (
-            f"Applied {action.parameter} {action.direction} {action.magnitude}. {objective_summary}"
+            f"Applied {action.parameter} {action.direction} {action.magnitude}. "
+            f"Low-fidelity evaluation. {objective_summary}"
         )
 
     def _summary_submit(self, metrics: EvaluationMetrics) -> str:
+        if metrics.evaluation_failed:
+            return f"Submit failed during high-fidelity evaluation: {metrics.failure_reason}"
         return (
             f"Submitted current_score={metrics.p1_score:.6f}, "
             f"best_seen_score={self._state.best_score:.6f}, "
@@ -338,32 +359,26 @@ class StellaratorEnvironment(
             f"constraints={'SATISFIED' if metrics.constraints_satisfied else 'VIOLATED'}."
         )
 
-    def _initial_params(self, seed: int | None) -> RotatingEllipseParams:
-        if seed is None:
-            return BASELINE_PARAMS
-        rng = Random(seed)
-        return RotatingEllipseParams(
-            aspect_ratio=self._clamp(
-                BASELINE_PARAMS.aspect_ratio + rng.uniform(-0.1, 0.1),
-                parameter="aspect_ratio",
-            ),
-            elongation=self._clamp(
-                BASELINE_PARAMS.elongation + rng.uniform(-0.1, 0.1),
-                parameter="elongation",
-            ),
-            rotational_transform=self._clamp(
-                BASELINE_PARAMS.rotational_transform + rng.uniform(-0.015, 0.015),
-                parameter="rotational_transform",
-            ),
+    def _summary_restore(self, metrics: EvaluationMetrics) -> str:
+        if metrics.evaluation_failed:
+            return f"Restore-best failed during low-fidelity evaluation: {metrics.failure_reason}"
+        return (
+            "Restored the best-known design. "
+            f"Score={metrics.p1_score:.6f}, feasibility={metrics.p1_feasibility:.6f}."
         )
 
+    def _initial_params(self, seed: int | None) -> LowDimBoundaryParams:
+        if seed is None:
+            return RESET_SEEDS[0]
+        return RESET_SEEDS[seed % len(RESET_SEEDS)]
+
     def _apply_action(
         self,
-        params: RotatingEllipseParams,
+        params: LowDimBoundaryParams,
         parameter: str,
         direction: str,
         magnitude: str,
-    ) -> RotatingEllipseParams:
+    ) -> LowDimBoundaryParams:
         delta = PARAMETER_DELTAS[parameter][magnitude]
         signed_delta = delta if direction == "increase" else -delta
 
@@ -372,13 +387,35 @@ class StellaratorEnvironment(
             next_values[parameter] + signed_delta,
             parameter=parameter,
         )
-        return RotatingEllipseParams.model_validate(next_values)
+        return LowDimBoundaryParams.model_validate(next_values)
 
     def _clamp(self, value: float, *, parameter: str) -> float:
         lower, upper = PARAMETER_RANGES[parameter]
         return min(max(value, lower), upper)
 
-    def _update_best(self, params: RotatingEllipseParams, metrics: EvaluationMetrics) -> None:
+    def _evaluate_params(
+        self,
+        params: LowDimBoundaryParams,
+        *,
+        fidelity: str,
+    ) -> EvaluationMetrics:
+        boundary = build_boundary_from_params(
+            params,
+            n_field_periods=N_FIELD_PERIODS,
+        )
+        return evaluate_boundary(boundary, fidelity=fidelity)
+
+    def _reference_metrics(self, fallback: EvaluationMetrics) -> EvaluationMetrics:
+        if self._last_metrics is not None and not self._last_metrics.evaluation_failed:
+            return self._last_metrics
+        if self._last_successful_metrics is not None:
+            return self._last_successful_metrics
+        return fallback
+
+    def _update_best(self, params: LowDimBoundaryParams, metrics: EvaluationMetrics) -> None:
+        if metrics.evaluation_failed:
+            return
+
         current = (
             (1, metrics.p1_score) if metrics.constraints_satisfied else (0, -metrics.p1_feasibility)
         )

server/physics.py

@@ -3,20 +3,27 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Final, Literal
 
+import numpy as np
 from constellaration.forward_model import (
     ConstellarationMetrics,
     ConstellarationSettings,
     forward_model,
 )
+from constellaration.geometry import surface_rz_fourier
+from constellaration.geometry.surface_rz_fourier import SurfaceRZFourier
 from constellaration.initial_guess import generate_rotating_ellipse
 from constellaration.problems import GeometricalProblem
 
-from fusion_lab.models import RotatingEllipseParams
+from fusion_lab.models import LowDimBoundaryParams
 
 ASPECT_RATIO_MAX: Final[float] = 4.0
 AVERAGE_TRIANGULARITY_MAX: Final[float] = -0.5
 EDGE_IOTA_OVER_NFP_MIN: Final[float] = 0.3
 FEASIBILITY_TOLERANCE: Final[float] = 0.01
+MAX_POLOIDAL_MODE: Final[int] = 3
+MAX_TOROIDAL_MODE: Final[int] = 3
+FAILED_FEASIBILITY: Final[float] = 1_000_000.0
+FAILED_ELONGATION: Final[float] = 10.0
 
 EvaluationFidelity = Literal["low", "high"]
 
@@ -31,23 +38,57 @@ class EvaluationMetrics:
     p1_feasibility: float
     constraints_satisfied: bool
     vacuum_well: float
+    evaluation_fidelity: EvaluationFidelity
+    evaluation_failed: bool
+    failure_reason: str
 
 
-def evaluate_params(
-    params: RotatingEllipseParams,
+def build_boundary_from_params(
+    params: LowDimBoundaryParams,
     *,
     n_field_periods: int = 3,
-    fidelity: EvaluationFidelity = "low",
-) -> EvaluationMetrics:
-    boundary = generate_rotating_ellipse(
+    max_poloidal_mode: int = MAX_POLOIDAL_MODE,
+    max_toroidal_mode: int = MAX_TOROIDAL_MODE,
+) -> SurfaceRZFourier:
+    surface = generate_rotating_ellipse(
         aspect_ratio=params.aspect_ratio,
         elongation=params.elongation,
         rotational_transform=params.rotational_transform,
         n_field_periods=n_field_periods,
     )
+    expanded_surface = surface_rz_fourier.set_max_mode_numbers(
+        surface,
+        max_poloidal_mode=max_poloidal_mode,
+        max_toroidal_mode=max_toroidal_mode,
+    )
+    r_cos = np.asarray(expanded_surface.r_cos, dtype=float).copy()
+    z_sin = np.asarray(expanded_surface.z_sin, dtype=float).copy()
+    center = r_cos.shape[1] // 2
+    minor_radius = float(r_cos[1, center])
+
+    r_cos[2, center] = -params.triangularity_scale * minor_radius
+    r_cos[0, :center] = 0.0
+    z_sin[0, : center + 1] = 0.0
+
+    return SurfaceRZFourier(
+        r_cos=r_cos,
+        z_sin=z_sin,
+        n_field_periods=n_field_periods,
+        is_stellarator_symmetric=True,
+    )
+
+
+def evaluate_boundary(
+    boundary: SurfaceRZFourier,
+    *,
+    fidelity: EvaluationFidelity = "low",
+) -> EvaluationMetrics:
     settings = _settings_for_fidelity(fidelity)
-    metrics, _ = forward_model(boundary, settings=settings)
-    return _to_evaluation_metrics(metrics)
+    try:
+        metrics, _ = forward_model(boundary, settings=settings)
+    except RuntimeError as error:
+        return _failure_metrics(fidelity=fidelity, failure_reason=str(error))
+    return _to_evaluation_metrics(metrics, fidelity=fidelity)
 
 
 def _settings_for_fidelity(fidelity: EvaluationFidelity) -> ConstellarationSettings:
@@ -65,7 +106,11 @@ def _settings_for_fidelity(fidelity: EvaluationFidelity) -> ConstellarationSetti
     )
 
 
-def _to_evaluation_metrics(metrics: ConstellarationMetrics) -> EvaluationMetrics:
+def _to_evaluation_metrics(
+    metrics: ConstellarationMetrics,
+    *,
+    fidelity: EvaluationFidelity,
+) -> EvaluationMetrics:
     problem = GeometricalProblem()
     constraints_satisfied = problem.is_feasible(metrics)
     p1_feasibility = float(problem.compute_feasibility(metrics))
@@ -83,6 +128,29 @@ def _to_evaluation_metrics(metrics: ConstellarationMetrics) -> EvaluationMetrics
         p1_feasibility=p1_feasibility,
         constraints_satisfied=constraints_satisfied,
         vacuum_well=float(metrics.vacuum_well),
+        evaluation_fidelity=fidelity,
+        evaluation_failed=False,
+        failure_reason="",
+    )
+
+
+def _failure_metrics(
+    *,
+    fidelity: EvaluationFidelity,
+    failure_reason: str,
+) -> EvaluationMetrics:
+    return EvaluationMetrics(
+        max_elongation=FAILED_ELONGATION,
+        aspect_ratio=0.0,
+        average_triangularity=0.0,
+        edge_iota_over_nfp=0.0,
+        p1_score=0.0,
+        p1_feasibility=FAILED_FEASIBILITY,
+        constraints_satisfied=False,
+        vacuum_well=0.0,
+        evaluation_fidelity=fidelity,
+        evaluation_failed=True,
+        failure_reason=failure_reason,
     )