fix: interference layer, anomaly recommendations, baseline rounding, card limit

FIX 3: InterferenceLayer — pulsed lines between wells <2km apart
  - Red for active-active pairs, gray for inactive
  - Width proportional to combined yield
  - Added to LayerControls as "Interference" checkbox

FIX 5: Differentiated anomaly recommendations by severity
  - >40% decline: "URGENT: Immediate rehabilitation"
  - 25-40%: "Schedule assessment within 2 weeks"
  - 15-25%: "Monitor closely"
  - Sensor fault: "Deploy field team to replace sensor"

FIX 6: Rounded sensor fault baseline to 2 decimal places

FIX 7: Network scan limited to top 10 anomalies + summary card
  when scanning all wells (prevents 30+ card flooding)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: CreatmanCEO

backend/eval/results/openrouter_deepseek_deepseek-chat-v3-0324_results.jsonl

@@ -0,0 +1,19 @@
+{
+  "openrouter/deepseek/deepseek-chat-v3-0324": {
+    "model": "openrouter/deepseek/deepseek-chat-v3-0324",
+    "total_cases": 96,
+    "correct_tool_calls": 66,
+    "accuracy": 0.6875,
+    "schema_valid_count": 38,
+    "schema_compliance": 0.3958333333333333,
+    "latency_p50": 2862.5,
+    "latency_p95": 10011.75,
+    "total_cost_usd": 0.03359899999999999,
+    "cost_per_request": 0.00034998958333333323,
+    "total_tokens_in": 226010,
+    "total_tokens_out": 7001,
+    "avg_tokens_per_request": 2427.1979166666665,
+    "error_count": 0,
+    "error_rate": 0.0
+  }
+}

backend/eval/results/summary.json

@@ -40,7 +40,11 @@ def _detect_debit_decline(df: pd.DataFrame, well_id: str) -> list[AnomalyCard]:
                 value_current=round(mean_q4, 2),
                 value_baseline=round(mean_q1, 2),
                 change_pct=round(change_pct, 1),
-                recommendation="Schedule pump inspection and well rehabilitation assessment",
+                recommendation=(
+                    "URGENT: Immediate well rehabilitation required. Consider reducing pumping rate." if change_pct < -40
+                    else "Schedule pump test and well assessment within 2 weeks." if change_pct < -25
+                    else "Monitor closely. Schedule inspection if decline continues."
+                ),
             ))
     return cards
 
@@ -108,9 +112,9 @@ def _detect_sensor_fault(df: pd.DataFrame, well_id: str) -> list[AnomalyCard]:
                 title=f"Sensor fault in {col}",
                 description=f"{col} shows {max_run} consecutive zero readings — likely sensor malfunction",
                 value_current=0.0,
-                value_baseline=float(np.mean(values[values != 0])) if (values != 0).any() else 0.0,
+                value_baseline=round(float(np.mean(values[values != 0])), 2) if (values != 0).any() else 0.0,
                 change_pct=-100.0,
-                recommendation=f"Inspect {col} sensor; replace if confirmed faulty",
+                recommendation=f"Deploy field team to inspect and replace faulty {col} sensor.",
             ))
     return cards
 
@@ -148,4 +152,25 @@ def detect_anomalies(well_id: str | None = None) -> list[AnomalyCard]:
     severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
     cards.sort(key=lambda c: severity_order.get(c.severity, 4))
 
+    # When scanning all wells, limit output to top anomalies to avoid flooding UI
+    if well_id is None and len(cards) > 10:
+        total = len(cards)
+        by_severity = {}
+        for c in cards:
+            by_severity[c.severity] = by_severity.get(c.severity, 0) + 1
+        summary = ", ".join(f"{v} {k}" for k, v in by_severity.items())
+        # Keep top 10, add summary card
+        cards = cards[:10]
+        cards.append(AnomalyCard(
+            severity="low",
+            well_id="NETWORK",
+            anomaly_type="debit_decline",
+            title=f"Network summary: {total} anomalies detected",
+            description=f"Showing top 10 by severity. Total breakdown: {summary}.",
+            value_current=0,
+            value_baseline=0,
+            change_pct=0,
+            recommendation="Use 'detect_anomalies' on individual wells for detailed analysis.",
+        ))
+
     return cards

