feat(P3-M2): L0 analytic pre-screening + feasibility-first adaptive search

L0 Pre-screening Engine (app/services/l0_prescreening.py):
- 4 categories: geometric / electrical / thermal / manufacturing
- 14+ constraint checks with margin calculation
- Geometric: diameter range, inner/outer ratio, airgap, magnet thickness, airgap/magnet ratio
- Electrical: current density (natural/forced cooling), slot fill factor, magnetic loading saturation
- Thermal: winding temp (Class F), magnet temp (NdFeB), first-order heat transfer estimate
- Manufacturing: PCB line width/spacing, copper thickness, layer count, via diameter
- FeasibilityReport with pass rate, risk items, constraint margins
- Batch filtering: filter_feasible() separates feasible/infeasible sets

Feasibility-First Search (app/services/feasibility_search.py):
- Pure Python implementation (no numpy/scipy/sklearn dependency)
- Latin Hypercube Sampling (LHS) for initial space coverage
- Active learning batch selection (distance + uncertainty heuristic)
- Constrained feasibility prioritization (L0 pre-screen before solver)
- Local trust region refinement (auto-activate after 3+ feasible points)
- Trust region radius shrinks as search converges (0.3 -> 0.035 in test)
- Convergence detection (stalled / converged / budget_exhausted)
- Search state management with checkpoint support (export_state)
- ParameterRange with normalize/denormalize and step quantization
- SearchPoint with param_hash for deduplication and caching

Search API Routes (app/routers/search.py):
- POST /api/search/l0/check - single parameter set feasibility check
- POST /api/search/l0/filter - batch filter feasible/infeasible
- POST /api/search/create - create new adaptive search run
- GET /api/search/{run_id}/state - current search state summary
- POST /api/search/{run_id}/next-batch - select next batch of points
- POST /api/search/{run_id}/report - report simulation result
- GET /api/search/{run_id}/points - list points (filter by status)
- GET /api/search/{run_id}/export - export full state for checkpoint
- GET /api/search/runs - list all active runs

Verification:
- L0 feasible case: 14/14 checks passed
- L0 infeasible case: correctly identified 4 failures (diameter ratio, airgap, current density, temperature)
- Search test: 3 parameters, 40 budget, 4 batch size
  - Initial batch: 9 pending (3 rejected by L0)
  - Trust region activated after round 1
  - Radius shrunk: 0.300 -> 0.072 -> 0.035
  - Final status: converged
  - Best torque: 75.13 Nm (airgap=0.7, magnet=2.5, current=25.0)
  - 21 feasible points out of 28 total

Per third-party review:
- Default mode is feasibility-first (not fixed full-factorial DoE)
- L0 pre-screening excludes obviously infeasible regions before any simulation
- Active learning balances exploration (distance) and exploitation (trust region)
- Trust region refinement enables local convergence after feasible region found

web/backend/app/main.py

@@ -4,7 +4,7 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from .config import APP_NAME, APP_VERSION, APP_DESCRIPTION, CORS_ORIGINS
 from .database import init_db
-from .routers import projects, plans, experience, generation, analytics, ai
+from .routers import projects, plans, experience, generation, analytics, ai, search
 
 app = FastAPI(
     title=APP_NAME,
@@ -28,6 +28,7 @@ app.include_router(experience.router)
 app.include_router(generation.router)
 app.include_router(analytics.router)
 app.include_router(ai.router)
+app.include_router(search.router)
 
 
 @app.on_event("startup")

web/backend/app/routers/search.py

@@ -0,0 +1,240 @@
+"""Search router - L0 pre-screening and feasibility-first adaptive search (P3-M2)."""
+from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from ..services.l0_prescreening import L0PreScreeningEngine
+from ..services.feasibility_search import FeasibilityFirstSearch, ParameterRange
+
+router = APIRouter(prefix="/api/search", tags=["Search"])
+
+# Global search instances (in-memory, P3-M2 prototype)
+_search_instances: Dict[str, FeasibilityFirstSearch] = {}
+_l0_engine = L0PreScreeningEngine()
+
+
+class L0CheckRequest(BaseModel):
+    """Request for L0 feasibility check."""
+    params: Dict[str, Any] = Field(..., description="Parameter values to check")
+
+
+class L0CheckResponse(BaseModel):
+    """Response for L0 feasibility check."""
+    feasible: bool
+    total_checks: int
+    passed_checks: int
+    failed_checks: int
+    pass_rate: float
+    results: List[Dict[str, Any]]
+    risk_items: List[str]
+
+
+class SearchCreateRequest(BaseModel):
+    """Request to create a new adaptive search."""
+    parameters: List[Dict[str, Any]] = Field(..., description="Parameter range definitions")
+    total_budget: int = Field(default=80, ge=10, le=500)
+    batch_size: int = Field(default=4, ge=1, le=16)
+    initial_samples: int = Field(default=16, ge=4, le=100)
+    objective_metric: str = Field(default="tavg_nm")
+    objective_direction: str = Field(default="maximize")
+    seed: int = Field(default=42)
+
+
+class SearchPointResponse(BaseModel):
+    """Response for a search point."""
+    id: int
+    params: Dict[str, float]
+    status: str
+    metrics: Dict[str, float] = Field(default_factory=dict)
+    batch_id: int
+    feasible: Optional[bool] = None
+
+
+class SearchStateResponse(BaseModel):
+    """Response for search state summary."""
+    run_id: str
+    search_method: str
+    convergence_status: str
+    total_budget: int
+    used_budget: int
+    remaining_budget: int
+    current_batch: int
+    total_points: int
+    pending_points: int
+    completed_points: int
+    feasible_points: int
+    trust_region_active: bool
+    trust_region_radius: float
+    best_objective_value: Optional[float] = None
+    best_point_params: Optional[Dict[str, float]] = None
+
+
+class SearchResultRequest(BaseModel):
+    """Request to report simulation result."""
+    point_id: int
+    metrics: Dict[str, float]
+    status: str = Field(default="ok", description="ok / failed")
+
+
+@router.post("/l0/check", response_model=L0CheckResponse)
+def l0_check(request: L0CheckRequest):
+    """Run L0 analytic pre-screening on a parameter set."""
+    report = _l0_engine.evaluate(request.params)
+    data = report.to_dict()
+    return L0CheckResponse(**data)
+
+
+@router.post("/l0/filter")
+def l0_filter(param_sets: List[Dict[str, Any]]):
+    """Filter a list of parameter sets into feasible and infeasible."""
+    feasible, infeasible = _l0_engine.filter_feasible(param_sets)
+    return {
+        "total": len(param_sets),
+        "feasible_count": len(feasible),
+        "infeasible_count": len(infeasible),
+        "feasible": feasible,
+        "infeasible": infeasible,
+    }
+
+
+@router.post("/create")
+def create_search(request: SearchCreateRequest):
+    """Create a new feasibility-first adaptive search run."""
+    try:
+        parameters = [
+            ParameterRange(
+                name=p["name"],
+                min_value=float(p["min_value"]),
+                max_value=float(p["max_value"]),
+                step=p.get("step"),
+                unit=p.get("unit", ""),
+                description=p.get("description", ""),
+            )
+            for p in request.parameters
+        ]
+    except (KeyError, ValueError) as e:
+        raise HTTPException(status_code=400, detail=f"Invalid parameter definition: {e}")
+
+    search = FeasibilityFirstSearch(
+        parameters=parameters,
+        l0_engine=_l0_engine,
+        total_budget=request.total_budget,
+        batch_size=request.batch_size,
+        initial_samples=request.initial_samples,
+        objective_metric=request.objective_metric,
+        objective_direction=request.objective_direction,
+        seed=request.seed,
+    )
+
+    # Generate initial batch
+    initial_points = search.generate_initial_batch()
+
+    _search_instances[search.state.run_id] = search
+
+    return {
+        "run_id": search.state.run_id,
+        "initial_points": [
+            {"id": p.id, "params": p.params, "status": p.status, "batch_id": p.batch_id}
+            for p in initial_points
+        ],
+        "state": search.get_state_summary(),
+    }
+
+
+@router.get("/{run_id}/state", response_model=SearchStateResponse)
+def get_search_state(run_id: str):
+    """Get current state of a search run."""
+    if run_id not in _search_instances:
+        raise HTTPException(status_code=404, detail=f"Search run {run_id} not found")
+    search = _search_instances[run_id]
+    return SearchStateResponse(**search.get_state_summary())
+
+
+@router.post("/{run_id}/next-batch")
+def next_batch(run_id: str):
+    """Select and return the next batch of points to simulate."""
+    if run_id not in _search_instances:
+        raise HTTPException(status_code=404, detail=f"Search run {run_id} not found")
+    search = _search_instances[run_id]
+
+    points = search.select_next_batch()
+    if not points:
+        return {
+            "run_id": run_id,
+            "batch": [],
+            "convergence_status": search.state.convergence_status,
+            "message": "No more points to select (budget exhausted or converged)",
+        }
+
+    return {
+        "run_id": run_id,
+        "batch_id": search.state.current_batch - 1,
+        "points": [
+            {"id": p.id, "params": p.params, "status": p.status, "batch_id": p.batch_id}
+            for p in points
+        ],
+        "state": search.get_state_summary(),
+    }
+
+
+@router.post("/{run_id}/report")
+def report_result(run_id: str, request: SearchResultRequest):
+    """Report simulation result for a point."""
+    if run_id not in _search_instances:
+        raise HTTPException(status_code=404, detail=f"Search run {run_id} not found")
+    search = _search_instances[run_id]
+    search.report_result(request.point_id, request.metrics, request.status)
+    return {
+        "run_id": run_id,
+        "point_id": request.point_id,
+        "status": "reported",
+        "state": search.get_state_summary(),
+    }
+
+
+@router.get("/{run_id}/points")
+def get_points(run_id: str, status: Optional[str] = None):
+    """Get all points in a search run, optionally filtered by status."""
+    if run_id not in _search_instances:
+        raise HTTPException(status_code=404, detail=f"Search run {run_id} not found")
+    search = _search_instances[run_id]
+
+    points = search.state.points
+    if status:
+        points = [p for p in points if p.status == status]
+
+    return {
+        "run_id": run_id,
+        "total": len(points),
+        "points": [
+            {
+                "id": p.id,
+                "params": p.params,
+                "status": p.status,
+                "metrics": p.metrics,
+                "batch_id": p.batch_id,
+                "feasible": p.feasibility_report.get("feasible") if p.feasibility_report else None,
+            }
+            for p in points
+        ],
+    }
+
+
+@router.get("/{run_id}/export")
+def export_search(run_id: str):
+    """Export full search state for checkpointing."""
+    if run_id not in _search_instances:
+        raise HTTPException(status_code=404, detail=f"Search run {run_id} not found")
+    search = _search_instances[run_id]
+    return search.export_state()
+
+
+@router.get("/runs")
+def list_runs():
+    """List all active search runs."""
+    return {
+        "runs": [
+            {"run_id": run_id, "state": search.get_state_summary()}
+            for run_id, search in _search_instances.items()
+        ],
+    }

web/backend/app/services/feasibility_search.py

@@ -0,0 +1,503 @@
+"""Feasibility-First Search Framework (P3-M2).
+
+Pure Python implementation (no numpy/scipy/sklearn dependency).
+Implements:
+- LHS (Latin Hypercube Sampling) for initial space coverage
+- Active learning batch selection (distance + uncertainty heuristic)
+- Constrained feasibility prioritization
+- Local trust region refinement
+- Search state management with checkpoint support
+
+Per third-party review: default mode is feasibility-first
+(constrained Bayesian / active learning), not fixed full-factorial DoE.
+"""
+import math
+import random
+import hashlib
+import json
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any, Callable
+from datetime import datetime
+
+from .l0_prescreening import L0PreScreeningEngine, FeasibilityReport
+
+
+@dataclass
+class ParameterRange:
+    """Definition of a scan parameter range."""
+    name: str
+    min_value: float
+    max_value: float
+    step: Optional[float] = None  # if set, values are quantized
+    unit: str = ""
+    description: str = ""
+
+    def normalize(self, value: float) -> float:
+        """Normalize value to [0, 1] range."""
+        if self.max_value == self.min_value:
+            return 0.5
+        return (value - self.min_value) / (self.max_value - self.min_value)
+
+    def denormalize(self, norm: float) -> float:
+        """Denormalize from [0, 1] to actual range."""
+        value = self.min_value + norm * (self.max_value - self.min_value)
+        if self.step is not None and self.step > 0:
+            value = round(value / self.step) * self.step
+            value = max(self.min_value, min(self.max_value, value))
+        return value
+
+    def random_value(self, rng: random.Random) -> float:
+        """Generate a random value within range."""
+        return self.denormalize(rng.random())
+
+
+@dataclass
+class SearchPoint:
+    """A single point in the search space."""
+    id: int
+    params: Dict[str, float]
+    status: str = "pending"  # pending / running / ok / failed / infeasible
+    metrics: Dict[str, float] = field(default_factory=dict)
+    feasibility_report: Optional[Dict[str, Any]] = None
+    surrogate_prediction: Optional[float] = None
+    surrogate_uncertainty: Optional[float] = None
+    batch_id: int = 0
+    created_at: str = ""
+
+    def param_hash(self) -> str:
+        """Generate a hash of parameter values for caching/dedup."""
+        sorted_params = sorted(self.params.items())
+        param_str = json.dumps(sorted_params, sort_keys=True)
+        return hashlib.md5(param_str.encode()).hexdigest()[:12]
+
+
+@dataclass
+class SearchState:
+    """Complete state of an adaptive search run."""
+    run_id: str
+    parameters: List[ParameterRange]
+    points: List[SearchPoint] = field(default_factory=list)
+    current_batch: int = 0
+    total_budget: int = 80
+    used_budget: int = 0
+    batch_size: int = 4
+    search_method: str = "active_learning"
+    trust_region_active: bool = False
+    trust_region_center: Optional[Dict[str, float]] = None
+    trust_region_radius: float = 0.3  # fraction of normalized range
+    best_feasible_point: Optional[SearchPoint] = None
+    best_objective_value: float = float('inf')
+    objective_metric: str = "tavg_nm"  # metric to optimize
+    objective_direction: str = "maximize"  # maximize / minimize
+    convergence_status: str = "searching"  # searching / converged / stalled / budget_exhausted
+    history: List[Dict[str, Any]] = field(default_factory=list)
+    created_at: str = ""
+    updated_at: str = ""
+
+    def get_param_names(self) -> List[str]:
+        return [p.name for p in self.parameters]
+
+    def get_param_by_name(self, name: str) -> Optional[ParameterRange]:
+        for p in self.parameters:
+            if p.name == name:
+                return p
+        return None
+
+    def get_pending_points(self) -> List[SearchPoint]:
+        return [p for p in self.points if p.status == "pending"]
+
+    def get_completed_points(self) -> List[SearchPoint]:
+        return [p for p in self.points if p.status in ("ok", "failed", "infeasible")]
+
+    def get_feasible_points(self) -> List[SearchPoint]:
+        return [p for p in self.points if p.status == "ok" and p.feasibility_report and p.feasibility_report.get("feasible", False)]
+
+    def remaining_budget(self) -> int:
+        return self.total_budget - self.used_budget
+
+
+class FeasibilityFirstSearch:
+    """Feasibility-first adaptive search engine.
+
+    Implements the recommended default path from third-party review:
+    L0 pre-screening + initial samples + active learning batch selection
+    + local trust region refinement.
+    """
+
+    def __init__(
+        self,
+        parameters: List[ParameterRange],
+        l0_engine: Optional[L0PreScreeningEngine] = None,
+        total_budget: int = 80,
+        batch_size: int = 4,
+        initial_samples: int = 16,
+        objective_metric: str = "tavg_nm",
+        objective_direction: str = "maximize",
+        seed: int = 42,
+    ):
+        self.rng = random.Random(seed)
+        self.parameters = parameters
+        self.l0_engine = l0_engine or L0PreScreeningEngine()
+        self.total_budget = total_budget
+        self.batch_size = batch_size
+        self.initial_samples = initial_samples
+        self.objective_metric = objective_metric
+        self.objective_direction = objective_direction
+        self.state = SearchState(
+            run_id=f"search_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            parameters=parameters,
+            total_budget=total_budget,
+            batch_size=batch_size,
+            objective_metric=objective_metric,
+            objective_direction=objective_direction,
+            created_at=datetime.now().isoformat(),
+        )
+
+    def latin_hypercube_sample(self, n_samples: int) -> List[Dict[str, float]]:
+        """Generate Latin Hypercube Samples in normalized space.
+
+        Pure Python implementation (no numpy dependency).
+        """
+        n_params = len(self.parameters)
+        # Create n_samples intervals per dimension
+        intervals = []
+        for _ in range(n_params):
+            # Shuffle interval assignments
+            assignments = list(range(n_samples))
+            self.rng.shuffle(assignments)
+            intervals.append(assignments)
+
+        samples = []
+        for i in range(n_samples):
+            sample = {}
+            for j, param in enumerate(self.parameters):
+                # Random point within assigned interval
+                interval_idx = intervals[j][i]
+                norm = (interval_idx + self.rng.random()) / n_samples
+                sample[param.name] = param.denormalize(norm)
+            samples.append(sample)
+        return samples
+
+    def _min_distance_to_existing(self, params: Dict[str, float], existing: List[Dict[str, float]]) -> float:
+        """Calculate minimum normalized Euclidean distance to existing points."""
+        if not existing:
+            return float('inf')
+        min_dist = float('inf')
+        for ex in existing:
+            dist_sq = 0.0
+            for param in self.parameters:
+                v1 = param.normalize(params.get(param.name, param.min_value))
+                v2 = param.normalize(ex.get(param.name, param.min_value))
+                dist_sq += (v1 - v2) ** 2
+            dist = math.sqrt(dist_sq)
+            min_dist = min(min_dist, dist)
+        return min_dist
+
+    def _is_duplicate(self, params: Dict[str, float], existing_points: List[SearchPoint]) -> bool:
+        """Check if parameter set is a duplicate of an existing point."""
+        param_hash = hashlib.md5(
+            json.dumps(sorted(params.items()), sort_keys=True).encode()
+        ).hexdigest()[:12]
+        return any(p.param_hash() == param_hash for p in existing_points)
+
+    def generate_initial_batch(self) -> List[SearchPoint]:
+        """Generate initial LHS samples, filtered by L0 feasibility.
+
+        Prioritizes feasible points but includes some infeasible for
+        boundary learning (active learning needs both classes).
+        """
+        # Generate more samples than needed, then select diverse subset
+        n_candidates = max(self.initial_samples * 3, 20)
+        candidates = self.latin_hypercube_sample(n_candidates)
+
+        # L0 pre-screen all candidates
+        scored = []
+        for params in candidates:
+            report = self.l0_engine.evaluate(params)
+            scored.append((params, report))
+
+        # Separate feasible and infeasible
+        feasible = [(p, r) for p, r in scored if r.feasible]
+        infeasible = [(p, r) for p, r in scored if not r.feasible]
+
+        # Select diverse subset: mostly feasible, some infeasible for boundary
+        n_feasible = min(len(feasible), int(self.initial_samples * 0.75))
+        n_infeasible = min(len(infeasible), self.initial_samples - n_feasible)
+
+        selected = []
+        selected_params = []
+
+        # Greedy max-distance selection for feasible points
+        feasible.sort(key=lambda x: x[1].pass_rate, reverse=True)
+        for params, report in feasible:
+            if len(selected) >= n_feasible:
+                break
+            # Check duplicate against already selected params
+            is_dup = any(
+                hashlib.md5(json.dumps(sorted(p.items()), sort_keys=True).encode()).hexdigest()[:12] ==
+                hashlib.md5(json.dumps(sorted(params.items()), sort_keys=True).encode()).hexdigest()[:12]
+                for p, _ in selected
+            )
+            if not is_dup:
+                dist = self._min_distance_to_existing(params, selected_params)
+                if dist > 0.1 or len(selected) < 3:
+                    selected.append((params, report))
+                    selected_params.append(params)
+
+        # Add infeasible points for boundary learning
+        for params, report in infeasible:
+            if len(selected) >= self.initial_samples:
+                break
+            is_dup = any(
+                hashlib.md5(json.dumps(sorted(p.items()), sort_keys=True).encode()).hexdigest()[:12] ==
+                hashlib.md5(json.dumps(sorted(params.items()), sort_keys=True).encode()).hexdigest()[:12]
+                for p, _ in selected
+            )
+            if not is_dup:
+                selected.append((params, report))
+                selected_params.append(params)
+
+        # Create SearchPoint objects
+        points = []
+        for i, (params, report) in enumerate(selected):
+            point = SearchPoint(
+                id=len(self.state.points) + i,
+                params=params,
+                status="infeasible" if not report.feasible else "pending",
+                feasibility_report=report.to_dict(),
+                batch_id=0,
+                created_at=datetime.now().isoformat(),
+            )
+            if not report.feasible:
+                # Mark as completed (L0 rejected) without using solver budget
+                point.status = "infeasible"
+            points.append(point)
+
+        self.state.points.extend(points)
+        self.state.current_batch = 1
+        self.state.used_budget += sum(1 for p in points if p.status == "pending")
+        self.state.updated_at = datetime.now().isoformat()
+
+        return [p for p in points if p.status == "pending"]
+
+    def select_next_batch(self) -> List[SearchPoint]:
+        """Select next batch of points using active learning.
+
+        Strategy:
+        1. If feasible points found, activate trust region around best
+        2. Select points balancing:
+           - Exploration: high distance from existing points
+           - Exploitation: near best feasible point (trust region)
+           - Uncertainty: points near feasibility boundary
+        3. L0 pre-screen all candidates, reject obviously infeasible
+        """
+        if self.state.remaining_budget() <= 0:
+            self.state.convergence_status = "budget_exhausted"
+            return []
+
+        feasible_points = self.state.get_feasible_points()
+        completed_params = [p.params for p in self.state.get_completed_points()]
+
+        # Activate trust region if we have enough feasible points
+        if len(feasible_points) >= 3 and not self.state.trust_region_active:
+            best = max(feasible_points, key=lambda p: p.metrics.get(self.objective_metric, 0))
+            self.state.trust_region_active = True
+            self.state.trust_region_center = best.params
+            self.state.best_feasible_point = best
+            self.state.history.append({
+                "event": "trust_region_activated",
+                "center": best.params,
+                "batch": self.state.current_batch,
+            })
+
+        # Generate candidates
+        n_candidates = 50
+        candidates = []
+
+        if self.state.trust_region_active and self.state.trust_region_center:
+            # 70% from trust region, 30% from global exploration
+            n_trust = int(n_candidates * 0.7)
+            n_global = n_candidates - n_trust
+
+            # Trust region samples (Gaussian-like around center)
+            for _ in range(n_trust):
+                params = {}
+                for param in self.parameters:
+                    center_norm = param.normalize(self.state.trust_region_center[param.name])
+                    # Sample with decreasing radius as search progresses
+                    radius = self.state.trust_region_radius * max(0.3, 1.0 - self.state.used_budget / self.total_budget)
+                    sample_norm = center_norm + self.rng.gauss(0, radius * 0.3)
+                    sample_norm = max(0.0, min(1.0, sample_norm))
+                    params[param.name] = param.denormalize(sample_norm)
+                candidates.append(params)
+
+            # Global exploration samples
+            candidates.extend(self.latin_hypercube_sample(n_global))
+        else:
+            # No trust region yet: full LHS exploration
+            candidates = self.latin_hypercube_sample(n_candidates)
+
+        # Score and select candidates
+        scored_candidates = []
+        for params in candidates:
+            if self._is_duplicate(params, self.state.points):
+                continue
+
+            # L0 pre-screen
+            report = self.l0_engine.evaluate(params)
+            if not report.feasible:
+                continue  # Skip obviously infeasible
+
+            # Distance score (exploration)
+            dist = self._min_distance_to_existing(params, completed_params)
+            dist_score = min(dist / math.sqrt(len(self.parameters)), 1.0)
+
+            # Trust region proximity score (exploitation)
+            trust_score = 0.0
+            if self.state.trust_region_center:
+                dist_to_center_sq = 0.0
+                for param in self.parameters:
+                    v1 = param.normalize(params[param.name])
+                    v2 = param.normalize(self.state.trust_region_center[param.name])
+                    dist_to_center_sq += (v1 - v2) ** 2
+                dist_to_center = math.sqrt(dist_to_center_sq)
+                trust_score = max(0, 1.0 - dist_to_center / self.state.trust_region_radius)
+
+            # Combined score (balance exploration and exploitation)
+            if self.state.trust_region_active:
+                score = 0.4 * dist_score + 0.6 * trust_score
+            else:
+                score = dist_score
+
+            scored_candidates.append((params, report, score))
+
+        # Sort by score and select top batch_size
+        scored_candidates.sort(key=lambda x: x[2], reverse=True)
+        batch_size = min(self.batch_size, self.state.remaining_budget(), len(scored_candidates))
+
+        selected = []
+        for i in range(batch_size):
+            params, report, score = scored_candidates[i]
+            point = SearchPoint(
+                id=len(self.state.points) + i,
+                params=params,
+                status="pending",
+                feasibility_report=report.to_dict(),
+                batch_id=self.state.current_batch,
+                created_at=datetime.now().isoformat(),
+            )
+            selected.append(point)
+
+        self.state.points.extend(selected)
+        self.state.used_budget += len(selected)
+        self.state.current_batch += 1
+        self.state.updated_at = datetime.now().isoformat()
+
+        return selected
+
+    def report_result(self, point_id: int, metrics: Dict[str, float], status: str = "ok") -> None:
+        """Report simulation result for a point.
+
+        Args:
+            point_id: ID of the search point
+            metrics: Dictionary of metric values
+            status: ok / failed
+        """
+        for point in self.state.points:
+            if point.id == point_id:
+                point.metrics = metrics
+                point.status = status
+
+                # Update best feasible point
+                if status == "ok" and self.objective_metric in metrics:
+                    value = metrics[self.objective_metric]
+                    is_better = (
+                        (self.objective_direction == "maximize" and value > self.state.best_objective_value) or
+                        (self.objective_direction == "minimize" and value < self.state.best_objective_value)
+                    )
+                    if is_better or self.state.best_feasible_point is None:
+                        self.state.best_objective_value = value
+                        self.state.best_feasible_point = point
+
+                # Check convergence
+                self._check_convergence()
+                break
+
+        self.state.updated_at = datetime.now().isoformat()
+
+    def _check_convergence(self) -> None:
+        """Check if search has converged or stalled."""
+        feasible = self.state.get_feasible_points()
+        if len(feasible) < 5:
+            return
+
+        # Check if objective has improved in last N points
+        recent = feasible[-10:] if len(feasible) >= 10 else feasible
+        if len(recent) >= 5:
+            values = [p.metrics.get(self.objective_metric, 0) for p in recent]
+            if self.objective_direction == "maximize":
+                improvement = max(values) - max(values[:-3]) if len(values) > 3 else 0
+            else:
+                improvement = min(values[:-3]) - min(values) if len(values) > 3 else 0
+
+            if improvement < 0.001 and self.state.trust_region_active:
+                # Shrink trust region
+                self.state.trust_region_radius *= 0.7
+                if self.state.trust_region_radius < 0.05:
+                    self.state.convergence_status = "converged"
+                    self.state.history.append({
+                        "event": "converged",
+                        "reason": "trust_region_shrunk_below_threshold",
+                        "batch": self.state.current_batch,
+                    })
+
+    def get_state_summary(self) -> Dict[str, Any]:
+        """Get a summary of current search state."""
+        return {
+            "run_id": self.state.run_id,
+            "search_method": self.state.search_method,
+            "convergence_status": self.state.convergence_status,
+            "total_budget": self.state.total_budget,
+            "used_budget": self.state.used_budget,
+            "remaining_budget": self.state.remaining_budget(),
+            "current_batch": self.state.current_batch,
+            "total_points": len(self.state.points),
+            "pending_points": len(self.state.get_pending_points()),
+            "completed_points": len(self.state.get_completed_points()),
+            "feasible_points": len(self.state.get_feasible_points()),
+            "trust_region_active": self.state.trust_region_active,
+            "trust_region_radius": round(self.state.trust_region_radius, 4),
+            "best_objective_value": self.state.best_objective_value if self.state.best_objective_value != float('inf') else None,
+            "best_point_params": self.state.best_feasible_point.params if self.state.best_feasible_point else None,
+        }
+
+    def export_state(self) -> Dict[str, Any]:
+        """Export full search state for checkpointing."""
+        return {
+            "state": {
+                "run_id": self.state.run_id,
+                "current_batch": self.state.current_batch,
+                "total_budget": self.state.total_budget,
+                "used_budget": self.state.used_budget,
+                "convergence_status": self.state.convergence_status,
+                "trust_region_active": self.state.trust_region_active,
+                "trust_region_center": self.state.trust_region_center,
+                "trust_region_radius": self.state.trust_region_radius,
+                "best_objective_value": self.state.best_objective_value,
+            },
+            "parameters": [
+                {"name": p.name, "min": p.min_value, "max": p.max_value, "step": p.step, "unit": p.unit}
+                for p in self.parameters
+            ],
+            "points": [
+                {
+                    "id": p.id,
+                    "params": p.params,
+                    "status": p.status,
+                    "metrics": p.metrics,
+                    "batch_id": p.batch_id,
+                    "feasible": p.feasibility_report.get("feasible") if p.feasibility_report else None,
+                }
+                for p in self.state.points
+            ],
+        }

web/backend/app/services/l0_prescreening.py

@@ -0,0 +1,412 @@
+"""L0 Analytic Pre-screening Engine (P3-M2).
+
+Per third-party review: L0 analytic + rule-based pre-filtering
+to exclude obviously infeasible regions before any simulation.
+
+Covers:
+- Geometric constraints (inner/outer diameter, airgap, axial length)
+- Electrical constraints (current density, voltage, magnetic loading)
+- Thermal constraints (temperature rise, cooling capacity)
+- Manufacturing constraints (PCB line width/spacing, copper thickness, tolerances)
+"""
+import math
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any
+
+
+@dataclass
+class ConstraintResult:
+    """Result of a single constraint check."""
+    name: str
+    category: str  # geometric / electrical / thermal / manufacturing
+    passed: bool
+    value: Optional[float] = None
+    limit: Optional[float] = None
+    margin: Optional[float] = None  # percentage margin (positive = safe)
+    message: str = ""
+
+
+@dataclass
+class FeasibilityReport:
+    """Complete L0 feasibility report for a parameter set."""
+    feasible: bool
+    total_checks: int
+    passed_checks: int
+    failed_checks: int
+    results: List[ConstraintResult] = field(default_factory=list)
+    risk_items: List[str] = field(default_factory=list)
+
+    @property
+    def pass_rate(self) -> float:
+        return self.passed_checks / self.total_checks if self.total_checks > 0 else 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "feasible": self.feasible,
+            "total_checks": self.total_checks,
+            "passed_checks": self.passed_checks,
+            "failed_checks": self.failed_checks,
+            "pass_rate": round(self.pass_rate, 4),
+            "results": [
+                {
+                    "name": r.name,
+                    "category": r.category,
+                    "passed": r.passed,
+                    "value": r.value,
+                    "limit": r.limit,
+                    "margin_pct": round(r.margin, 2) if r.margin is not None else None,
+                    "message": r.message,
+                }
+                for r in self.results
+            ],
+            "risk_items": self.risk_items,
+        }
+
+
+class L0PreScreeningEngine:
+    """L0 analytic pre-screening engine.
+
+    Uses first-order physics and engineering rules to quickly
+    reject infeasible parameter combinations without simulation.
+    """
+
+    # Default engineering limits (can be overridden per project)
+    DEFAULT_LIMITS = {
+        # Geometric
+        "min_outer_diameter_mm": 20.0,
+        "max_outer_diameter_mm": 500.0,
+        "min_inner_diameter_mm": 5.0,
+        "min_diameter_ratio": 0.2,  # inner/outer
+        "max_diameter_ratio": 0.8,
+        "min_airgap_mm": 0.3,
+        "max_airgap_mm": 5.0,
+        "min_magnet_thickness_mm": 1.0,
+        "max_magnet_thickness_mm": 20.0,
+        # Electrical
+        "max_current_density_amm2": 15.0,  # A/mm^2 (natural convection)
+        "max_current_density_forced_amm2": 25.0,  # A/mm^2 (forced cooling)
+        "min_slot_fill_factor": 0.3,
+        "max_slot_fill_factor": 0.75,
+        "max_magnetic_loading_t": 1.8,  # Tesla (avoid saturation)
+        # Thermal
+        "max_temperature_rise_c": 80.0,  # K (above ambient)
+        "max_winding_temp_c": 150.0,  # Class F
+        "max_magnet_temp_c": 120.0,  # NdFeB N42SH
+        # Manufacturing (PCB)
+        "min_pcb_line_width_mm": 0.1,
+        "min_pcb_line_spacing_mm": 0.1,
+        "min_pcb_copper_thickness_oz": 0.5,
+        "max_pcb_copper_thickness_oz": 6.0,
+        "min_via_diameter_mm": 0.2,
+        "max_pcb_layers": 20,
+    }
+
+    def __init__(self, limits: Optional[Dict[str, float]] = None):
+        self.limits = dict(self.DEFAULT_LIMITS)
+        if limits:
+            self.limits.update(limits)
+
+    def check_geometric(self, params: Dict[str, Any]) -> List[ConstraintResult]:
+        """Check geometric feasibility constraints."""
+        results = []
+        L = self.limits
+
+        outer_d = params.get("outer_diameter_mm")
+        inner_d = params.get("inner_diameter_mm")
+        airgap = params.get("airgap_mm")
+        magnet_thickness = params.get("magnet_thickness_mm")
+
+        # Outer diameter range
+        if outer_d is not None:
+            passed = L["min_outer_diameter_mm"] <= outer_d <= L["max_outer_diameter_mm"]
+            results.append(ConstraintResult(
+                name="outer_diameter_range",
+                category="geometric",
+                passed=passed,
+                value=outer_d,
+                limit=f"{L['min_outer_diameter_mm']}-{L['max_outer_diameter_mm']}",
+                message=f"Outer diameter {outer_d}mm {'within' if passed else 'outside'} valid range",
+            ))
+
+        # Inner diameter and ratio
+        if outer_d is not None and inner_d is not None:
+            ratio = inner_d / outer_d if outer_d > 0 else 0
+            passed = (L["min_inner_diameter_mm"] <= inner_d and
+                      L["min_diameter_ratio"] <= ratio <= L["max_diameter_ratio"])
+            margin = (ratio - L["min_diameter_ratio"]) / L["min_diameter_ratio"] * 100 if ratio >= L["min_diameter_ratio"] else None
+            results.append(ConstraintResult(
+                name="inner_diameter_ratio",
+                category="geometric",
+                passed=passed,
+                value=round(ratio, 3),
+                limit=f"{L['min_diameter_ratio']}-{L['max_diameter_ratio']}",
+                margin=margin,
+                message=f"Inner/outer diameter ratio {ratio:.3f} {'valid' if passed else 'invalid'}",
+            ))
+
+        # Airgap range
+        if airgap is not None:
+            passed = L["min_airgap_mm"] <= airgap <= L["max_airgap_mm"]
+            results.append(ConstraintResult(
+                name="airgap_range",
+                category="geometric",
+                passed=passed,
+                value=airgap,
+                limit=f"{L['min_airgap_mm']}-{L['max_airgap_mm']}",
+                message=f"Airgap {airgap}mm {'within' if passed else 'outside'} valid range",
+            ))
+
+        # Magnet thickness
+        if magnet_thickness is not None:
+            passed = L["min_magnet_thickness_mm"] <= magnet_thickness <= L["max_magnet_thickness_mm"]
+            results.append(ConstraintResult(
+                name="magnet_thickness_range",
+                category="geometric",
+                passed=passed,
+                value=magnet_thickness,
+                limit=f"{L['min_magnet_thickness_mm']}-{L['max_magnet_thickness_mm']}",
+                message=f"Magnet thickness {magnet_thickness}mm {'within' if passed else 'outside'} valid range",
+            ))
+
+        # Airgap vs magnet thickness ratio (engineering rule)
+        if airgap is not None and magnet_thickness is not None:
+            ratio = airgap / magnet_thickness if magnet_thickness > 0 else 0
+            passed = 0.05 <= ratio <= 0.5  # typical: airgap 5-50% of magnet thickness
+            results.append(ConstraintResult(
+                name="airgap_magnet_ratio",
+                category="geometric",
+                passed=passed,
+                value=round(ratio, 3),
+                limit="0.05-0.5",
+                message=f"Airgap/magnet thickness ratio {ratio:.3f} {'reasonable' if passed else 'unusual'}",
+            ))
+
+        return results
+
+    def check_electrical(self, params: Dict[str, Any]) -> List[ConstraintResult]:
+        """Check electrical feasibility constraints."""
+        results = []
+        L = self.limits
+
+        current_density = params.get("current_density_amm2")
+        rms_current = params.get("current_a") or params.get("rms_current_a")
+        conductor_area = params.get("conductor_area_mm2")
+        slot_fill_factor = params.get("slot_fill_factor")
+        magnetic_loading = params.get("magnetic_loading_t") or params.get("airgap_flux_density_t")
+        forced_cooling = params.get("forced_cooling", False)
+
+        # Current density (derived or direct)
+        if current_density is None and rms_current is not None and conductor_area is not None and conductor_area > 0:
+            current_density = rms_current / conductor_area
+
+        if current_density is not None:
+            limit = L["max_current_density_forced_amm2"] if forced_cooling else L["max_current_density_amm2"]
+            passed = current_density <= limit
+            margin = (limit - current_density) / limit * 100 if current_density > 0 else None
+            results.append(ConstraintResult(
+                name="current_density",
+                category="electrical",
+                passed=passed,
+                value=round(current_density, 2),
+                limit=limit,
+                margin=margin,
+                message=f"Current density {current_density:.1f} A/mm^2 {'within' if passed else 'exceeds'} {limit} A/mm^2 limit ({'forced' if forced_cooling else 'natural'} cooling)",
+            ))
+
+        # Slot fill factor
+        if slot_fill_factor is not None:
+            passed = L["min_slot_fill_factor"] <= slot_fill_factor <= L["max_slot_fill_factor"]
+            results.append(ConstraintResult(
+                name="slot_fill_factor",
+                category="electrical",
+                passed=passed,
+                value=slot_fill_factor,
+                limit=f"{L['min_slot_fill_factor']}-{L['max_slot_fill_factor']}",
+                message=f"Slot fill factor {slot_fill_factor:.2f} {'within' if passed else 'outside'} valid range",
+            ))
+
+        # Magnetic loading (saturation check)
+        if magnetic_loading is not None:
+            passed = magnetic_loading <= L["max_magnetic_loading_t"]
+            margin = (L["max_magnetic_loading_t"] - magnetic_loading) / L["max_magnetic_loading_t"] * 100
+            results.append(ConstraintResult(
+                name="magnetic_loading",
+                category="electrical",
+                passed=passed,
+                value=round(magnetic_loading, 3),
+                limit=L["max_magnetic_loading_t"],
+                margin=margin,
+                message=f"Magnetic loading {magnetic_loading:.2f}T {'below' if passed else 'exceeds'} {L['max_magnetic_loading_t']}T saturation limit",
+            ))
+
+        return results
+
+    def check_thermal(self, params: Dict[str, Any]) -> List[ConstraintResult]:
+        """Check thermal feasibility constraints (first-order estimates)."""
+        results = []
+        L = self.limits
+
+        ambient_temp = params.get("ambient_temp_c", 25.0)
+        winding_temp = params.get("winding_temp_c")
+        magnet_temp = params.get("magnet_temp_c")
+        total_losses_w = params.get("total_losses_w")
+        cooling_area_mm2 = params.get("cooling_area_mm2")
+
+        # Winding temperature limit
+        if winding_temp is not None:
+            passed = winding_temp <= L["max_winding_temp_c"]
+            margin = (L["max_winding_temp_c"] - winding_temp) / L["max_winding_temp_c"] * 100
+            results.append(ConstraintResult(
+                name="winding_temperature",
+                category="thermal",
+                passed=passed,
+                value=winding_temp,
+                limit=L["max_winding_temp_c"],
+                margin=margin,
+                message=f"Winding temperature {winding_temp}C {'below' if passed else 'exceeds'} {L['max_winding_temp_c']}C limit (Class F)",
+            ))
+
+        # Magnet temperature limit
+        if magnet_temp is not None:
+            passed = magnet_temp <= L["max_magnet_temp_c"]
+            margin = (L["max_magnet_temp_c"] - magnet_temp) / L["max_magnet_temp_c"] * 100
+            results.append(ConstraintResult(
+                name="magnet_temperature",
+                category="thermal",
+                passed=passed,
+                value=magnet_temp,
+                limit=L["max_magnet_temp_c"],
+                margin=margin,
+                message=f"Magnet temperature {magnet_temp}C {'below' if passed else 'exceeds'} {L['max_magnet_temp_c']}C limit (NdFeB N42SH)",
+            ))
+
+        # First-order thermal estimate: losses vs cooling capacity
+        if total_losses_w is not None and cooling_area_mm2 is not None and cooling_area_mm2 > 0:
+            # Rough heat transfer coefficient: 10 W/m^2K (natural), 50 W/m^2K (forced)
+            forced = params.get("forced_cooling", False)
+            h = 50.0 if forced else 10.0  # W/m^2K
+            cooling_area_m2 = cooling_area_mm2 / 1e6
+            temp_rise = total_losses_w / (h * cooling_area_m2) if cooling_area_m2 > 0 else float('inf')
+            passed = temp_rise <= L["max_temperature_rise_c"]
+            results.append(ConstraintResult(
+                name="thermal_estimate",
+                category="thermal",
+                passed=passed,
+                value=round(temp_rise, 1),
+                limit=L["max_temperature_rise_c"],
+                message=f"Estimated temperature rise {temp_rise:.1f}K {'within' if passed else 'exceeds'} {L['max_temperature_rise_c']}K limit (rough estimate, needs L2 verification)",
+            ))
+
+        return results
+
+    def check_manufacturing(self, params: Dict[str, Any]) -> List[ConstraintResult]:
+        """Check PCB manufacturing constraints."""
+        results = []
+        L = self.limits
+
+        pcb_line_width = params.get("pcb_line_width_mm")
+        pcb_line_spacing = params.get("pcb_line_spacing_mm")
+        pcb_copper_thickness_oz = params.get("pcb_copper_thickness_oz")
+        pcb_layers = params.get("pcb_layers")
+        via_diameter = params.get("via_diameter_mm")
+
+        if pcb_line_width is not None:
+            passed = pcb_line_width >= L["min_pcb_line_width_mm"]
+            results.append(ConstraintResult(
+                name="pcb_line_width",
+                category="manufacturing",
+                passed=passed,
+                value=pcb_line_width,
+                limit=L["min_pcb_line_width_mm"],
+                message=f"PCB line width {pcb_line_width}mm {'meets' if passed else 'below'} {L['min_pcb_line_width_mm']}mm minimum",
+            ))
+
+        if pcb_line_spacing is not None:
+            passed = pcb_line_spacing >= L["min_pcb_line_spacing_mm"]
+            results.append(ConstraintResult(
+                name="pcb_line_spacing",
+                category="manufacturing",
+                passed=passed,
+                value=pcb_line_spacing,
+                limit=L["min_pcb_line_spacing_mm"],
+                message=f"PCB line spacing {pcb_line_spacing}mm {'meets' if passed else 'below'} {L['min_pcb_line_spacing_mm']}mm minimum",
+            ))
+
+        if pcb_copper_thickness_oz is not None:
+            passed = L["min_pcb_copper_thickness_oz"] <= pcb_copper_thickness_oz <= L["max_pcb_copper_thickness_oz"]
+            results.append(ConstraintResult(
+                name="pcb_copper_thickness",
+                category="manufacturing",
+                passed=passed,
+                value=pcb_copper_thickness_oz,
+                limit=f"{L['min_pcb_copper_thickness_oz']}-{L['max_pcb_copper_thickness_oz']}",
+                message=f"PCB copper thickness {pcb_copper_thickness_oz}oz {'within' if passed else 'outside'} standard range",
+            ))
+
+        if pcb_layers is not None:
+            passed = pcb_layers <= L["max_pcb_layers"]
+            results.append(ConstraintResult(
+                name="pcb_layer_count",
+                category="manufacturing",
+                passed=passed,
+                value=pcb_layers,
+                limit=L["max_pcb_layers"],
+                message=f"PCB layer count {pcb_layers} {'within' if passed else 'exceeds'} {L['max_pcb_layers']} layer limit",
+            ))
+
+        return results
+
+    def evaluate(self, params: Dict[str, Any]) -> FeasibilityReport:
+        """Run full L0 pre-screening on a parameter set.
+
+        Args:
+            params: Dictionary of parameter values (diameters, airgap, currents, etc.)
+
+        Returns:
+            FeasibilityReport with all check results and overall feasibility.
+        """
+        all_results = []
+        all_results.extend(self.check_geometric(params))
+        all_results.extend(self.check_electrical(params))
+        all_results.extend(self.check_thermal(params))
+        all_results.extend(self.check_manufacturing(params))
+
+        passed = sum(1 for r in all_results if r.passed)
+        failed = len(all_results) - passed
+        feasible = failed == 0
+
+        # Collect risk items (failed or low-margin checks)
+        risk_items = []
+        for r in all_results:
+            if not r.passed:
+                risk_items.append(f"[FAIL] {r.name}: {r.message}")
+            elif r.margin is not None and r.margin < 10:
+                risk_items.append(f"[RISK] {r.name}: margin only {r.margin:.1f}%")
+
+        return FeasibilityReport(
+            feasible=feasible,
+            total_checks=len(all_results),
+            passed_checks=passed,
+            failed_checks=failed,
+            results=all_results,
+            risk_items=risk_items,
+        )
+
+    def is_feasible(self, params: Dict[str, Any]) -> bool:
+        """Quick feasibility check (boolean only)."""
+        return self.evaluate(params).feasible
+
+    def filter_feasible(self, param_sets: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+        """Filter a list of parameter sets into feasible and infeasible.
+
+        Returns:
+            Tuple of (feasible_sets, infeasible_sets)
+        """
+        feasible = []
+        infeasible = []
+        for params in param_sets:
+            if self.is_feasible(params):
+                feasible.append(params)
+            else:
+                infeasible.append(params)
+        return feasible, infeasible