backend/tools/detect_anomalies.py

@@ -0,0 +1,75 @@
+'use client';
+
+import { useMemo } from "react";
+import { Source, Layer } from "react-map-gl/maplibre";
+import type { WellsGeoJSON } from "@/types";
+import type { FeatureCollection, LineString } from "geojson";
+
+interface Props {
+  wellsGeoJSON: WellsGeoJSON;
+}
+
+const INTERFERENCE_RADIUS_KM = 2;
+
+function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const R = 6371;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLon = ((lon2 - lon1) * Math.PI) / 180;
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLon / 2) ** 2;
+  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
+export function InterferenceLayer({ wellsGeoJSON }: Props) {
+  const linesGeoJSON = useMemo<FeatureCollection<LineString>>(() => {
+    const features: FeatureCollection<LineString>["features"] = [];
+    const wells = wellsGeoJSON.features;
+
+    for (let i = 0; i < wells.length; i++) {
+      for (let j = i + 1; j < wells.length; j++) {
+        const [lon1, lat1] = wells[i].geometry.coordinates;
+        const [lon2, lat2] = wells[j].geometry.coordinates;
+        const dist = haversineKm(lat1, lon1, lat2, lon2);
+
+        if (dist < INTERFERENCE_RADIUS_KM) {
+          const bothActive = wells[i].properties.status === "active" && wells[j].properties.status === "active";
+          const totalYield = wells[i].properties.current_yield_ls + wells[j].properties.current_yield_ls;
+
+          features.push({
+            type: "Feature",
+            geometry: {
+              type: "LineString",
+              coordinates: [[lon1, lat1], [lon2, lat2]],
+            },
+            properties: {
+              well_a: wells[i].properties.id,
+              well_b: wells[j].properties.id,
+              distance_km: Math.round(dist * 100) / 100,
+              total_yield: totalYield,
+              both_active: bothActive,
+              width: Math.max(1, Math.min(4, totalYield / 15)),
+            },
+          });
+        }
+      }
+    }
+
+    return { type: "FeatureCollection", features };
+  }, [wellsGeoJSON]);
+
+  return (
+    <Source id="interference-lines" type="geojson" data={linesGeoJSON}>
+      <Layer
+        id="interference-lines-layer"
+        type="line"
+        paint={{
+          "line-color": ["case", ["get", "both_active"], "#ef4444", "#9ca3af"],
+          "line-width": ["get", "width"],
+          "line-dasharray": [4, 3],
+          "line-opacity": 0.6,
+        }}
+      />
+    </Source>
+  );
+}

frontend/src/components/Map/InterferenceLayer.tsx

@@ -5,6 +5,7 @@ import { useMapStore } from "@/stores/mapStore";
 const LAYERS = [
   { id: "wells", label: "Wells", icon: "⬤" },
   { id: "depression_cones", label: "Depression Cones", icon: "◎" },
+  { id: "interference", label: "Interference", icon: "⟷" },
 ];
 
 export function LayerControls() {

frontend/src/components/Map/LayerControls.tsx

@@ -9,6 +9,7 @@ import type { WellProperties } from "@/types";
 import { WellPopup } from "./WellPopup";
 import { LayerControls } from "./LayerControls";
 import { DepressionConeLayer } from "./DepressionConeLayer";
+import { InterferenceLayer } from "./InterferenceLayer";
 
 const MAP_STYLE = "https://tiles.openfreemap.org/styles/positron";
 
@@ -154,6 +155,11 @@ export function WellsMap() {
           <DepressionConeLayer wellsGeoJSON={wellsGeoJSON} />
         )}
 
+        {/* Interference lines */}
+        {activeLayers.includes("interference") && wellsGeoJSON && (
+          <InterferenceLayer wellsGeoJSON={wellsGeoJSON} />
+        )}
+
         {/* Well popup */}
         {popupWell && (
           <WellPopup