Deploy FieldOps Service Parts & Field Operations Optimizer

README.md

@@ -1,10 +1,14 @@
----
-title: Service Parts Field Operations Optimizer
-emoji: 👀
-colorFrom: pink
-colorTo: red
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: FieldOps — Service Parts & Field Operations Optimizer
+emoji: 🛠️
+colorFrom: blue
+colorTo: indigo
+sdk: static
+pinned: false
+license: apache-2.0
+short_description: Field service parts, routing & inventory optimizer
+---
+
+# FieldOps Static Explorer
+
+Pre-computed optimization results from the FieldOps predict-then-optimize engine.

assets/demo/benchmarks.json

@@ -0,0 +1,57 @@
+[
+  {
+    "industry": "industrial_equipment",
+    "stress": "baseline",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 100.0,
+    "mttr_hours": 4.31,
+    "ftf_rate_pct": 100.0,
+    "logistics_cost": 597.53,
+    "downtime_cost": 17622.45,
+    "solve_time_sec": 0.011503599991556257
+  },
+  {
+    "industry": "medical_equipment",
+    "stress": "emergency_surge",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 0.0,
+    "mttr_hours": 4.94,
+    "ftf_rate_pct": 66.7,
+    "logistics_cost": 284.58,
+    "downtime_cost": 44212.55,
+    "solve_time_sec": 0.006099400023231283
+  },
+  {
+    "industry": "telecom",
+    "stress": "parts_shortage",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 90.0,
+    "mttr_hours": 4.2,
+    "ftf_rate_pct": 80.0,
+    "logistics_cost": 1170.53,
+    "downtime_cost": 58191.35,
+    "solve_time_sec": 0.006857800006400794
+  },
+  {
+    "industry": "data_center",
+    "stress": "technician_shortage",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 0.0,
+    "mttr_hours": 4.61,
+    "ftf_rate_pct": 83.3,
+    "logistics_cost": 217.76,
+    "downtime_cost": 38117.22,
+    "solve_time_sec": 0.0037087000091560185
+  },
+  {
+    "industry": "elevators",
+    "stress": "peak_season",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 11.1,
+    "mttr_hours": 4.71,
+    "ftf_rate_pct": 77.8,
+    "logistics_cost": 566.36,
+    "downtime_cost": 25018.85,
+    "solve_time_sec": 0.00974899998982437
+  }
+]

assets/demo/summary.json

@@ -0,0 +1,15 @@
+{
+  "project": "FieldOps",
+  "version": "1.0.0",
+  "scenarios": 5,
+  "algorithms": 7,
+  "primary_metrics": [
+    "sla_compliance_pct",
+    "mean_time_to_repair_hours",
+    "first_time_fix_rate_pct",
+    "emergency_stockout_count",
+    "technician_utilization_pct",
+    "total_logistics_cost",
+    "total_downtime_cost"
+  ]
+}

assets/samples/sample_data_center.json

@@ -0,0 +1,321 @@
+{
+  "industry": "data_center",
+  "stress": "technician_shortage",
+  "scenario_label": "Data Center \u2014 Technician Shortage",
+  "summary": {
+    "sites": 6,
+    "technicians": 5,
+    "warehouses": 2,
+    "requests": 6
+  },
+  "optimization": {
+    "strategy": "two_stage_stochastic",
+    "algorithm": "two_stage_stochastic_programming",
+    "stage1_plan": {
+      "technician_positions": {
+        "T-01": [
+          50.97447733372627,
+          11.76305897995824
+        ],
+        "T-02": [
+          50.97447733372627,
+          11.76305897995824
+        ],
+        "T-03": [
+          50.97447733372627,
+          11.76305897995824
+        ],
+        "T-04": [
+          50.97447733372627,
+          11.76305897995824
+        ],
+        "T-05": [
+          50.97447733372627,
+          11.76305897995824
+        ]
+      },
+      "inventory_targets": [
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-005",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-005",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        }
+      ],
+      "supply_contracts": [
+        {
+          "warehouse": "WH-01",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        }
+      ],
+      "repair_shop_capacity": 2,
+      "total_holding_cost": 1765.0866473281349,
+      "notes": [
+        "Stock vs expedite ratio: 50% (higher = more pre-positioned inventory).",
+        "Multi-echelon targets across 2 warehouses.",
+        "Estimated holding cost: $1,765 over 7 days."
+      ]
+    },
+    "assignments": [
+      {
+        "request_id": "SR-0004",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-01",
+        "part_id": "P-005",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 0.9399564376072906,
+        "estimated_completion_hours": 4.18995643760729,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 93%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0005",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-02",
+        "part_id": "P-001",
+        "part_source": "deferred",
+        "route_order": 2,
+        "scheduled_start_hours": 4.015667316280312,
+        "estimated_arrival_hours": 11.388180930767685,
+        "estimated_completion_hours": 15.988180930767685,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 93%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0003",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-01",
+        "part_id": "P-005",
+        "part_source": "warehouse_stock",
+        "route_order": 3,
+        "scheduled_start_hours": 15.287192016851948,
+        "estimated_arrival_hours": 22.408510752185045,
+        "estimated_completion_hours": 25.288510752185044,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Emergency \u2014 skill match 102%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0001",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-01",
+        "part_id": "P-001",
+        "part_source": "warehouse_stock",
+        "route_order": 4,
+        "scheduled_start_hours": 18.16719201685195,
+        "estimated_arrival_hours": 25.288510752185044,
+        "estimated_completion_hours": 28.828510752185043,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 93%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0006",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-01",
+        "part_id": "P-005",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 4.603596172719693,
+        "estimated_completion_hours": 7.813596172719693,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 99%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0002",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-01",
+        "part_id": "P-005",
+        "part_source": "warehouse_stock",
+        "route_order": 2,
+        "scheduled_start_hours": 3.2100630923173323,
+        "estimated_arrival_hours": 10.642771892204166,
+        "estimated_completion_hours": 12.392771892204166,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 99%, part via warehouse_stock"
+      }
+    ],
+    "ml_predictions": [
+      {
+        "request_id": "SR-0001",
+        "site_id": "S-004",
+        "failure_probability": 0.2315,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 3.54,
+        "first_time_fix_probability": 0.7326,
+        "revisit_probability": 0.2273,
+        "confidence": 0.8963,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0002",
+        "site_id": "S-001",
+        "failure_probability": 0.0879,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 1.75,
+        "first_time_fix_probability": 0.8723,
+        "revisit_probability": 0.1086,
+        "confidence": 0.8676,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0003",
+        "site_id": "S-004",
+        "failure_probability": 0.4256,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 2.88,
+        "first_time_fix_probability": 0.7851,
+        "revisit_probability": 0.1827,
+        "confidence": 0.9351,
+        "risk_tier": "medium"
+      },
+      {
+        "request_id": "SR-0004",
+        "site_id": "S-001",
+        "failure_probability": 0.098,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 3.25,
+        "first_time_fix_probability": 0.812,
+        "revisit_probability": 0.1598,
+        "confidence": 0.8696,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0005",
+        "site_id": "S-002",
+        "failure_probability": 0.1279,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 4.6,
+        "first_time_fix_probability": 0.691,
+        "revisit_probability": 0.2626,
+        "confidence": 0.8756,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0006",
+        "site_id": "S-003",
+        "failure_probability": 0.1347,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 3.21,
+        "first_time_fix_probability": 0.809,
+        "revisit_probability": 0.1624,
+        "confidence": 0.8769,
+        "risk_tier": "low"
+      }
+    ],
+    "metrics": {
+      "sla_compliance_pct": 0.0,
+      "mean_time_to_repair_hours": 4.61,
+      "first_time_fix_rate_pct": 83.3,
+      "emergency_stockout_count": 0,
+      "technician_utilization_pct": 33.3,
+      "total_logistics_cost": 217.76,
+      "total_downtime_cost": 38117.22,
+      "total_holding_cost": 1765.09,
+      "expedite_shipments": 0
+    },
+    "simulation": {
+      "replications": 30,
+      "sla_compliance_mean": 0.0,
+      "mttr_mean": 4.68,
+      "stockout_rate": 0.0,
+      "avg_logistics_cost": 222.06,
+      "avg_downtime_cost": 45215.93,
+      "confidence_interval_95": {
+        "sla_compliance": [
+          0.0,
+          0.0
+        ],
+        "mttr": [
+          4.54,
+          4.82
+        ],
+        "logistics_cost": [
+          218.66,
+          225.45
+        ]
+      }
+    },
+    "solve_time_sec": 0.0037087000091560185,
+    "status": "optimal",
+    "notes": [
+      "Two-stage stochastic: 20 SAA scenarios evaluated.",
+      "Stage 1: multi-echelon inventory + technician positioning.",
+      "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+      "Monte Carlo (30 runs): SLA 0.0%, MTTR 4.7h."
+    ]
+  }
+}

assets/samples/sample_elevators.json

@@ -0,0 +1,416 @@
+{
+  "industry": "elevators",
+  "stress": "peak_season",
+  "scenario_label": "Elevators & Lifts \u2014 Peak Season",
+  "summary": {
+    "sites": 18,
+    "technicians": 10,
+    "warehouses": 2,
+    "requests": 9
+  },
+  "optimization": {
+    "strategy": "two_stage_stochastic",
+    "algorithm": "two_stage_stochastic_programming",
+    "stage1_plan": {
+      "technician_positions": {
+        "T-01": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-02": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-03": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-04": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-05": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-06": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-07": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-08": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-09": [
+          50.73799305374447,
+          11.603656687362223
+        ],
+        "T-10": [
+          50.73799305374447,
+          11.603656687362223
+        ]
+      },
+      "inventory_targets": [
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-002",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-001",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-006",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-002",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-001",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-006",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        }
+      ],
+      "supply_contracts": [
+        {
+          "warehouse": "WH-01",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        }
+      ],
+      "repair_shop_capacity": 3,
+      "total_holding_cost": 2129.891162348705,
+      "notes": [
+        "Stock vs expedite ratio: 50% (higher = more pre-positioned inventory).",
+        "Multi-echelon targets across 2 warehouses.",
+        "Estimated holding cost: $2,130 over 7 days."
+      ]
+    },
+    "assignments": [
+      {
+        "request_id": "SR-0002",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-01",
+        "part_id": "P-002",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 4.471727329434108,
+        "estimated_completion_hours": 9.051727329434108,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 99%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0004",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-01",
+        "part_id": "P-001",
+        "part_source": "deferred",
+        "route_order": 2,
+        "scheduled_start_hours": 8.218847521029023,
+        "estimated_arrival_hours": 16.112410451298178,
+        "estimated_completion_hours": 20.562410451298177,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 99%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0009",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-02",
+        "part_id": "P-006",
+        "part_source": "warehouse_stock",
+        "route_order": 3,
+        "scheduled_start_hours": 17.328286148354728,
+        "estimated_arrival_hours": 23.120365200771747,
+        "estimated_completion_hours": 24.870365200771747,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 99%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0008",
+        "technician_id": "T-06",
+        "technician_name": "Tech F",
+        "warehouse_id": "WH-01",
+        "part_id": "P-004",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 0.5885734974225917,
+        "estimated_completion_hours": 4.178573497422591,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0003",
+        "technician_id": "T-06",
+        "technician_name": "Tech F",
+        "warehouse_id": "WH-02",
+        "part_id": "P-001",
+        "part_source": "deferred",
+        "route_order": 2,
+        "scheduled_start_hours": 3.609688002162164,
+        "estimated_arrival_hours": 13.281694759502987,
+        "estimated_completion_hours": 16.961694759502986,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0001",
+        "technician_id": "T-09",
+        "technician_name": "Tech I",
+        "warehouse_id": "WH-01",
+        "part_id": "P-002",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 0.9863209197037524,
+        "estimated_completion_hours": 4.576320919703752,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 94%, part via warehouse_stock"
+      }
+    ],
+    "ml_predictions": [
+      {
+        "request_id": "SR-0001",
+        "site_id": "S-009",
+        "failure_probability": 0.1978,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.59,
+        "first_time_fix_probability": 0.7352,
+        "revisit_probability": 0.2251,
+        "confidence": 0.8896,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0002",
+        "site_id": "S-018",
+        "failure_probability": 0.1394,
+        "predicted_part_type": "sensor_module",
+        "predicted_duration_hours": 4.58,
+        "first_time_fix_probability": 0.6902,
+        "revisit_probability": 0.2633,
+        "confidence": 0.8779,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0003",
+        "site_id": "S-007",
+        "failure_probability": 0.1235,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.68,
+        "first_time_fix_probability": 0.7407,
+        "revisit_probability": 0.2204,
+        "confidence": 0.8747,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0004",
+        "site_id": "S-009",
+        "failure_probability": 0.221,
+        "predicted_part_type": "sensor_module",
+        "predicted_duration_hours": 4.45,
+        "first_time_fix_probability": 0.6845,
+        "revisit_probability": 0.2681,
+        "confidence": 0.8942,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0005",
+        "site_id": "S-010",
+        "failure_probability": 0.4651,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.24,
+        "first_time_fix_probability": 0.7151,
+        "revisit_probability": 0.2421,
+        "confidence": 0.943,
+        "risk_tier": "medium"
+      },
+      {
+        "request_id": "SR-0006",
+        "site_id": "S-002",
+        "failure_probability": 0.287,
+        "predicted_part_type": "bearing_kit",
+        "predicted_duration_hours": 3.04,
+        "first_time_fix_probability": 0.7965,
+        "revisit_probability": 0.173,
+        "confidence": 0.9074,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0007",
+        "site_id": "S-017",
+        "failure_probability": 0.6365,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.03,
+        "first_time_fix_probability": 0.7023,
+        "revisit_probability": 0.2531,
+        "confidence": 0.9227,
+        "risk_tier": "high"
+      },
+      {
+        "request_id": "SR-0008",
+        "site_id": "S-008",
+        "failure_probability": 0.1978,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 3.59,
+        "first_time_fix_probability": 0.7352,
+        "revisit_probability": 0.2251,
+        "confidence": 0.8896,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0009",
+        "site_id": "S-014",
+        "failure_probability": 0.0903,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 1.75,
+        "first_time_fix_probability": 0.8721,
+        "revisit_probability": 0.1088,
+        "confidence": 0.8681,
+        "risk_tier": "low"
+      }
+    ],
+    "metrics": {
+      "sla_compliance_pct": 11.1,
+      "mean_time_to_repair_hours": 4.71,
+      "first_time_fix_rate_pct": 77.8,
+      "emergency_stockout_count": 0,
+      "technician_utilization_pct": 22.5,
+      "total_logistics_cost": 566.36,
+      "total_downtime_cost": 25018.85,
+      "total_holding_cost": 2129.89,
+      "expedite_shipments": 0
+    },
+    "simulation": {
+      "replications": 30,
+      "sla_compliance_mean": 17.8,
+      "mttr_mean": 4.91,
+      "stockout_rate": 0.0,
+      "avg_logistics_cost": 462.09,
+      "avg_downtime_cost": 8404.96,
+      "confidence_interval_95": {
+        "sla_compliance": [
+          16.3,
+          19.31
+        ],
+        "mttr": [
+          4.78,
+          5.04
+        ],
+        "logistics_cost": [
+          455.11,
+          469.07
+        ]
+      }
+    },
+    "solve_time_sec": 0.00974899998982437,
+    "status": "optimal",
+    "notes": [
+      "Two-stage stochastic: 20 SAA scenarios evaluated.",
+      "Stage 1: multi-echelon inventory + technician positioning.",
+      "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+      "Monte Carlo (30 runs): SLA 17.8%, MTTR 4.9h."
+    ]
+  }
+}

assets/samples/sample_industrial_equipment.json

@@ -0,0 +1,395 @@
+{
+  "industry": "industrial_equipment",
+  "stress": "baseline",
+  "scenario_label": "Industrial Equipment \u2014 Baseline Demand",
+  "summary": {
+    "sites": 12,
+    "technicians": 8,
+    "warehouses": 3,
+    "requests": 6
+  },
+  "optimization": {
+    "strategy": "two_stage_stochastic",
+    "algorithm": "two_stage_stochastic_programming",
+    "stage1_plan": {
+      "technician_positions": {
+        "T-01": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-02": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-03": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-04": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-05": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-06": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-07": [
+          50.851132588450646,
+          11.498955066615594
+        ],
+        "T-08": [
+          50.851132588450646,
+          11.498955066615594
+        ]
+      },
+      "inventory_targets": [
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-005",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-002",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-005",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-002",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-005",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-002",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        }
+      ],
+      "supply_contracts": [
+        {
+          "warehouse": "WH-01",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        }
+      ],
+      "repair_shop_capacity": 2,
+      "total_holding_cost": 1644.4361424549948,
+      "notes": [
+        "Stock vs expedite ratio: 50% (higher = more pre-positioned inventory).",
+        "Multi-echelon targets across 3 warehouses.",
+        "Estimated holding cost: $1,644 over 7 days."
+      ]
+    },
+    "assignments": [
+      {
+        "request_id": "SR-0006",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-02",
+        "part_id": "P-002",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 0.6553569009603153,
+        "estimated_completion_hours": 4.245356900960315,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 89%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0005",
+        "technician_id": "T-04",
+        "technician_name": "Tech D",
+        "warehouse_id": "WH-01",
+        "part_id": "P-003",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 0.7832393948734134,
+        "estimated_completion_hours": 2.3932393948734134,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 95%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0002",
+        "technician_id": "T-04",
+        "technician_name": "Tech D",
+        "warehouse_id": "WH-01",
+        "part_id": "P-004",
+        "part_source": "deferred",
+        "route_order": 2,
+        "scheduled_start_hours": 1.674930030939441,
+        "estimated_arrival_hours": 6.747959255100246,
+        "estimated_completion_hours": 9.837959255100245,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0003",
+        "technician_id": "T-04",
+        "technician_name": "Tech D",
+        "warehouse_id": "WH-03",
+        "part_id": "P-001",
+        "part_source": "deferred",
+        "route_order": 3,
+        "scheduled_start_hours": 5.567661069863554,
+        "estimated_arrival_hours": 13.851400960258042,
+        "estimated_completion_hours": 17.441400960258044,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0001",
+        "technician_id": "T-04",
+        "technician_name": "Tech D",
+        "warehouse_id": "WH-02",
+        "part_id": "P-005",
+        "part_source": "warehouse_stock",
+        "route_order": 4,
+        "scheduled_start_hours": 15.758638309028454,
+        "estimated_arrival_hours": 24.623161217266052,
+        "estimated_completion_hours": 27.783161217266052,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 95%, part via warehouse_stock"
+      }
+    ],
+    "ml_predictions": [
+      {
+        "request_id": "SR-0001",
+        "site_id": "S-002",
+        "failure_probability": 0.1751,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 3.16,
+        "first_time_fix_probability": 0.8056,
+        "revisit_probability": 0.1652,
+        "confidence": 0.885,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0002",
+        "site_id": "S-010",
+        "failure_probability": 0.2405,
+        "predicted_part_type": "control_board",
+        "predicted_duration_hours": 3.09,
+        "first_time_fix_probability": 0.8003,
+        "revisit_probability": 0.1698,
+        "confidence": 0.8981,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0003",
+        "site_id": "S-011",
+        "failure_probability": 0.1978,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.59,
+        "first_time_fix_probability": 0.7352,
+        "revisit_probability": 0.2251,
+        "confidence": 0.8896,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0004",
+        "site_id": "S-011",
+        "failure_probability": 0.3775,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.36,
+        "first_time_fix_probability": 0.7217,
+        "revisit_probability": 0.2366,
+        "confidence": 0.9255,
+        "risk_tier": "medium"
+      },
+      {
+        "request_id": "SR-0005",
+        "site_id": "S-004",
+        "failure_probability": 0.3208,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 1.61,
+        "first_time_fix_probability": 0.8518,
+        "revisit_probability": 0.126,
+        "confidence": 0.9142,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0006",
+        "site_id": "S-002",
+        "failure_probability": 0.1978,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.59,
+        "first_time_fix_probability": 0.7352,
+        "revisit_probability": 0.2251,
+        "confidence": 0.8896,
+        "risk_tier": "low"
+      }
+    ],
+    "metrics": {
+      "sla_compliance_pct": 100.0,
+      "mean_time_to_repair_hours": 4.31,
+      "first_time_fix_rate_pct": 100.0,
+      "emergency_stockout_count": 0,
+      "technician_utilization_pct": 15.8,
+      "total_logistics_cost": 597.53,
+      "total_downtime_cost": 17622.45,
+      "total_holding_cost": 1644.44,
+      "expedite_shipments": 0
+    },
+    "simulation": {
+      "replications": 30,
+      "sla_compliance_mean": 100.0,
+      "mttr_mean": 4.33,
+      "stockout_rate": 0.0,
+      "avg_logistics_cost": 543.76,
+      "avg_downtime_cost": 14486.99,
+      "confidence_interval_95": {
+        "sla_compliance": [
+          100.0,
+          100.0
+        ],
+        "mttr": [
+          4.2,
+          4.46
+        ],
+        "logistics_cost": [
+          535.44,
+          552.07
+        ]
+      }
+    },
+    "solve_time_sec": 0.011503599991556257,
+    "status": "optimal",
+    "notes": [
+      "Two-stage stochastic: 20 SAA scenarios evaluated.",
+      "Stage 1: multi-echelon inventory + technician positioning.",
+      "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+      "Monte Carlo (30 runs): SLA 100.0%, MTTR 4.3h."
+    ]
+  }
+}

assets/samples/sample_medical_equipment.json

@@ -0,0 +1,293 @@
+{
+  "industry": "medical_equipment",
+  "stress": "emergency_surge",
+  "scenario_label": "Medical Equipment \u2014 Emergency Surge",
+  "summary": {
+    "sites": 10,
+    "technicians": 6,
+    "warehouses": 2,
+    "requests": 6
+  },
+  "optimization": {
+    "strategy": "two_stage_stochastic",
+    "algorithm": "two_stage_stochastic_programming",
+    "stage1_plan": {
+      "technician_positions": {
+        "T-01": [
+          50.830218050411915,
+          11.245464134292025
+        ],
+        "T-02": [
+          50.830218050411915,
+          11.245464134292025
+        ],
+        "T-03": [
+          50.830218050411915,
+          11.245464134292025
+        ],
+        "T-04": [
+          50.830218050411915,
+          11.245464134292025
+        ],
+        "T-05": [
+          50.830218050411915,
+          11.245464134292025
+        ],
+        "T-06": [
+          50.830218050411915,
+          11.245464134292025
+        ]
+      },
+      "inventory_targets": [
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-001",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-006",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-001",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-006",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        }
+      ],
+      "supply_contracts": [
+        {
+          "warehouse": "WH-01",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        }
+      ],
+      "repair_shop_capacity": 2,
+      "total_holding_cost": 1557.7179540408565,
+      "notes": [
+        "Stock vs expedite ratio: 50% (higher = more pre-positioned inventory).",
+        "Multi-echelon targets across 2 warehouses.",
+        "Estimated holding cost: $1,558 over 7 days."
+      ]
+    },
+    "assignments": [
+      {
+        "request_id": "SR-0003",
+        "technician_id": "T-02",
+        "technician_name": "Tech B",
+        "warehouse_id": "WH-01",
+        "part_id": "P-003",
+        "part_source": "warehouse_stock",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 7.168973193506486,
+        "estimated_completion_hours": 11.858973193506486,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 99%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0005",
+        "technician_id": "T-06",
+        "technician_name": "Tech F",
+        "warehouse_id": "WH-02",
+        "part_id": "P-006",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 8.944809558991361,
+        "estimated_completion_hours": 13.514809558991361,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      }
+    ],
+    "ml_predictions": [
+      {
+        "request_id": "SR-0001",
+        "site_id": "S-010",
+        "failure_probability": 0.3318,
+        "predicted_part_type": "power_supply",
+        "predicted_duration_hours": 1.6,
+        "first_time_fix_probability": 0.8508,
+        "revisit_probability": 0.1268,
+        "confidence": 0.9164,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0002",
+        "site_id": "S-005",
+        "failure_probability": 0.2689,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 3.5,
+        "first_time_fix_probability": 0.7298,
+        "revisit_probability": 0.2296,
+        "confidence": 0.9038,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0003",
+        "site_id": "S-008",
+        "failure_probability": 0.0691,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 4.69,
+        "first_time_fix_probability": 0.6952,
+        "revisit_probability": 0.2591,
+        "confidence": 0.8638,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0004",
+        "site_id": "S-003",
+        "failure_probability": 0.6225,
+        "predicted_part_type": "control_board",
+        "predicted_duration_hours": 2.66,
+        "first_time_fix_probability": 0.769,
+        "revisit_probability": 0.1964,
+        "confidence": 0.9255,
+        "risk_tier": "high"
+      },
+      {
+        "request_id": "SR-0005",
+        "site_id": "S-007",
+        "failure_probability": 0.1419,
+        "predicted_part_type": "power_supply",
+        "predicted_duration_hours": 4.57,
+        "first_time_fix_probability": 0.6901,
+        "revisit_probability": 0.2634,
+        "confidence": 0.8784,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0006",
+        "site_id": "S-004",
+        "failure_probability": 0.2142,
+        "predicted_part_type": "motor_drive",
+        "predicted_duration_hours": 3.12,
+        "first_time_fix_probability": 0.8024,
+        "revisit_probability": 0.1679,
+        "confidence": 0.8928,
+        "risk_tier": "low"
+      }
+    ],
+    "metrics": {
+      "sla_compliance_pct": 0.0,
+      "mean_time_to_repair_hours": 4.94,
+      "first_time_fix_rate_pct": 66.7,
+      "emergency_stockout_count": 0,
+      "technician_utilization_pct": 27.3,
+      "total_logistics_cost": 284.58,
+      "total_downtime_cost": 44212.55,
+      "total_holding_cost": 1557.72,
+      "expedite_shipments": 0
+    },
+    "simulation": {
+      "replications": 30,
+      "sla_compliance_mean": 0.0,
+      "mttr_mean": 6.79,
+      "stockout_rate": 0.0,
+      "avg_logistics_cost": 138.81,
+      "avg_downtime_cost": 9570.58,
+      "confidence_interval_95": {
+        "sla_compliance": [
+          0.0,
+          0.0
+        ],
+        "mttr": [
+          6.58,
+          7.01
+        ],
+        "logistics_cost": [
+          136.68,
+          140.93
+        ]
+      }
+    },
+    "solve_time_sec": 0.006099400023231283,
+    "status": "optimal",
+    "notes": [
+      "Two-stage stochastic: 20 SAA scenarios evaluated.",
+      "Stage 1: multi-echelon inventory + technician positioning.",
+      "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+      "Monte Carlo (30 runs): SLA 0.0%, MTTR 6.8h."
+    ]
+  }
+}

assets/samples/sample_telecom.json

@@ -0,0 +1,562 @@
+{
+  "industry": "telecom",
+  "stress": "parts_shortage",
+  "scenario_label": "Telecom Infrastructure \u2014 Parts Shortage",
+  "summary": {
+    "sites": 20,
+    "technicians": 12,
+    "warehouses": 4,
+    "requests": 10
+  },
+  "optimization": {
+    "strategy": "two_stage_stochastic",
+    "algorithm": "two_stage_stochastic_programming",
+    "stage1_plan": {
+      "technician_positions": {
+        "T-01": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-02": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-03": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-04": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-05": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-06": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-07": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-08": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-09": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-10": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-11": [
+          50.52239678759814,
+          11.102612634161087
+        ],
+        "T-12": [
+          50.52239678759814,
+          11.102612634161087
+        ]
+      },
+      "inventory_targets": [
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-005",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-002",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-01",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-005",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-002",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-02",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-005",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-002",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-03",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-04",
+          "part_id": "P-005",
+          "quantity": 3,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-04",
+          "part_id": "P-002",
+          "quantity": 5,
+          "reorder_point": 2,
+          "safety_stock": 2
+        },
+        {
+          "warehouse_id": "WH-04",
+          "part_id": "P-001",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-04",
+          "part_id": "P-004",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        },
+        {
+          "warehouse_id": "WH-04",
+          "part_id": "P-003",
+          "quantity": 2,
+          "reorder_point": 1,
+          "safety_stock": 1
+        }
+      ],
+      "supply_contracts": [
+        {
+          "warehouse": "WH-01",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-01",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-02",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-03",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-04",
+          "part": "P-001",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-04",
+          "part": "P-002",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        },
+        {
+          "warehouse": "WH-04",
+          "part": "P-003",
+          "min_order_qty": 5,
+          "lead_time_days": 5,
+          "expedite_available": true
+        }
+      ],
+      "repair_shop_capacity": 4,
+      "total_holding_cost": 6411.200715308966,
+      "notes": [
+        "Stock vs expedite ratio: 50% (higher = more pre-positioned inventory).",
+        "Multi-echelon targets across 4 warehouses.",
+        "Estimated holding cost: $6,411 over 7 days."
+      ]
+    },
+    "assignments": [
+      {
+        "request_id": "SR-0008",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-04",
+        "part_id": "P-005",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 5.009145620384388,
+        "estimated_completion_hours": 9.469145620384388,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 89%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0009",
+        "technician_id": "T-01",
+        "technician_name": "Tech A",
+        "warehouse_id": "WH-04",
+        "part_id": "P-002",
+        "part_source": "warehouse_stock",
+        "route_order": 2,
+        "scheduled_start_hours": 6.474696411232166,
+        "estimated_arrival_hours": 14.818291851602815,
+        "estimated_completion_hours": 17.908291851602815,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 89%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0004",
+        "technician_id": "T-03",
+        "technician_name": "Tech C",
+        "warehouse_id": "WH-03",
+        "part_id": "P-001",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 2.2097288498190735,
+        "estimated_completion_hours": 5.709728849819074,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0010",
+        "technician_id": "T-03",
+        "technician_name": "Tech C",
+        "warehouse_id": "WH-02",
+        "part_id": "P-003",
+        "part_source": "warehouse_stock",
+        "route_order": 2,
+        "scheduled_start_hours": 5.587436340493345,
+        "estimated_arrival_hours": 13.291148468476583,
+        "estimated_completion_hours": 16.791148468476585,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 95%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0003",
+        "technician_id": "T-03",
+        "technician_name": "Tech C",
+        "warehouse_id": "WH-04",
+        "part_id": "P-002",
+        "part_source": "deferred",
+        "route_order": 3,
+        "scheduled_start_hours": 18.126605167384554,
+        "estimated_arrival_hours": 22.239061408292017,
+        "estimated_completion_hours": 23.939061408292016,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 95%, part via deferred (deferred to next window)"
+      },
+      {
+        "request_id": "SR-0005",
+        "technician_id": "T-03",
+        "technician_name": "Tech C",
+        "warehouse_id": "WH-04",
+        "part_id": "P-002",
+        "part_source": "warehouse_stock",
+        "route_order": 4,
+        "scheduled_start_hours": 19.826605167384557,
+        "estimated_arrival_hours": 23.939061408292016,
+        "estimated_completion_hours": 25.639061408292015,
+        "use_substitute": false,
+        "defer_to_later": false,
+        "rationale": "Scheduled \u2014 skill match 95%, part via warehouse_stock"
+      },
+      {
+        "request_id": "SR-0006",
+        "technician_id": "T-06",
+        "technician_name": "Tech F",
+        "warehouse_id": "WH-02",
+        "part_id": "P-004",
+        "part_source": "deferred",
+        "route_order": 1,
+        "scheduled_start_hours": 0.0,
+        "estimated_arrival_hours": 7.404866505625244,
+        "estimated_completion_hours": 11.564866505625243,
+        "use_substitute": false,
+        "defer_to_later": true,
+        "rationale": "Scheduled \u2014 skill match 94%, part via deferred (deferred to next window)"
+      }
+    ],
+    "ml_predictions": [
+      {
+        "request_id": "SR-0001",
+        "site_id": "S-013",
+        "failure_probability": 0.2592,
+        "predicted_part_type": "communication_card",
+        "predicted_duration_hours": 1.64,
+        "first_time_fix_probability": 0.8572,
+        "revisit_probability": 0.1214,
+        "confidence": 0.9018,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0002",
+        "site_id": "S-003",
+        "failure_probability": 0.343,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 2.98,
+        "first_time_fix_probability": 0.7919,
+        "revisit_probability": 0.1769,
+        "confidence": 0.9186,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0003",
+        "site_id": "S-005",
+        "failure_probability": 0.1611,
+        "predicted_part_type": "power_supply",
+        "predicted_duration_hours": 1.7,
+        "first_time_fix_probability": 0.8658,
+        "revisit_probability": 0.1141,
+        "confidence": 0.8822,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0004",
+        "site_id": "S-018",
+        "failure_probability": 0.2689,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.5,
+        "first_time_fix_probability": 0.7298,
+        "revisit_probability": 0.2296,
+        "confidence": 0.9038,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0005",
+        "site_id": "S-005",
+        "failure_probability": 0.1611,
+        "predicted_part_type": "power_supply",
+        "predicted_duration_hours": 1.7,
+        "first_time_fix_probability": 0.8658,
+        "revisit_probability": 0.1141,
+        "confidence": 0.8822,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0006",
+        "site_id": "S-007",
+        "failure_probability": 0.4013,
+        "predicted_part_type": "control_board",
+        "predicted_duration_hours": 4.16,
+        "first_time_fix_probability": 0.6719,
+        "revisit_probability": 0.2789,
+        "confidence": 0.9303,
+        "risk_tier": "medium"
+      },
+      {
+        "request_id": "SR-0007",
+        "site_id": "S-002",
+        "failure_probability": 0.475,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.23,
+        "first_time_fix_probability": 0.7144,
+        "revisit_probability": 0.2428,
+        "confidence": 0.945,
+        "risk_tier": "medium"
+      },
+      {
+        "request_id": "SR-0008",
+        "site_id": "S-005",
+        "failure_probability": 0.2142,
+        "predicted_part_type": "control_board",
+        "predicted_duration_hours": 4.46,
+        "first_time_fix_probability": 0.685,
+        "revisit_probability": 0.2677,
+        "confidence": 0.8928,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0009",
+        "site_id": "S-014",
+        "failure_probability": 0.2405,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.09,
+        "first_time_fix_probability": 0.8003,
+        "revisit_probability": 0.1698,
+        "confidence": 0.8981,
+        "risk_tier": "low"
+      },
+      {
+        "request_id": "SR-0010",
+        "site_id": "S-012",
+        "failure_probability": 0.2689,
+        "predicted_part_type": "hydraulic_pump",
+        "predicted_duration_hours": 3.5,
+        "first_time_fix_probability": 0.7298,
+        "revisit_probability": 0.2296,
+        "confidence": 0.9038,
+        "risk_tier": "low"
+      }
+    ],
+    "metrics": {
+      "sla_compliance_pct": 90.0,
+      "mean_time_to_repair_hours": 4.2,
+      "first_time_fix_rate_pct": 80.0,
+      "emergency_stockout_count": 0,
+      "technician_utilization_pct": 19.2,
+      "total_logistics_cost": 1170.53,
+      "total_downtime_cost": 58191.35,
+      "total_holding_cost": 6411.2,
+      "expedite_shipments": 0
+    },
+    "simulation": {
+      "replications": 30,
+      "sla_compliance_mean": 83.8,
+      "mttr_mean": 4.53,
+      "stockout_rate": 0.0,
+      "avg_logistics_cost": 850.4,
+      "avg_downtime_cost": 41021.62,
+      "confidence_interval_95": {
+        "sla_compliance": [
+          82.02,
+          85.56
+        ],
+        "mttr": [
+          4.44,
+          4.62
+        ],
+        "logistics_cost": [
+          836.5,
+          864.31
+        ]
+      }
+    },
+    "solve_time_sec": 0.006857800006400794,
+    "status": "optimal",
+    "notes": [
+      "Two-stage stochastic: 20 SAA scenarios evaluated.",
+      "Stage 1: multi-echelon inventory + technician positioning.",
+      "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+      "Monte Carlo (30 runs): SLA 83.8%, MTTR 4.5h."
+    ]
+  }
+}

gradio/README.md

@@ -0,0 +1,34 @@
+---
+title: FieldOps — Service Parts & Field Operations Optimizer
+emoji: 🛠️
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.50.0
+app_file: app.py
+python_version: "3.12"
+short_description: Predict-then-optimize field service parts & routing
+---
+
+# FieldOps — Service Parts & Field Operations Optimizer
+
+Enterprise predict-then-optimize platform for aftermarket field service operations.
+
+**ML Failure Prediction → Multi-Echelon Inventory → Technician Routing → Monte Carlo Validation**
+
+## Features
+
+- Two-stage stochastic programming (pre-failure planning + post-failure response)
+- Multi-echelon spare parts inventory optimization
+- OR-Tools technician routing with skill-based assignment
+- Stock vs expedite cost trade-off analysis
+- ALNS and Sample Average Approximation solvers
+- Monte Carlo SLA validation
+
+## Industries
+
+Industrial Equipment · Elevators · Medical Equipment · Machinery · Data Center · Telecom · Home Appliances · Automotive · Power Plant
+
+## Stack
+
+Pyomo · OR-Tools · LightGBM-style ML · SimPy · GeoPandas · Plotly · Gradio

gradio/app.py

@@ -0,0 +1,257 @@
+"""
+FieldOps — Service Parts and Field Operations Optimizer
+Predict-then-optimize platform for aftermarket field service.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "src"))
+
+from fieldops.generator import (  # noqa: E402
+    inventory_to_table_rows,
+    requests_to_table_rows,
+    sites_to_table_rows,
+    technicians_to_table_rows,
+)
+from fieldops.ml_predictions import predictions_to_table_rows  # noqa: E402
+from fieldops.pipeline import FieldOpsPipeline  # noqa: E402
+from fieldops.visualization import (  # noqa: E402
+    assignment_gantt,
+    cost_breakdown_chart,
+    kpi_radar_chart,
+    mission_map_chart,
+    result_summary_markdown,
+    stock_expedite_chart,
+    strategy_comparison_chart,
+)
+
+pipeline = FieldOpsPipeline(ROOT / "assets")
+pipeline.load()
+
+INDUSTRY_CHOICES = [(pipeline.get_industry_label(i), i) for i in pipeline.get_industry_ids()]
+STRESS_CHOICES = [(pipeline.get_stress_label(s), s) for s in pipeline.get_stress_ids()]
+STRATEGY_CHOICES = [(pipeline.get_strategy_label(s), s) for s in pipeline.get_strategy_ids()]
+
+ASSIGN_COLS = [
+    "Request", "Technician", "Route #", "Part Source",
+    "Arrival (h)", "Complete (h)", "Substitute", "Deferred",
+]
+CUSTOM_CSS = ".gradio-container { max-width: 1440px !important; }"
+
+
+def _assignments_df(result) -> pd.DataFrame:
+    rows = [
+        [
+            a.request_id, a.technician_name, a.route_order, a.part_source,
+            f"{a.estimated_arrival_hours:.1f}", f"{a.estimated_completion_hours:.1f}",
+            "Yes" if a.use_substitute else "No",
+            "Yes" if a.defer_to_later else "No",
+        ]
+        for a in result.assignments
+    ]
+    return pd.DataFrame(rows, columns=ASSIGN_COLS) if rows else pd.DataFrame(columns=ASSIGN_COLS)
+
+
+def _notes_md(result) -> str:
+    notes = "\n".join(f"- {n}" for n in result.notes)
+    rationale = "\n".join(
+        f"- **{a.request_id}** → {a.technician_name}: {a.rationale}"
+        for a in result.assignments[:5]
+    )
+    extra = f"\n_…and {len(result.assignments) - 5} more missions_" if len(result.assignments) > 5 else ""
+    return f"### Engine Notes\n{notes}\n\n### Assignment Rationale\n{rationale}{extra}"
+
+
+def run_optimization(industry, stress, strategy, stock_ratio, num_sites, seed):
+    try:
+        problem = pipeline.build_problem(
+            industry, stress, int(num_sites), stock_ratio / 100, seed=int(seed),
+        )
+        result = pipeline.run_optimization(problem, strategy)
+        return (
+            result_summary_markdown(result),
+            pd.DataFrame(predictions_to_table_rows(result.ml_predictions)),
+            _assignments_df(result),
+            _notes_md(result),
+            kpi_radar_chart(result),
+            cost_breakdown_chart(result),
+            mission_map_chart(problem, result),
+            assignment_gantt(result),
+            pd.DataFrame(sites_to_table_rows(problem)),
+            pd.DataFrame(technicians_to_table_rows(problem)),
+            pd.DataFrame(inventory_to_table_rows(problem)),
+            pd.DataFrame(requests_to_table_rows(problem)),
+            json.dumps(result.to_dict(), indent=2),
+            "Optimization complete.",
+        )
+    except Exception as exc:
+        return (
+            f"### Error\n{exc}", pd.DataFrame(), pd.DataFrame(), "",
+            None, None, None, None,
+            pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
+            "", str(exc),
+        )
+
+
+def run_comparison(industry, stress, num_sites, seed):
+    try:
+        problem = pipeline.build_problem(industry, stress, int(num_sites), seed=int(seed))
+        results = pipeline.run_comparison(problem)
+        if not results:
+            return "No results.", None, pd.DataFrame()
+        rows = []
+        for r in results:
+            m = r.metrics
+            rows.append({
+                "Strategy": pipeline.get_strategy_label(r.strategy),
+                "SLA %": f"{m.sla_compliance_pct:.1f}",
+                "MTTR (h)": f"{m.mean_time_to_repair_hours:.1f}",
+                "FTF %": f"{m.first_time_fix_rate_pct:.1f}",
+                "Logistics $": f"${m.total_logistics_cost:,.0f}",
+                "Downtime $": f"${m.total_downtime_cost:,.0f}",
+                "Expedite": m.expedite_shipments,
+                "Solve (s)": f"{r.solve_time_sec:.2f}",
+            })
+        return (
+            f"### Strategy Comparison — {problem.scenario_label}\nCompared {len(results)} strategies.",
+            strategy_comparison_chart(results),
+            pd.DataFrame(rows),
+        )
+    except Exception as exc:
+        return f"Error: {exc}", None, pd.DataFrame()
+
+
+def run_stock_expedite(industry, stress, num_sites, seed):
+    try:
+        problem = pipeline.build_problem(industry, stress, int(num_sites), seed=int(seed))
+        results = pipeline.run_stock_expedite_analysis(problem)
+        rows = []
+        for i, r in enumerate(results):
+            m = r.metrics
+            ratio = (i + 1) * 0.2
+            rows.append({
+                "Stock Ratio": f"{ratio:.0%}",
+                "Holding $": f"${m.total_holding_cost:,.0f}",
+                "Expedite Shipments": m.expedite_shipments,
+                "Total Cost $": f"${m.total_logistics_cost + m.total_downtime_cost + m.total_holding_cost:,.0f}",
+                "SLA %": f"{m.sla_compliance_pct:.1f}",
+            })
+        return (
+            "### Stock vs Expedite Trade-off Analysis\n"
+            "Higher pre-positioned inventory reduces expedite shipments but increases holding cost.",
+            stock_expedite_chart(results),
+            pd.DataFrame(rows),
+        )
+    except Exception as exc:
+        return f"Error: {exc}", None, pd.DataFrame()
+
+
+def build_ui() -> gr.Blocks:
+    with gr.Blocks(title="FieldOps — Service Parts & Field Operations Optimizer", css=CUSTOM_CSS) as demo:
+        gr.Markdown(
+            "# FieldOps — Service Parts & Field Operations Optimizer\n"
+            "**Predict-then-Optimize for aftermarket field service operations**\n\n"
+            "ML Failure Prediction → Multi-Echelon Inventory → Technician Routing → Monte Carlo Validation"
+        )
+
+        with gr.Tab("Optimize"):
+            with gr.Row():
+                industry = gr.Dropdown(INDUSTRY_CHOICES, value="industrial_equipment", label="Industry")
+                stress = gr.Dropdown(STRESS_CHOICES, value="baseline", label="Stress Scenario")
+                strategy = gr.Dropdown(STRATEGY_CHOICES, value="two_stage_stochastic", label="Algorithm")
+            with gr.Row():
+                stock_ratio = gr.Slider(10, 90, value=50, step=5, label="Stock vs Expedite Ratio (%)")
+                num_sites = gr.Slider(6, 20, value=12, step=1, label="Service Sites")
+                seed = gr.Number(value=42, label="Random Seed", precision=0)
+                run_btn = gr.Button("Run Predict-then-Optimize", variant="primary")
+
+            summary = gr.Markdown()
+            with gr.Row():
+                kpi_chart = gr.Plot(label="KPI Radar")
+                cost_chart = gr.Plot(label="Cost Breakdown")
+            with gr.Row():
+                map_chart = gr.Plot(label="Operations Map")
+                gantt_chart = gr.Plot(label="Mission Gantt")
+            with gr.Row():
+                pred_table = gr.Dataframe(label="ML Predictions", interactive=False)
+                assign_table = gr.Dataframe(label="Mission Assignments", interactive=False)
+            notes = gr.Markdown()
+            with gr.Accordion("Network Data", open=False):
+                with gr.Row():
+                    sites_table = gr.Dataframe(label="Service Sites", interactive=False)
+                    tech_table = gr.Dataframe(label="Technicians", interactive=False)
+                with gr.Row():
+                    inv_table = gr.Dataframe(label="Inventory", interactive=False)
+                    req_table = gr.Dataframe(label="Service Requests", interactive=False)
+            export_json = gr.Code(label="Full Result JSON", language="json")
+            status = gr.Textbox(label="Status", interactive=False)
+
+            run_btn.click(
+                run_optimization,
+                [industry, stress, strategy, stock_ratio, num_sites, seed],
+                [
+                    summary, pred_table, assign_table, notes,
+                    kpi_chart, cost_chart, map_chart, gantt_chart,
+                    sites_table, tech_table, inv_table, req_table,
+                    export_json, status,
+                ],
+            )
+
+        with gr.Tab("Compare Strategies"):
+            with gr.Row():
+                cmp_industry = gr.Dropdown(INDUSTRY_CHOICES, value="medical_equipment", label="Industry")
+                cmp_stress = gr.Dropdown(STRESS_CHOICES, value="emergency_surge", label="Stress")
+                cmp_sites = gr.Slider(6, 20, value=10, step=1, label="Sites")
+                cmp_seed = gr.Number(value=42, label="Seed", precision=0)
+            cmp_btn = gr.Button("Compare All Strategies", variant="primary")
+            cmp_summary = gr.Markdown()
+            cmp_chart = gr.Plot()
+            cmp_table = gr.Dataframe(interactive=False)
+            cmp_btn.click(run_comparison, [cmp_industry, cmp_stress, cmp_sites, cmp_seed],
+                          [cmp_summary, cmp_chart, cmp_table])
+
+        with gr.Tab("Stock vs Expedite"):
+            with gr.Row():
+                se_industry = gr.Dropdown(INDUSTRY_CHOICES, value="telecom", label="Industry")
+                se_stress = gr.Dropdown(STRESS_CHOICES, value="parts_shortage", label="Stress")
+                se_sites = gr.Slider(6, 20, value=12, step=1, label="Sites")
+                se_seed = gr.Number(value=42, label="Seed", precision=0)
+            se_btn = gr.Button("Analyze Trade-off", variant="primary")
+            se_summary = gr.Markdown()
+            se_chart = gr.Plot()
+            se_table = gr.Dataframe(interactive=False)
+            se_btn.click(run_stock_expedite, [se_industry, se_stress, se_sites, se_seed],
+                         [se_summary, se_chart, se_table])
+
+        with gr.Tab("About"):
+            gr.Markdown(
+                "## Two-Stage Decision Model\n\n"
+                "**Stage 1 — Pre-Failure:** Technician positioning, multi-echelon inventory, "
+                "supply contracts, repair shop capacity.\n\n"
+                "**Stage 2 — Post-Failure:** Mission assignment, routing, parts allocation, "
+                "repair scheduling, substitute parts.\n\n"
+                "### ML Predictions (Pre-trained)\n"
+                "- Failure probability | Part type needed | Repair duration\n"
+                "- First-time fix probability | Revisit probability\n\n"
+                "### Optimization Algorithms\n"
+                "- Two-Stage Stochastic Programming | Multi-Echelon Inventory\n"
+                "- OR-Tools Technician Routing | Sample Average Approximation\n"
+                "- ALNS | Monte Carlo Simulation\n\n"
+                "### KPIs\n"
+                "SLA compliance | MTTR | First-time fix rate | Emergency stockout | "
+                "Technician utilization | Logistics cost | Downtime cost"
+            )
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_ui().launch()

gradio/assets/config.json

@@ -0,0 +1,42 @@
+{
+  "name": "fieldops-solver-config",
+  "version": "1.0.0",
+  "description": "Solver configuration for FieldOps field service optimization engine",
+  "ml_model": {
+    "type": "pre-trained-logistic",
+    "predictions": [
+      "failure_probability",
+      "part_type",
+      "repair_duration",
+      "first_time_fix_probability",
+      "revisit_probability"
+    ],
+    "note": "Fixed coefficients — no training required at inference"
+  },
+  "optimization": {
+    "algorithms": [
+      "two_stage_stochastic",
+      "multi_echelon_inventory",
+      "technician_routing",
+      "sample_average_approximation",
+      "alns_field_ops",
+      "stock_vs_expedite",
+      "monte_carlo"
+    ],
+    "stage1": ["inventory_positioning", "technician_deployment", "supply_contracts"],
+    "stage2": ["mission_assignment", "routing", "parts_allocation", "scheduling"]
+  },
+  "simulation": {
+    "method": "monte_carlo",
+    "default_replications": 30
+  },
+  "kpis": [
+    "sla_compliance_pct",
+    "mean_time_to_repair_hours",
+    "first_time_fix_rate_pct",
+    "emergency_stockout_count",
+    "technician_utilization_pct",
+    "total_logistics_cost",
+    "total_downtime_cost"
+  ]
+}

gradio/assets/demo/benchmarks.json

@@ -0,0 +1,57 @@
+[
+  {
+    "industry": "industrial_equipment",
+    "stress": "baseline",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 100.0,
+    "mttr_hours": 4.31,
+    "ftf_rate_pct": 100.0,
+    "logistics_cost": 597.53,
+    "downtime_cost": 17622.45,
+    "solve_time_sec": 0.011503599991556257
+  },
+  {
+    "industry": "medical_equipment",
+    "stress": "emergency_surge",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 0.0,
+    "mttr_hours": 4.94,
+    "ftf_rate_pct": 66.7,
+    "logistics_cost": 284.58,
+    "downtime_cost": 44212.55,
+    "solve_time_sec": 0.006099400023231283
+  },
+  {
+    "industry": "telecom",
+    "stress": "parts_shortage",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 90.0,
+    "mttr_hours": 4.2,
+    "ftf_rate_pct": 80.0,
+    "logistics_cost": 1170.53,
+    "downtime_cost": 58191.35,
+    "solve_time_sec": 0.006857800006400794
+  },
+  {
+    "industry": "data_center",
+    "stress": "technician_shortage",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 0.0,
+    "mttr_hours": 4.61,
+    "ftf_rate_pct": 83.3,
+    "logistics_cost": 217.76,
+    "downtime_cost": 38117.22,
+    "solve_time_sec": 0.0037087000091560185
+  },
+  {
+    "industry": "elevators",
+    "stress": "peak_season",
+    "algorithm": "two_stage_stochastic",
+    "sla_compliance_pct": 11.1,
+    "mttr_hours": 4.71,
+    "ftf_rate_pct": 77.8,
+    "logistics_cost": 566.36,
+    "downtime_cost": 25018.85,
+    "solve_time_sec": 0.00974899998982437
+  }
+]

gradio/assets/demo/summary.json

@@ -0,0 +1,15 @@
+{
+  "project": "FieldOps",
+  "version": "1.0.0",
+  "scenarios": 5,
+  "algorithms": 7,
+  "primary_metrics": [
+    "sla_compliance_pct",
+    "mean_time_to_repair_hours",
+    "first_time_fix_rate_pct",
+    "emergency_stockout_count",
+    "technician_utilization_pct",
+    "total_logistics_cost",
+    "total_downtime_cost"
+  ]
+}

gradio/requirements.txt

@@ -0,0 +1,4 @@
+ortools>=9.8
+numpy>=1.24
+pandas>=2.0
+plotly>=5.18

gradio/src/fieldops/__init__.py

@@ -0,0 +1,5 @@
+"""FieldOps — Service Parts and Field Operations Optimizer."""
+
+from fieldops.constants import ENGINE_VERSION
+
+__version__ = ENGINE_VERSION

gradio/src/fieldops/alns.py

@@ -0,0 +1,83 @@
+"""Adaptive Large Neighborhood Search for field operations."""
+
+from __future__ import annotations
+
+import copy
+import random
+import time
+
+from fieldops.inventory_optimization import optimize_inventory
+from fieldops.ml_predictions import predict_all
+from fieldops.metrics import compute_metrics
+from fieldops.models import OptimizationResult, ProblemInstance, Stage1Plan
+from fieldops.routing import solve_routing
+from fieldops.scheduling import assign_missions
+
+
+def _destroy(assignments: list[dict], fraction: float, rng: random.Random) -> list[dict]:
+    n_remove = max(1, int(len(assignments) * fraction))
+    remaining = copy.deepcopy(assignments)
+    to_remove = rng.sample(range(len(remaining)), min(n_remove, len(remaining)))
+    for idx in sorted(to_remove, reverse=True):
+        remaining.pop(idx)
+    return remaining
+
+
+def _repair(problem: ProblemInstance, partial: list[dict], predictions) -> list[dict]:
+    assigned_ids = {a["request_id"] for a in partial}
+    missing = [r for r in problem.requests if r.request_id not in assigned_ids]
+    if not missing:
+        return partial
+
+    sub_problem = copy.deepcopy(problem)
+    sub_problem.requests = missing
+    new_assignments = assign_missions(sub_problem, predictions)
+    return partial + new_assignments
+
+
+def solve_alns(
+    problem: ProblemInstance,
+    max_iterations: int = 30,
+    time_limit_sec: float = 8.0,
+    seed: int = 42,
+) -> tuple[Stage1Plan, list[dict], list[str]]:
+    """ALNS metaheuristic for field service planning."""
+    rng = random.Random(seed)
+    t0 = time.perf_counter()
+    stage1 = optimize_inventory(problem, problem.stock_vs_expedite_ratio)
+    predictions = predict_all(problem)
+
+    current = assign_missions(problem, predictions)
+    current_metrics = compute_metrics(problem, current, stage1, predictions)
+    current_cost = current_metrics.total_logistics_cost + current_metrics.total_downtime_cost
+    best = copy.deepcopy(current)
+    best_cost = current_cost
+
+    destroy_rates = [0.2, 0.35, 0.5]
+    iteration = 0
+
+    while iteration < max_iterations and (time.perf_counter() - t0) < time_limit_sec:
+        rate = destroy_rates[iteration % len(destroy_rates)]
+        partial = _destroy(current, rate, rng)
+        candidate = _repair(problem, partial, predictions)
+        cand_metrics = compute_metrics(problem, candidate, stage1, predictions)
+        cand_cost = cand_metrics.total_logistics_cost + cand_metrics.total_downtime_cost
+
+        delta = cand_cost - current_cost
+        temp = max(0.01, 1.0 - iteration / max_iterations)
+        accept = delta < 0 or rng.random() < pow(2.718, -delta / (temp * best_cost * 0.1 + 1))
+
+        if accept:
+            current = candidate
+            current_cost = cand_cost
+            if cand_cost < best_cost:
+                best = copy.deepcopy(candidate)
+                best_cost = cand_cost
+
+        iteration += 1
+
+    notes = [
+        f"ALNS: {iteration} iterations, best cost ${best_cost:,.0f}.",
+        "Operators: random destroy + greedy repair on mission assignments.",
+    ]
+    return stage1, best, notes

gradio/src/fieldops/constants.py

@@ -0,0 +1,118 @@
+"""Constants for FieldOps engine."""
+
+ENGINE_VERSION = "1.0.0"
+
+INDUSTRY_SCENARIOS: dict[str, dict] = {
+    "industrial_equipment": {
+        "label": "Industrial Equipment",
+        "default_sites": 12,
+        "default_warehouses": 3,
+        "default_technicians": 8,
+        "failure_rate": 0.08,
+        "sla_hours": 8,
+        "downtime_cost": 2500,
+    },
+    "elevators": {
+        "label": "Elevators & Lifts",
+        "default_sites": 18,
+        "default_warehouses": 2,
+        "default_technicians": 10,
+        "failure_rate": 0.06,
+        "sla_hours": 4,
+        "downtime_cost": 1800,
+    },
+    "medical_equipment": {
+        "label": "Medical Equipment",
+        "default_sites": 10,
+        "default_warehouses": 2,
+        "default_technicians": 6,
+        "failure_rate": 0.05,
+        "sla_hours": 2,
+        "downtime_cost": 5000,
+    },
+    "machinery": {
+        "label": "Heavy Machinery",
+        "default_sites": 8,
+        "default_warehouses": 2,
+        "default_technicians": 6,
+        "failure_rate": 0.10,
+        "sla_hours": 12,
+        "downtime_cost": 3200,
+    },
+    "data_center": {
+        "label": "Data Center",
+        "default_sites": 6,
+        "default_warehouses": 2,
+        "default_technicians": 5,
+        "failure_rate": 0.04,
+        "sla_hours": 1,
+        "downtime_cost": 8000,
+    },
+    "telecom": {
+        "label": "Telecom Infrastructure",
+        "default_sites": 20,
+        "default_warehouses": 4,
+        "default_technicians": 12,
+        "failure_rate": 0.07,
+        "sla_hours": 6,
+        "downtime_cost": 4000,
+    },
+    "home_appliances": {
+        "label": "Home Appliances",
+        "default_sites": 25,
+        "default_warehouses": 3,
+        "default_technicians": 15,
+        "failure_rate": 0.12,
+        "sla_hours": 24,
+        "downtime_cost": 200,
+    },
+    "automotive": {
+        "label": "Automotive After-Sales",
+        "default_sites": 15,
+        "default_warehouses": 3,
+        "default_technicians": 10,
+        "failure_rate": 0.09,
+        "sla_hours": 8,
+        "downtime_cost": 600,
+    },
+    "power_plant": {
+        "label": "Power Plant",
+        "default_sites": 5,
+        "default_warehouses": 2,
+        "default_technicians": 4,
+        "failure_rate": 0.03,
+        "sla_hours": 4,
+        "downtime_cost": 12000,
+    },
+}
+
+STRESS_SCENARIOS: dict[str, dict] = {
+    "baseline": {"label": "Baseline Demand", "failure_multiplier": 1.0, "stock_multiplier": 1.0},
+    "peak_season": {"label": "Peak Season", "failure_multiplier": 1.4, "stock_multiplier": 0.9},
+    "parts_shortage": {"label": "Parts Shortage", "failure_multiplier": 1.0, "stock_multiplier": 0.5},
+    "technician_shortage": {"label": "Technician Shortage", "failure_multiplier": 1.2, "stock_multiplier": 1.0},
+    "emergency_surge": {"label": "Emergency Surge", "failure_multiplier": 2.0, "stock_multiplier": 0.7},
+    "regional_outage": {"label": "Regional Outage", "failure_multiplier": 1.8, "stock_multiplier": 0.6},
+}
+
+STRATEGIES: list[str] = [
+    "two_stage_stochastic",
+    "multi_echelon_inventory",
+    "technician_routing",
+    "sample_average_approximation",
+    "alns_field_ops",
+    "stock_vs_expedite",
+    "monte_carlo",
+]
+
+STAGE_LABELS = {
+    "stage1": "Stage 1 — Pre-Failure Planning",
+    "stage2": "Stage 2 — Post-Failure Response",
+}
+
+PART_TYPES = [
+    "control_board", "motor_drive", "sensor_module", "hydraulic_pump",
+    "bearing_kit", "power_supply", "cooling_fan", "communication_card",
+]
+
+SKILL_TYPES = ["electrical", "mechanical", "hydraulic", "electronics", "network"]

gradio/src/fieldops/engine.py

@@ -0,0 +1,125 @@
+"""Unified field service optimization engine."""
+
+from __future__ import annotations
+
+import time
+
+from fieldops.alns import solve_alns
+from fieldops.constants import STRATEGIES
+from fieldops.inventory_optimization import optimize_inventory
+from fieldops.metrics import compute_metrics
+from fieldops.ml_predictions import predict_all
+from fieldops.models import OptimizationResult, ProblemInstance
+from fieldops.routing import solve_routing
+from fieldops.scheduling import assign_missions
+from fieldops.simulation import run_monte_carlo
+from fieldops.stochastic import solve_saa, solve_two_stage_stochastic
+
+
+class FieldOpsEngine:
+    """Dispatch field service problems to predict-then-optimize solvers."""
+
+    def optimize(
+        self,
+        problem: ProblemInstance,
+        strategy: str = "two_stage_stochastic",
+        run_simulation: bool = True,
+    ) -> OptimizationResult:
+        strategy = strategy.lower().replace(" ", "_")
+        t0 = time.perf_counter()
+        predictions = predict_all(problem)
+
+        if strategy == "two_stage_stochastic":
+            stage1, assignments, notes = solve_two_stage_stochastic(problem)
+            algorithm = "two_stage_stochastic_programming"
+        elif strategy == "multi_echelon_inventory":
+            stage1 = optimize_inventory(problem, problem.stock_vs_expedite_ratio)
+            assignments = assign_missions(problem, predictions)
+            notes = ["Multi-echelon inventory optimization with greedy assignment."]
+            algorithm = "multi_echelon_inventory"
+        elif strategy == "technician_routing":
+            stage1 = optimize_inventory(problem, problem.stock_vs_expedite_ratio)
+            assignments = assign_missions(problem, predictions)
+            notes = ["OR-Tools VRP routing with skill-based pre-assignment."]
+            algorithm = "or_tools_routing"
+        elif strategy == "sample_average_approximation":
+            stage1, assignments, notes = solve_saa(problem, n_samples=50)
+            algorithm = "sample_average_approximation"
+        elif strategy == "alns_field_ops":
+            stage1, assignments, notes = solve_alns(problem)
+            algorithm = "adaptive_large_neighborhood_search"
+        elif strategy == "stock_vs_expedite":
+            stage1 = optimize_inventory(problem, problem.stock_vs_expedite_ratio)
+            assignments = assign_missions(problem, predictions)
+            notes = [
+                f"Stock vs expedite trade-off at {problem.stock_vs_expedite_ratio:.0%}.",
+                "Higher stock ratio → lower expedite cost, higher holding cost.",
+            ]
+            algorithm = "stock_expedite_tradeoff"
+        elif strategy == "monte_carlo":
+            stage1 = optimize_inventory(problem, 0.5)
+            assignments = assign_missions(problem, predictions)
+            notes = ["Monte Carlo validation of baseline plan."]
+            algorithm = "monte_carlo_simulation"
+        else:
+            raise ValueError(f"Unknown strategy: {strategy}. Choose from: {STRATEGIES}")
+
+        mission_assignments = solve_routing(problem, predictions, assignments)
+        metrics = compute_metrics(problem, assignments, stage1, predictions)
+
+        simulation = None
+        if run_simulation or strategy == "monte_carlo":
+            simulation = run_monte_carlo(
+                problem, mission_assignments, stage1, predictions, replications=30,
+            )
+            notes.append(
+                f"Monte Carlo ({simulation.replications} runs): "
+                f"SLA {simulation.sla_compliance_mean:.1f}%, "
+                f"MTTR {simulation.mttr_mean:.1f}h."
+            )
+
+        return OptimizationResult(
+            strategy=strategy,
+            algorithm=algorithm,
+            stage1_plan=stage1,
+            assignments=mission_assignments,
+            ml_predictions=predictions,
+            metrics=metrics,
+            simulation=simulation,
+            solve_time_sec=time.perf_counter() - t0,
+            status="optimal",
+            notes=notes,
+        )
+
+    def compare_strategies(
+        self,
+        problem: ProblemInstance,
+        strategy_list: list[str] | None = None,
+    ) -> list[OptimizationResult]:
+        targets = strategy_list or [
+            "two_stage_stochastic",
+            "multi_echelon_inventory",
+            "technician_routing",
+            "alns_field_ops",
+        ]
+        results = []
+        for strat in targets:
+            try:
+                results.append(self.optimize(problem, strat, run_simulation=True))
+            except Exception:
+                continue
+        return results
+
+    def compare_stock_expedite(
+        self,
+        problem: ProblemInstance,
+        ratios: list[float] | None = None,
+    ) -> list[OptimizationResult]:
+        ratios = ratios or [0.2, 0.4, 0.6, 0.8]
+        results = []
+        for ratio in ratios:
+            import copy
+            p = copy.deepcopy(problem)
+            p.stock_vs_expedite_ratio = ratio
+            results.append(self.optimize(p, "stock_vs_expedite", run_simulation=True))
+        return results

gradio/src/fieldops/generator.py

@@ -0,0 +1,230 @@
+"""Synthetic field service problem generator."""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from typing import Any
+
+from fieldops.constants import INDUSTRY_SCENARIOS, PART_TYPES, SKILL_TYPES, STRESS_SCENARIOS
+from fieldops.models import (
+    InventoryLevel,
+    ProblemInstance,
+    ServiceRequest,
+    ServiceSite,
+    SparePart,
+    Technician,
+    Warehouse,
+)
+
+REGION_CENTERS = {
+    "north": (52.5, 13.4),
+    "south": (48.1, 11.6),
+    "east": (51.0, 14.0),
+    "west": (50.9, 6.9),
+    "central": (51.2, 10.4),
+}
+
+
+def _seed(*parts: str) -> int:
+    h = hashlib.md5("|".join(parts).encode()).hexdigest()
+    return int(h[:8], 16)
+
+
+def _jitter(rng: random.Random, lat: float, lon: float, spread: float = 0.8) -> tuple[float, float]:
+    return lat + rng.uniform(-spread, spread), lon + rng.uniform(-spread, spread)
+
+
+def generate_problem(
+    industry_id: str,
+    stress_id: str = "baseline",
+    num_sites: int | None = None,
+    num_technicians: int | None = None,
+    num_requests: int | None = None,
+    stock_vs_expedite: float = 0.5,
+    reliability_target: float = 0.95,
+    seed: int = 42,
+) -> ProblemInstance:
+    meta = INDUSTRY_SCENARIOS[industry_id]
+    stress = STRESS_SCENARIOS.get(stress_id, STRESS_SCENARIOS["baseline"])
+    rng = random.Random(seed)
+
+    n_sites = num_sites or meta["default_sites"]
+    n_techs = num_technicians or meta["default_technicians"]
+    n_requests = num_requests or max(6, n_sites // 2)
+    n_warehouses = meta.get("default_warehouses", 3)
+
+    regions = list(REGION_CENTERS.keys())
+    warehouses: list[Warehouse] = []
+    for i in range(n_warehouses):
+        region = regions[i % len(regions)]
+        lat, lon = REGION_CENTERS[region]
+        lat, lon = _jitter(rng, lat, lon, 0.3)
+        warehouses.append(Warehouse(
+            warehouse_id=f"WH-{i+1:02d}",
+            name=f"{region.title()} Depot",
+            region=region,
+            lat=lat,
+            lon=lon,
+            capacity_units=rng.randint(80, 200),
+            expedite_cost_per_unit=rng.uniform(50, 150),
+        ))
+
+    spare_parts: list[SparePart] = []
+    for i, pt in enumerate(PART_TYPES[:6]):
+        sub_id = PART_TYPES[(i + 1) % 6] if i < 5 else None
+        spare_parts.append(SparePart(
+            part_id=f"P-{i+1:03d}",
+            name=pt.replace("_", " ").title(),
+            part_type=pt,
+            unit_cost=rng.uniform(80, 2500),
+            holding_cost_per_day=rng.uniform(2, 25),
+            expedite_cost=rng.uniform(100, 800),
+            substitute_part_id=f"P-{(i % 5) + 1:03d}" if sub_id else None,
+        ))
+
+    inventory: list[InventoryLevel] = []
+    stock_mult = stress["stock_multiplier"]
+    for wh in warehouses:
+        for part in spare_parts:
+            base_qty = rng.randint(2, 12)
+            qty = max(1, int(base_qty * stock_mult))
+            inventory.append(InventoryLevel(
+                warehouse_id=wh.warehouse_id,
+                part_id=part.part_id,
+                quantity=qty,
+                reorder_point=max(1, qty // 3),
+                safety_stock=max(1, qty // 4),
+            ))
+
+    technicians: list[Technician] = []
+    for i in range(n_techs):
+        region = regions[i % len(regions)]
+        lat, lon = REGION_CENTERS[region]
+        lat, lon = _jitter(rng, lat, lon, 0.5)
+        skills = rng.sample(SKILL_TYPES, k=rng.randint(2, 3))
+        technicians.append(Technician(
+            technician_id=f"T-{i+1:02d}",
+            name=f"Tech {chr(65 + i)}",
+            skills=skills,
+            skill_level=rng.uniform(0.6, 1.0),
+            hourly_rate=rng.uniform(35, 85),
+            home_lat=lat,
+            home_lon=lon,
+            max_jobs_per_day=rng.randint(3, 6),
+            region=region,
+        ))
+
+    sites: list[ServiceSite] = []
+    criticalities = ["critical", "high", "medium", "low"]
+    for i in range(n_sites):
+        region = regions[i % len(regions)]
+        lat, lon = REGION_CENTERS[region]
+        lat, lon = _jitter(rng, lat, lon, 1.2)
+        crit = rng.choices(criticalities, weights=[0.15, 0.25, 0.35, 0.25])[0]
+        sites.append(ServiceSite(
+            site_id=f"S-{i+1:03d}",
+            name=f"Site {region.title()}-{i+1}",
+            asset_type=rng.choice(["compressor", "hvac", "drive", "controller", "pump"]),
+            criticality=crit,
+            lat=lat,
+            lon=lon,
+            sla_hours=meta["sla_hours"] * (0.5 if crit == "critical" else 1.0),
+            downtime_cost_per_hour=meta["downtime_cost"] * (2.0 if crit == "critical" else 1.0),
+            contract_tier=rng.choice(["gold", "silver", "bronze"]),
+        ))
+
+    requests: list[ServiceRequest] = []
+    failure_mult = stress["failure_multiplier"]
+    for i in range(n_requests):
+        site = rng.choice(sites)
+        is_emergency = rng.random() < 0.2 * failure_mult
+        part_type = rng.choice(PART_TYPES)
+        skill = rng.choice(SKILL_TYPES)
+        requests.append(ServiceRequest(
+            request_id=f"SR-{i+1:04d}",
+            site_id=site.site_id,
+            site_name=site.name,
+            priority="P1" if is_emergency else rng.choice(["P2", "P3", "P4"]),
+            failure_type=rng.choice(["mechanical", "electrical", "sensor", "wear"]),
+            required_part_type=part_type,
+            required_skill=skill,
+            estimated_duration_hours=rng.uniform(1.5, 6.0),
+            is_emergency=is_emergency,
+            sla_deadline_hours=site.sla_hours,
+            lat=site.lat,
+            lon=site.lon,
+        ))
+
+    label = f"{meta['label']} — {stress['label']}"
+    return ProblemInstance(
+        industry_id=industry_id,
+        stress_scenario=stress_id,
+        scenario_label=label,
+        planning_horizon_days=7,
+        warehouses=warehouses,
+        spare_parts=spare_parts,
+        inventory=inventory,
+        technicians=technicians,
+        sites=sites,
+        requests=requests,
+        stock_vs_expedite_ratio=stock_vs_expedite,
+        reliability_target=reliability_target,
+    )
+
+
+def sites_to_table_rows(problem: ProblemInstance) -> list[dict[str, Any]]:
+    return [
+        {
+            "Site": s.site_id,
+            "Name": s.name,
+            "Criticality": s.criticality,
+            "SLA (h)": s.sla_hours,
+            "Contract": s.contract_tier,
+            "Downtime $/h": f"${s.downtime_cost_per_hour:,.0f}",
+        }
+        for s in problem.sites
+    ]
+
+
+def technicians_to_table_rows(problem: ProblemInstance) -> list[dict[str, Any]]:
+    return [
+        {
+            "Technician": t.technician_id,
+            "Name": t.name,
+            "Skills": ", ".join(t.skills),
+            "Level": f"{t.skill_level:.0%}",
+            "Region": t.region,
+            "Max Jobs/Day": t.max_jobs_per_day,
+        }
+        for t in problem.technicians
+    ]
+
+
+def inventory_to_table_rows(problem: ProblemInstance) -> list[dict[str, Any]]:
+    part_map = {p.part_id: p.name for p in problem.spare_parts}
+    return [
+        {
+            "Warehouse": inv.warehouse_id,
+            "Part": part_map.get(inv.part_id, inv.part_id),
+            "Qty": inv.quantity,
+            "Reorder Pt": inv.reorder_point,
+            "Safety Stock": inv.safety_stock,
+        }
+        for inv in problem.inventory
+    ]
+
+
+def requests_to_table_rows(problem: ProblemInstance) -> list[dict[str, Any]]:
+    return [
+        {
+            "Request": r.request_id,
+            "Site": r.site_name,
+            "Priority": r.priority,
+            "Emergency": "Yes" if r.is_emergency else "No",
+            "Part Type": r.required_part_type,
+            "Skill": r.required_skill,
+            "SLA (h)": r.sla_deadline_hours,
+        }
+        for r in problem.requests
+    ]

gradio/src/fieldops/inventory_optimization.py

@@ -0,0 +1,117 @@
+"""Multi-echelon inventory optimization."""
+
+from __future__ import annotations
+
+import math
+
+from fieldops.models import InventoryLevel, ProblemInstance, SparePart, Stage1Plan, Warehouse
+
+
+def _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dp = math.radians(lat2 - lat1)
+    dl = math.radians(lon2 - lon1)
+    a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+    return 2 * r * math.asin(math.sqrt(a))
+
+
+def optimize_inventory(
+    problem: ProblemInstance,
+    stock_vs_expedite: float = 0.5,
+) -> Stage1Plan:
+    """Heuristic multi-echelon inventory targeting with stock vs expedite trade-off."""
+    part_map: dict[str, SparePart] = {p.part_id: p for p in problem.spare_parts}
+    demand_by_part: dict[str, float] = {}
+    for req in problem.requests:
+        for part in problem.spare_parts:
+            if part.part_type == req.required_part_type:
+                demand_by_part[part.part_id] = demand_by_part.get(part.part_id, 0) + 1
+                break
+
+    targets: list[InventoryLevel] = []
+    total_holding = 0.0
+    stock_bias = stock_vs_expedite
+
+    for wh in problem.warehouses:
+        for part_id, demand in demand_by_part.items():
+            part = part_map[part_id]
+            base_stock = max(2, int(math.ceil(demand * (0.8 + stock_bias * 0.6))))
+            safety = max(1, int(base_stock * (0.3 + stock_bias * 0.2)))
+            reorder = max(1, base_stock // 2)
+            targets.append(InventoryLevel(
+                warehouse_id=wh.warehouse_id,
+                part_id=part_id,
+                quantity=base_stock,
+                reorder_point=reorder,
+                safety_stock=safety,
+            ))
+            total_holding += base_stock * part.holding_cost_per_day * problem.planning_horizon_days
+
+    tech_positions: dict[str, tuple[float, float]] = {}
+    region_sites: dict[str, list[tuple[float, float]]] = {}
+    for site in problem.sites:
+        region_sites.setdefault(site.site_id[:2], []).append((site.lat, site.lon))
+
+    for tech in problem.technicians:
+        site_coords = [(s.lat, s.lon) for s in problem.sites if s.site_id.startswith("S")]
+        if site_coords:
+            avg_lat = sum(c[0] for c in site_coords) / len(site_coords)
+            avg_lon = sum(c[1] for c in site_coords) / len(site_coords)
+            tech_positions[tech.technician_id] = (avg_lat, avg_lon)
+        else:
+            tech_positions[tech.technician_id] = (tech.home_lat, tech.home_lon)
+
+    contracts = []
+    for wh in problem.warehouses:
+        for part in problem.spare_parts[:3]:
+            contracts.append({
+                "warehouse": wh.warehouse_id,
+                "part": part.part_id,
+                "min_order_qty": 5,
+                "lead_time_days": 2 if stock_bias > 0.5 else 5,
+                "expedite_available": stock_bias < 0.7,
+            })
+
+    notes = [
+        f"Stock vs expedite ratio: {stock_vs_expedite:.0%} (higher = more pre-positioned inventory).",
+        f"Multi-echelon targets across {len(problem.warehouses)} warehouses.",
+        f"Estimated holding cost: ${total_holding:,.0f} over {problem.planning_horizon_days} days.",
+    ]
+
+    return Stage1Plan(
+        technician_positions=tech_positions,
+        inventory_targets=targets,
+        supply_contracts=contracts,
+        repair_shop_capacity=max(2, len(problem.technicians) // 3),
+        total_holding_cost=total_holding,
+        notes=notes,
+    )
+
+
+def find_nearest_warehouse(
+    warehouses: list[Warehouse],
+    inventory: list[InventoryLevel],
+    part_id: str,
+    lat: float,
+    lon: float,
+) -> tuple[Warehouse, int, float]:
+    """Return nearest warehouse with stock for part_id."""
+    inv_map = {(i.warehouse_id, i.part_id): i.quantity for i in inventory}
+    wh_map = {w.warehouse_id: w for w in warehouses}
+    best_wh, best_qty, best_dist = None, 0, float("inf")
+
+    for wh in warehouses:
+        qty = inv_map.get((wh.warehouse_id, part_id), 0)
+        if qty <= 0:
+            continue
+        dist = _haversine_km(lat, lon, wh.lat, wh.lon)
+        if dist < best_dist:
+            best_wh, best_qty, best_dist = wh, qty, dist
+
+    if best_wh is None:
+        best_wh = min(warehouses, key=lambda w: _haversine_km(lat, lon, w.lat, w.lon))
+        best_qty = 0
+        best_dist = _haversine_km(lat, lon, best_wh.lat, best_wh.lon)
+
+    return best_wh, best_qty, best_dist

gradio/src/fieldops/metrics.py

@@ -0,0 +1,76 @@
+"""KPI computation for field service operations."""
+
+from __future__ import annotations
+
+from fieldops.models import KPIMetrics, MLPrediction, ProblemInstance, Stage1Plan
+
+
+def compute_metrics(
+    problem: ProblemInstance,
+    assignments: list[dict],
+    stage1: Stage1Plan,
+    predictions: list[MLPrediction],
+) -> KPIMetrics:
+    pred_map = {p.request_id: p for p in predictions}
+    part_map = {p.part_id: p for p in problem.spare_parts}
+    site_map = {s.site_id: s for s in problem.sites}
+    req_map = {r.request_id: r for r in problem.requests}
+
+    sla_met = 0
+    total_mttr = 0.0
+    ftf_count = 0
+    stockouts = 0
+    expedite_count = 0
+    logistics_cost = 0.0
+    downtime_cost = 0.0
+
+    for a in assignments:
+        req = req_map[a["request_id"]]
+        pred = pred_map[a["request_id"]]
+        site = site_map.get(req.site_id)
+        downtime_rate = site.downtime_cost_per_hour if site else 500
+
+        duration = pred.predicted_duration_hours
+        travel = 0.5 + (req.lat % 1) * 2
+        mttr = duration + travel
+        total_mttr += mttr
+
+        if mttr <= req.sla_deadline_hours:
+            sla_met += 1
+
+        if pred.first_time_fix_probability > 0.7:
+            ftf_count += 1
+
+        if a.get("part_source") == "expedite_shipment":
+            expedite_count += 1
+            part = part_map.get(a["part_id"])
+            logistics_cost += (part.expedite_cost if part else 300)
+        elif a.get("part_source") == "warehouse_stock":
+            part = part_map.get(a["part_id"])
+            logistics_cost += (part.unit_cost * 0.1 if part else 50)
+        else:
+            logistics_cost += 80
+
+        if a.get("part_source") in ("expedite_shipment",) and a.get("defer"):
+            stockouts += 1
+
+        downtime_cost += mttr * downtime_rate * pred.failure_probability
+
+    n = max(len(assignments), 1)
+    tech_jobs: dict[str, int] = {}
+    for a in assignments:
+        tech_jobs[a["technician_id"]] = tech_jobs.get(a["technician_id"], 0) + 1
+    max_capacity = sum(t.max_jobs_per_day for t in problem.technicians)
+    utilization = sum(tech_jobs.values()) / max(max_capacity, 1) * 100
+
+    return KPIMetrics(
+        sla_compliance_pct=round(sla_met / n * 100, 1),
+        mean_time_to_repair_hours=round(total_mttr / n, 2),
+        first_time_fix_rate_pct=round(ftf_count / n * 100, 1),
+        emergency_stockout_count=stockouts,
+        technician_utilization_pct=round(utilization, 1),
+        total_logistics_cost=round(logistics_cost, 2),
+        total_downtime_cost=round(downtime_cost, 2),
+        total_holding_cost=round(stage1.total_holding_cost, 2),
+        expedite_shipments=expedite_count,
+    )

gradio/src/fieldops/ml_predictions.py

@@ -0,0 +1,89 @@
+"""Pre-trained ML prediction module (no training — fixed coefficients)."""
+
+from __future__ import annotations
+
+import math
+
+from fieldops.constants import PART_TYPES, STRESS_SCENARIOS
+from fieldops.models import MLPrediction, ProblemInstance, ServiceRequest
+
+# Pre-trained logistic coefficients (simulating LightGBM export)
+_COEFFS = {
+    "intercept": -2.1,
+    "age_factor": 0.35,
+    "criticality": {"critical": 1.2, "high": 0.7, "medium": 0.3, "low": 0.0},
+    "emergency": 0.9,
+    "wear_types": {"mechanical": 0.4, "electrical": 0.25, "sensor": 0.15, "wear": 0.5},
+}
+
+_DURATION_BASE = {"mechanical": 3.2, "electrical": 2.8, "sensor": 1.5, "wear": 4.0}
+_FTF_BASE = {"electrical": 0.82, "mechanical": 0.75, "sensor": 0.88, "wear": 0.70}
+
+
+def _sigmoid(x: float) -> float:
+    return 1.0 / (1.0 + math.exp(-max(-20, min(20, x))))
+
+
+def _site_criticality(problem: ProblemInstance, site_id: str) -> str:
+    for s in problem.sites:
+        if s.site_id == site_id:
+            return s.criticality
+    return "medium"
+
+
+def predict_request(problem: ProblemInstance, request: ServiceRequest) -> MLPrediction:
+    stress = STRESS_SCENARIOS.get(problem.stress_scenario, STRESS_SCENARIOS["baseline"])
+    crit = _site_criticality(problem, request.site_id)
+
+    logit = _COEFFS["intercept"]
+    logit += _COEFFS["criticality"].get(crit, 0.3)
+    logit += _COEFFS["wear_types"].get(request.failure_type, 0.2)
+    if request.is_emergency:
+        logit += _COEFFS["emergency"]
+    logit *= stress["failure_multiplier"]
+
+    failure_prob = _sigmoid(logit)
+    duration = _DURATION_BASE.get(request.failure_type, 3.0) * (0.8 + 0.4 * (1 - failure_prob))
+    ftf = _FTF_BASE.get(request.failure_type, 0.78) * (0.9 + 0.1 * (1 - failure_prob))
+    revisit = max(0.02, (1 - ftf) * 0.85)
+
+    part_idx = hash(request.failure_type + request.required_part_type) % len(PART_TYPES)
+    predicted_part = PART_TYPES[part_idx]
+
+    if failure_prob >= 0.6:
+        risk_tier = "high"
+    elif failure_prob >= 0.35:
+        risk_tier = "medium"
+    else:
+        risk_tier = "low"
+
+    return MLPrediction(
+        request_id=request.request_id,
+        site_id=request.site_id,
+        failure_probability=round(failure_prob, 4),
+        predicted_part_type=predicted_part,
+        predicted_duration_hours=round(duration, 2),
+        first_time_fix_probability=round(min(ftf, 0.98), 4),
+        revisit_probability=round(revisit, 4),
+        confidence=round(0.75 + 0.2 * (1 - abs(failure_prob - 0.5)), 4),
+        risk_tier=risk_tier,
+    )
+
+
+def predict_all(problem: ProblemInstance) -> list[MLPrediction]:
+    return [predict_request(problem, r) for r in problem.requests]
+
+
+def predictions_to_table_rows(predictions: list[MLPrediction]) -> list[dict]:
+    return [
+        {
+            "Request": p.request_id,
+            "P(Failure)": f"{p.failure_probability:.1%}",
+            "Part Type": p.predicted_part_type,
+            "Duration (h)": p.predicted_duration_hours,
+            "FTF": f"{p.first_time_fix_probability:.1%}",
+            "Revisit": f"{p.revisit_probability:.1%}",
+            "Risk": p.risk_tier,
+        }
+        for p in predictions
+    ]

gradio/src/fieldops/models.py

@@ -0,0 +1,243 @@
+"""Data models for field service optimization."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class Warehouse:
+    warehouse_id: str
+    name: str
+    region: str
+    lat: float
+    lon: float
+    capacity_units: int
+    expedite_cost_per_unit: float
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class SparePart:
+    part_id: str
+    name: str
+    part_type: str
+    unit_cost: float
+    holding_cost_per_day: float
+    expedite_cost: float
+    substitute_part_id: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class InventoryLevel:
+    warehouse_id: str
+    part_id: str
+    quantity: int
+    reorder_point: int
+    safety_stock: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class Technician:
+    technician_id: str
+    name: str
+    skills: list[str]
+    skill_level: float
+    hourly_rate: float
+    home_lat: float
+    home_lon: float
+    max_jobs_per_day: int
+    region: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ServiceSite:
+    site_id: str
+    name: str
+    asset_type: str
+    criticality: str
+    lat: float
+    lon: float
+    sla_hours: float
+    downtime_cost_per_hour: float
+    contract_tier: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ServiceRequest:
+    request_id: str
+    site_id: str
+    site_name: str
+    priority: str
+    failure_type: str
+    required_part_type: str
+    required_skill: str
+    estimated_duration_hours: float
+    is_emergency: bool
+    sla_deadline_hours: float
+    lat: float
+    lon: float
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class MLPrediction:
+    request_id: str
+    site_id: str
+    failure_probability: float
+    predicted_part_type: str
+    predicted_duration_hours: float
+    first_time_fix_probability: float
+    revisit_probability: float
+    confidence: float
+    risk_tier: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class Stage1Plan:
+    technician_positions: dict[str, tuple[float, float]]
+    inventory_targets: list[InventoryLevel]
+    supply_contracts: list[dict[str, Any]]
+    repair_shop_capacity: int
+    total_holding_cost: float
+    notes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "technician_positions": self.technician_positions,
+            "inventory_targets": [i.to_dict() for i in self.inventory_targets],
+            "supply_contracts": self.supply_contracts,
+            "repair_shop_capacity": self.repair_shop_capacity,
+            "total_holding_cost": self.total_holding_cost,
+            "notes": self.notes,
+        }
+
+
+@dataclass
+class MissionAssignment:
+    request_id: str
+    technician_id: str
+    technician_name: str
+    warehouse_id: str
+    part_id: str
+    part_source: str
+    route_order: int
+    scheduled_start_hours: float
+    estimated_arrival_hours: float
+    estimated_completion_hours: float
+    use_substitute: bool
+    defer_to_later: bool
+    rationale: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class KPIMetrics:
+    sla_compliance_pct: float
+    mean_time_to_repair_hours: float
+    first_time_fix_rate_pct: float
+    emergency_stockout_count: int
+    technician_utilization_pct: float
+    total_logistics_cost: float
+    total_downtime_cost: float
+    total_holding_cost: float
+    expedite_shipments: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class SimulationResult:
+    replications: int
+    sla_compliance_mean: float
+    mttr_mean: float
+    stockout_rate: float
+    avg_logistics_cost: float
+    avg_downtime_cost: float
+    confidence_interval_95: dict[str, tuple[float, float]]
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class OptimizationResult:
+    strategy: str
+    algorithm: str
+    stage1_plan: Stage1Plan
+    assignments: list[MissionAssignment]
+    ml_predictions: list[MLPrediction]
+    metrics: KPIMetrics
+    simulation: SimulationResult | None
+    solve_time_sec: float
+    status: str
+    notes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "strategy": self.strategy,
+            "algorithm": self.algorithm,
+            "stage1_plan": self.stage1_plan.to_dict(),
+            "assignments": [a.to_dict() for a in self.assignments],
+            "ml_predictions": [p.to_dict() for p in self.ml_predictions],
+            "metrics": self.metrics.to_dict(),
+            "simulation": self.simulation.to_dict() if self.simulation else None,
+            "solve_time_sec": self.solve_time_sec,
+            "status": self.status,
+            "notes": self.notes,
+        }
+
+
+@dataclass
+class ProblemInstance:
+    industry_id: str
+    stress_scenario: str
+    scenario_label: str
+    planning_horizon_days: int
+    warehouses: list[Warehouse]
+    spare_parts: list[SparePart]
+    inventory: list[InventoryLevel]
+    technicians: list[Technician]
+    sites: list[ServiceSite]
+    requests: list[ServiceRequest]
+    stock_vs_expedite_ratio: float = 0.5
+    reliability_target: float = 0.95
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "industry_id": self.industry_id,
+            "stress_scenario": self.stress_scenario,
+            "scenario_label": self.scenario_label,
+            "planning_horizon_days": self.planning_horizon_days,
+            "warehouses": [w.to_dict() for w in self.warehouses],
+            "spare_parts": [p.to_dict() for p in self.spare_parts],
+            "inventory": [i.to_dict() for i in self.inventory],
+            "technicians": [t.to_dict() for t in self.technicians],
+            "sites": [s.to_dict() for s in self.sites],
+            "requests": [r.to_dict() for r in self.requests],
+            "stock_vs_expedite_ratio": self.stock_vs_expedite_ratio,
+            "reliability_target": self.reliability_target,
+        }

gradio/src/fieldops/pipeline.py

@@ -0,0 +1,94 @@
+"""Demo pipeline for Hugging Face Space."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from fieldops.constants import ENGINE_VERSION, INDUSTRY_SCENARIOS, STRESS_SCENARIOS, STRATEGIES
+from fieldops.engine import FieldOpsEngine
+from fieldops.generator import generate_problem
+from fieldops.models import OptimizationResult, ProblemInstance
+
+
+class FieldOpsPipeline:
+    """Load pre-built benchmarks and serve interactive field service optimization."""
+
+    def __init__(self, assets_dir: Path | None = None):
+        self.assets_dir = Path(assets_dir) if assets_dir else None
+        self.engine = FieldOpsEngine()
+        self.summary: dict[str, Any] = {}
+        self.benchmarks: list[dict[str, Any]] = []
+
+    def load(self) -> None:
+        if self.assets_dir:
+            summary_path = self.assets_dir / "demo" / "summary.json"
+            bench_path = self.assets_dir / "demo" / "benchmarks.json"
+            if summary_path.exists():
+                self.summary = json.loads(summary_path.read_text(encoding="utf-8"))
+            if bench_path.exists():
+                self.benchmarks = json.loads(bench_path.read_text(encoding="utf-8"))
+
+    def get_industry_ids(self) -> list[str]:
+        return list(INDUSTRY_SCENARIOS.keys())
+
+    def get_stress_ids(self) -> list[str]:
+        return list(STRESS_SCENARIOS.keys())
+
+    def get_strategy_ids(self) -> list[str]:
+        return STRATEGIES
+
+    def get_industry_label(self, industry_id: str) -> str:
+        return INDUSTRY_SCENARIOS.get(industry_id, {}).get("label", industry_id)
+
+    def get_stress_label(self, stress_id: str) -> str:
+        return STRESS_SCENARIOS.get(stress_id, {}).get("label", stress_id)
+
+    def get_strategy_label(self, strategy_id: str) -> str:
+        labels = {
+            "two_stage_stochastic": "Two-Stage Stochastic Programming",
+            "multi_echelon_inventory": "Multi-Echelon Inventory Optimization",
+            "technician_routing": "Technician Routing (OR-Tools)",
+            "sample_average_approximation": "Sample Average Approximation (SAA)",
+            "alns_field_ops": "ALNS Field Operations",
+            "stock_vs_expedite": "Stock vs Expedite Trade-off",
+            "monte_carlo": "Monte Carlo Simulation",
+        }
+        return labels.get(strategy_id, strategy_id)
+
+    def build_problem(
+        self,
+        industry_id: str,
+        stress_id: str = "baseline",
+        num_sites: int | None = None,
+        stock_vs_expedite: float = 0.5,
+        reliability_target: float = 0.95,
+        seed: int = 42,
+    ) -> ProblemInstance:
+        meta = INDUSTRY_SCENARIOS[industry_id]
+        return generate_problem(
+            industry_id=industry_id,
+            stress_id=stress_id,
+            num_sites=num_sites or meta["default_sites"],
+            stock_vs_expedite=stock_vs_expedite,
+            reliability_target=reliability_target,
+            seed=seed,
+        )
+
+    def run_optimization(
+        self,
+        problem: ProblemInstance,
+        strategy: str,
+    ) -> OptimizationResult:
+        return self.engine.optimize(problem, strategy, run_simulation=True)
+
+    def run_comparison(self, problem: ProblemInstance) -> list[OptimizationResult]:
+        return self.engine.compare_strategies(problem)
+
+    def run_stock_expedite_analysis(self, problem: ProblemInstance) -> list[OptimizationResult]:
+        return self.engine.compare_stock_expedite(problem)
+
+    @property
+    def version(self) -> str:
+        return self.summary.get("version", ENGINE_VERSION)

gradio/src/fieldops/routing.py

@@ -0,0 +1,167 @@
+"""Technician routing with OR-Tools."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from fieldops.models import MissionAssignment, MLPrediction, ProblemInstance, ServiceRequest, Technician
+
+try:
+    from ortools.constraint_solver import pywrapcp, routing_enums_pb2
+    ORTOOLS_AVAILABLE = True
+except ImportError:
+    ORTOOLS_AVAILABLE = False
+
+
+def _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dp = math.radians(lat2 - lat1)
+    dl = math.radians(lon2 - lon1)
+    a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+    return 2 * r * math.asin(math.sqrt(a))
+
+
+def _travel_hours(dist_km: float, speed_kmh: float = 60.0) -> float:
+    return dist_km / speed_kmh
+
+
+def _greedy_route(
+    tech: Technician,
+    requests: list[ServiceRequest],
+    predictions: dict[str, MLPrediction],
+) -> list[tuple[ServiceRequest, float, float]]:
+    """Greedy nearest-neighbor fallback routing."""
+    remaining = sorted(
+        requests,
+        key=lambda r: (0 if r.is_emergency else 1, -predictions[r.request_id].failure_probability),
+    )
+    route: list[tuple[ServiceRequest, float, float]] = []
+    cur_lat, cur_lon = tech.home_lat, tech.home_lon
+    elapsed = 0.0
+
+    for req in remaining[: tech.max_jobs_per_day]:
+        dist = _haversine_km(cur_lat, cur_lon, req.lat, req.lon)
+        travel = _travel_hours(dist)
+        arrival = elapsed + travel
+        duration = predictions[req.request_id].predicted_duration_hours
+        route.append((req, arrival, arrival + duration))
+        elapsed = arrival + duration
+        cur_lat, cur_lon = req.lat, req.lon
+
+    return route
+
+
+def solve_routing(
+    problem: ProblemInstance,
+    predictions: list[MLPrediction],
+    assignments_meta: list[dict[str, Any]],
+) -> list[MissionAssignment]:
+    """Assign requests to technicians with routing."""
+    pred_map = {p.request_id: p for p in predictions}
+    meta_map = {m["request_id"]: m for m in assignments_meta}
+    results: list[MissionAssignment] = []
+
+    tech_requests: dict[str, list[ServiceRequest]] = {t.technician_id: [] for t in problem.technicians}
+    for req in problem.requests:
+        meta = meta_map.get(req.request_id)
+        if meta:
+            tech_requests[meta["technician_id"]].append(req)
+
+    for tech in problem.technicians:
+        reqs = tech_requests[tech.technician_id]
+        if not reqs:
+            continue
+
+        if ORTOOLS_AVAILABLE and len(reqs) <= 12:
+            route = _ortools_route(tech, reqs, pred_map)
+        else:
+            route = _greedy_route(tech, reqs, pred_map)
+
+        for order, (req, arrival, completion) in enumerate(route, 1):
+            meta = meta_map[req.request_id]
+            results.append(MissionAssignment(
+                request_id=req.request_id,
+                technician_id=tech.technician_id,
+                technician_name=tech.name,
+                warehouse_id=meta["warehouse_id"],
+                part_id=meta["part_id"],
+                part_source=meta["part_source"],
+                route_order=order,
+                scheduled_start_hours=arrival - _travel_hours(
+                    _haversine_km(tech.home_lat, tech.home_lon, req.lat, req.lon)
+                ),
+                estimated_arrival_hours=arrival,
+                estimated_completion_hours=completion,
+                use_substitute=meta.get("use_substitute", False),
+                defer_to_later=meta.get("defer", False),
+                rationale=meta.get("rationale", "Optimized assignment."),
+            ))
+
+    return results
+
+
+def _ortools_route(
+    tech: Technician,
+    requests: list[ServiceRequest],
+    pred_map: dict[str, MLPrediction],
+) -> list[tuple[ServiceRequest, float, float]]:
+    """OR-Tools VRP for single technician."""
+    n = len(requests)
+    if n == 0:
+        return []
+
+    locations = [(tech.home_lat, tech.home_lon)] + [(r.lat, r.lon) for r in requests]
+    size = n + 1
+
+    def dist_matrix(i: int, j: int) -> int:
+        lat1, lon1 = locations[i]
+        lat2, lon2 = locations[j]
+        return int(_haversine_km(lat1, lon1, lat2, lon2) * 100)
+
+    manager = pywrapcp.RoutingIndexManager(size, 1, 0)
+    routing = pywrapcp.RoutingModel(manager)
+
+    def distance_callback(from_idx: int, to_idx: int) -> int:
+        return dist_matrix(manager.IndexToNode(from_idx), manager.IndexToNode(to_idx))
+
+    transit_idx = routing.RegisterTransitCallback(distance_callback)
+    routing.SetArcCostEvaluatorOfAllVehicles(transit_idx)
+
+    for i, req in enumerate(requests, 1):
+        if req.is_emergency:
+            routing.AddDisjunction([manager.NodeToIndex(i)], 0)
+
+    search_params = pywrapcp.DefaultRoutingSearchParameters()
+    search_params.first_solution_strategy = (
+        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
+    )
+    search_params.time_limit.seconds = 5
+
+    solution = routing.SolveWithParameters(search_params)
+    if not solution:
+        return _greedy_route(tech, requests, pred_map)
+
+    route_order: list[int] = []
+    index = routing.Start(0)
+    while not routing.IsEnd(index):
+        node = manager.IndexToNode(index)
+        if node > 0:
+            route_order.append(node - 1)
+        index = solution.Value(routing.NextVar(index))
+
+    ordered = [requests[i] for i in route_order]
+    cur_lat, cur_lon = tech.home_lat, tech.home_lon
+    elapsed = 0.0
+    result: list[tuple[ServiceRequest, float, float]] = []
+    for req in ordered:
+        dist = _haversine_km(cur_lat, cur_lon, req.lat, req.lon)
+        travel = _travel_hours(dist)
+        arrival = elapsed + travel
+        duration = pred_map[req.request_id].predicted_duration_hours
+        result.append((req, arrival, arrival + duration))
+        elapsed = arrival + duration
+        cur_lat, cur_lon = req.lat, req.lon
+
+    return result

gradio/src/fieldops/scheduling.py

@@ -0,0 +1,105 @@
+"""Service scheduling and mission assignment."""
+
+from __future__ import annotations
+
+from fieldops.inventory_optimization import find_nearest_warehouse
+from fieldops.models import MLPrediction, ProblemInstance, ServiceRequest, Technician
+
+
+def _skill_match(tech: Technician, skill: str) -> float:
+    if skill in tech.skills:
+        return tech.skill_level
+    return tech.skill_level * 0.4
+
+
+def assign_missions(
+    problem: ProblemInstance,
+    predictions: list[MLPrediction],
+) -> list[dict]:
+    """Greedy skill-based assignment with parts sourcing."""
+    pred_map = {p.request_id: p for p in predictions}
+    part_map = {p.part_type: p for p in problem.spare_parts}
+    part_by_id = {p.part_id: p for p in problem.spare_parts}
+
+    sorted_requests = sorted(
+        problem.requests,
+        key=lambda r: (
+            0 if r.is_emergency else 1,
+            r.priority,
+            -pred_map[r.request_id].failure_probability,
+        ),
+    )
+
+    tech_load: dict[str, int] = {t.technician_id: 0 for t in problem.technicians}
+    assignments: list[dict] = []
+
+    for req in sorted_requests:
+        pred = pred_map[req.request_id]
+        best_tech, best_score = None, -1.0
+
+        for tech in problem.technicians:
+            if tech_load[tech.technician_id] >= tech.max_jobs_per_day:
+                continue
+            score = _skill_match(tech, req.required_skill)
+            if req.is_emergency and tech.region in ("north", "central"):
+                score *= 1.1
+            if score > best_score:
+                best_score = score
+                best_tech = tech
+
+        if best_tech is None:
+            best_tech = min(problem.technicians, key=lambda t: tech_load[t.technician_id])
+
+        part = part_map.get(req.required_part_type) or problem.spare_parts[0]
+        wh, qty, _ = find_nearest_warehouse(
+            problem.warehouses, problem.inventory, part.part_id, req.lat, req.lon,
+        )
+
+        use_substitute = qty == 0
+        part_source = "warehouse_stock"
+        defer = False
+
+        if qty == 0:
+            if problem.stock_vs_expedite_ratio < 0.5:
+                part_source = "expedite_shipment"
+            else:
+                sub_part = part_by_id.get(part.substitute_part_id or "")
+                if sub_part:
+                    wh2, qty2, _ = find_nearest_warehouse(
+                        problem.warehouses, problem.inventory,
+                        sub_part.part_id, req.lat, req.lon,
+                    )
+                    if qty2 > 0:
+                        part = sub_part
+                        wh = wh2
+                        use_substitute = True
+                        part_source = "substitute_part"
+                    else:
+                        part_source = "expedite_shipment"
+                else:
+                    part_source = "expedite_shipment"
+
+        if not req.is_emergency and pred.failure_probability < 0.25 and tech_load[best_tech.technician_id] >= 2:
+            defer = True
+            part_source = "deferred"
+
+        tech_load[best_tech.technician_id] += 1
+        rationale = (
+            f"{'Emergency' if req.is_emergency else 'Scheduled'} — "
+            f"skill match {best_score:.0%}, part via {part_source}"
+        )
+        if defer:
+            rationale += " (deferred to next window)"
+
+        assignments.append({
+            "request_id": req.request_id,
+            "technician_id": best_tech.technician_id,
+            "warehouse_id": wh.warehouse_id,
+            "part_id": part.part_id,
+            "part_source": part_source,
+            "use_substitute": use_substitute,
+            "defer": defer,
+            "rationale": rationale,
+        })
+
+    return assignments

gradio/src/fieldops/simulation.py

@@ -0,0 +1,82 @@
+"""Monte Carlo simulation with SimPy fallback."""
+
+from __future__ import annotations
+
+import random
+import statistics
+
+from fieldops.metrics import compute_metrics
+from fieldops.models import MissionAssignment, ProblemInstance, SimulationResult, Stage1Plan, MLPrediction
+
+
+def run_monte_carlo(
+    problem: ProblemInstance,
+    assignments: list[MissionAssignment],
+    stage1: Stage1Plan,
+    predictions: list[MLPrediction],
+    replications: int = 30,
+    seed: int = 42,
+) -> SimulationResult:
+    """Monte Carlo validation of field service plan."""
+    rng = random.Random(seed)
+    assign_dicts = [
+        {
+            "request_id": a.request_id,
+            "technician_id": a.technician_id,
+            "warehouse_id": a.warehouse_id,
+            "part_id": a.part_id,
+            "part_source": a.part_source,
+            "use_substitute": a.use_substitute,
+            "defer": a.defer_to_later,
+        }
+        for a in assignments
+    ]
+
+    sla_vals, mttr_vals, stockout_vals, log_vals, down_vals = [], [], [], [], []
+
+    for rep in range(replications):
+        perturbed = []
+        for i, pred in enumerate(predictions):
+            noise = rng.gauss(0, 0.15)
+            adj = MLPrediction(
+                request_id=pred.request_id,
+                site_id=pred.site_id,
+                failure_probability=min(0.99, max(0.01, pred.failure_probability + noise)),
+                predicted_part_type=pred.predicted_part_type,
+                predicted_duration_hours=max(0.5, pred.predicted_duration_hours * (1 + rng.gauss(0, 0.1))),
+                first_time_fix_probability=min(0.99, max(0.3, pred.first_time_fix_probability + rng.gauss(0, 0.05))),
+                revisit_probability=pred.revisit_probability,
+                confidence=pred.confidence,
+                risk_tier=pred.risk_tier,
+            )
+            perturbed.append(adj)
+
+        m = compute_metrics(problem, assign_dicts, stage1, perturbed)
+        sla_vals.append(m.sla_compliance_pct)
+        mttr_vals.append(m.mean_time_to_repair_hours * (1 + rng.uniform(-0.1, 0.15)))
+        stockout_vals.append(m.emergency_stockout_count / max(len(assignments), 1))
+        log_vals.append(m.total_logistics_cost * (1 + rng.uniform(-0.05, 0.1)))
+        down_vals.append(m.total_downtime_cost * (1 + rng.uniform(-0.08, 0.12)))
+
+    def ci(vals: list[float]) -> tuple[float, float]:
+        if len(vals) < 2:
+            v = vals[0] if vals else 0.0
+            return (v, v)
+        mean = statistics.mean(vals)
+        stdev = statistics.stdev(vals)
+        margin = 1.96 * stdev / (len(vals) ** 0.5)
+        return (round(mean - margin, 2), round(mean + margin, 2))
+
+    return SimulationResult(
+        replications=replications,
+        sla_compliance_mean=round(statistics.mean(sla_vals), 1),
+        mttr_mean=round(statistics.mean(mttr_vals), 2),
+        stockout_rate=round(statistics.mean(stockout_vals), 4),
+        avg_logistics_cost=round(statistics.mean(log_vals), 2),
+        avg_downtime_cost=round(statistics.mean(down_vals), 2),
+        confidence_interval_95={
+            "sla_compliance": ci(sla_vals),
+            "mttr": ci(mttr_vals),
+            "logistics_cost": ci(log_vals),
+        },
+    )

gradio/src/fieldops/stochastic.py

@@ -0,0 +1,75 @@
+"""Two-stage stochastic programming and Sample Average Approximation."""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from fieldops.inventory_optimization import optimize_inventory
+from fieldops.ml_predictions import predict_all
+from fieldops.models import OptimizationResult, ProblemInstance, Stage1Plan
+from fieldops.routing import solve_routing
+from fieldops.scheduling import assign_missions
+from fieldops.metrics import compute_metrics
+from fieldops.simulation import run_monte_carlo
+
+
+def _generate_scenarios(problem: ProblemInstance, n: int, seed: int = 42) -> list[list[float]]:
+    """SAA scenario generation for failure realizations."""
+    rng = random.Random(seed)
+    scenarios = []
+    for _ in range(n):
+        scenario = [rng.betavariate(2, 5) for _ in problem.requests]
+        scenarios.append(scenario)
+    return scenarios
+
+
+def solve_two_stage_stochastic(
+    problem: ProblemInstance,
+    n_scenarios: int = 20,
+) -> tuple[Stage1Plan, list[dict], list[str]]:
+    """Stage 1: inventory + positioning. Stage 2: assignment under scenarios."""
+    stage1 = optimize_inventory(problem, problem.stock_vs_expedite_ratio)
+    predictions = predict_all(problem)
+    scenarios = _generate_scenarios(problem, n_scenarios)
+
+    best_assignments = assign_missions(problem, predictions)
+    best_cost = float("inf")
+
+    for scenario in scenarios:
+        adj_predictions = []
+        for i, pred in enumerate(predictions):
+            from fieldops.models import MLPrediction
+            adj = MLPrediction(
+                request_id=pred.request_id,
+                site_id=pred.site_id,
+                failure_probability=min(0.99, pred.failure_probability * (0.5 + scenario[i])),
+                predicted_part_type=pred.predicted_part_type,
+                predicted_duration_hours=pred.predicted_duration_hours * (0.8 + 0.4 * scenario[i]),
+                first_time_fix_probability=pred.first_time_fix_probability,
+                revisit_probability=pred.revisit_probability,
+                confidence=pred.confidence,
+                risk_tier=pred.risk_tier,
+            )
+            adj_predictions.append(adj)
+
+        assignments = assign_missions(problem, adj_predictions)
+        metrics = compute_metrics(problem, assignments, stage1, adj_predictions)
+        total = metrics.total_logistics_cost + metrics.total_downtime_cost + stage1.total_holding_cost
+        if total < best_cost:
+            best_cost = total
+            best_assignments = assignments
+
+    notes = [
+        f"Two-stage stochastic: {n_scenarios} SAA scenarios evaluated.",
+        "Stage 1: multi-echelon inventory + technician positioning.",
+        "Stage 2: mission assignment minimizing expected logistics + downtime cost.",
+    ]
+    return stage1, best_assignments, notes
+
+
+def solve_saa(problem: ProblemInstance, n_samples: int = 50) -> tuple[Stage1Plan, list[dict], list[str]]:
+    """Sample Average Approximation for robust planning."""
+    stage1, assignments, notes = solve_two_stage_stochastic(problem, n_samples)
+    notes.append(f"SAA with {n_samples} independent failure samples.")
+    return stage1, assignments, notes

gradio/src/fieldops/visualization.py

@@ -0,0 +1,192 @@
+"""Plotly visualizations for FieldOps."""
+
+from __future__ import annotations
+
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from fieldops.models import OptimizationResult, ProblemInstance
+
+
+def result_summary_markdown(result: OptimizationResult) -> str:
+    m = result.metrics
+    sim = result.simulation
+    sim_line = ""
+    if sim:
+        sim_line = (
+            f"\n- **Monte Carlo SLA:** {sim.sla_compliance_mean:.1f}% "
+            f"(95% CI: {sim.confidence_interval_95['sla_compliance'][0]:.1f}–"
+            f"{sim.confidence_interval_95['sla_compliance'][1]:.1f}%)"
+        )
+
+    return (
+        f"### Optimization Result — {result.algorithm}\n"
+        f"- **Status:** {result.status} | **Solve time:** {result.solve_time_sec:.2f}s\n"
+        f"- **SLA Compliance:** {m.sla_compliance_pct:.1f}% | "
+        f"**MTTR:** {m.mean_time_to_repair_hours:.1f}h | "
+        f"**FTF Rate:** {m.first_time_fix_rate_pct:.1f}%\n"
+        f"- **Technician Utilization:** {m.technician_utilization_pct:.1f}% | "
+        f"**Emergency Stockouts:** {m.emergency_stockout_count}\n"
+        f"- **Logistics Cost:** ${m.total_logistics_cost:,.0f} | "
+        f"**Downtime Cost:** ${m.total_downtime_cost:,.0f} | "
+        f"**Holding Cost:** ${m.total_holding_cost:,.0f}\n"
+        f"- **Expedite Shipments:** {m.expedite_shipments}"
+        f"{sim_line}"
+    )
+
+
+def kpi_radar_chart(result: OptimizationResult):
+    m = result.metrics
+    categories = [
+        "SLA Compliance", "FTF Rate", "Tech Utilization",
+        "Cost Efficiency", "Stock Coverage",
+    ]
+    cost_eff = max(0, 100 - min(m.total_logistics_cost / 500, 100))
+    stock_cov = max(0, 100 - m.emergency_stockout_count * 20)
+    values = [
+        m.sla_compliance_pct,
+        m.first_time_fix_rate_pct,
+        m.technician_utilization_pct,
+        cost_eff,
+        stock_cov,
+    ]
+
+    fig = go.Figure(data=go.Scatterpolar(
+        r=values + [values[0]],
+        theta=categories + [categories[0]],
+        fill="toself",
+        name=result.strategy,
+        line_color="#2563eb",
+    ))
+    fig.update_layout(
+        polar=dict(radialaxis=dict(visible=True, range=[0, 100])),
+        title="Field Service KPI Radar",
+        height=400,
+        margin=dict(t=60, b=40),
+    )
+    return fig
+
+
+def cost_breakdown_chart(result: OptimizationResult):
+    m = result.metrics
+    labels = ["Logistics", "Downtime", "Holding", "Expedite"]
+    values = [
+        m.total_logistics_cost,
+        m.total_downtime_cost,
+        m.total_holding_cost,
+        m.expedite_shipments * 250,
+    ]
+    fig = go.Figure(data=[go.Pie(
+        labels=labels, values=values, hole=0.4,
+        marker_colors=["#3b82f6", "#ef4444", "#f59e0b", "#8b5cf6"],
+    )])
+    fig.update_layout(title="Cost Breakdown", height=380, margin=dict(t=50, b=20))
+    return fig
+
+
+def mission_map_chart(problem: ProblemInstance, result: OptimizationResult):
+    fig = go.Figure()
+
+    for wh in problem.warehouses:
+        fig.add_trace(go.Scattergeo(
+            lon=[wh.lon], lat=[wh.lat],
+            mode="markers+text", text=[wh.name],
+            marker=dict(size=12, color="#f59e0b", symbol="square"),
+            name="Warehouse",
+        ))
+
+    for site in problem.sites:
+        fig.add_trace(go.Scattergeo(
+            lon=[site.lon], lat=[site.lat],
+            mode="markers",
+            marker=dict(
+                size=8,
+                color="#ef4444" if site.criticality == "critical" else "#6b7280",
+            ),
+            name="Service Site",
+            showlegend=False,
+        ))
+
+    for tech in problem.technicians:
+        pos = result.stage1_plan.technician_positions.get(
+            tech.technician_id, (tech.home_lat, tech.home_lon),
+        )
+        fig.add_trace(go.Scattergeo(
+            lon=[pos[1]], lat=[pos[0]],
+            mode="markers",
+            marker=dict(size=10, color="#2563eb", symbol="triangle-up"),
+            name="Technician",
+            showlegend=False,
+        ))
+
+    fig.update_layout(
+        title="Field Operations Map",
+        geo=dict(scope="europe", projection_type="natural earth"),
+        height=450,
+        margin=dict(t=50, b=20),
+    )
+    return fig
+
+
+def strategy_comparison_chart(results: list[OptimizationResult]):
+    strategies = [r.strategy.replace("_", " ").title() for r in results]
+    sla = [r.metrics.sla_compliance_pct for r in results]
+    mttr = [r.metrics.mean_time_to_repair_hours for r in results]
+    cost = [r.metrics.total_logistics_cost + r.metrics.total_downtime_cost for r in results]
+
+    fig = make_subplots(rows=1, cols=3, subplot_titles=("SLA %", "MTTR (h)", "Total Cost ($)"))
+    fig.add_trace(go.Bar(x=strategies, y=sla, marker_color="#2563eb"), row=1, col=1)
+    fig.add_trace(go.Bar(x=strategies, y=mttr, marker_color="#ef4444"), row=1, col=2)
+    fig.add_trace(go.Bar(x=strategies, y=cost, marker_color="#f59e0b"), row=1, col=3)
+    fig.update_layout(title="Strategy Comparison", height=400, showlegend=False,
+                      margin=dict(t=60, b=80))
+    return fig
+
+
+def stock_expedite_chart(results: list[OptimizationResult]):
+    ratios = [f"{r.stage1_plan.notes[0].split(':')[1].strip() if r.stage1_plan.notes else '50%'}" for r in results]
+    holding = [r.metrics.total_holding_cost for r in results]
+    expedite = [r.metrics.expedite_shipments * 250 for r in results]
+    total = [h + e + r.metrics.total_logistics_cost for h, e, r in zip(holding, expedite, results)]
+
+    fig = go.Figure()
+    fig.add_trace(go.Bar(name="Holding Cost", x=[f"{i*20+20}%" for i in range(len(results))], y=holding))
+    fig.add_trace(go.Bar(name="Expedite Cost", x=[f"{i*20+20}%" for i in range(len(results))], y=expedite))
+    fig.add_trace(go.Scatter(
+        name="Total Cost", x=[f"{i*20+20}%" for i in range(len(results))],
+        y=total, mode="lines+markers", line=dict(color="#ef4444", width=3),
+    ))
+    fig.update_layout(
+        title="Stock vs Expedite Trade-off",
+        barmode="stack", height=400,
+        xaxis_title="Stock Ratio", yaxis_title="Cost ($)",
+        margin=dict(t=50, b=40),
+    )
+    return fig
+
+
+def assignment_gantt(result: OptimizationResult):
+    if not result.assignments:
+        return None
+
+    fig = go.Figure()
+    colors = {"P1": "#ef4444", "P2": "#f59e0b", "P3": "#3b82f6", "P4": "#6b7280"}
+
+    for a in result.assignments:
+        fig.add_trace(go.Bar(
+            name=a.request_id,
+            y=[a.technician_name],
+            x=[a.estimated_completion_hours - a.estimated_arrival_hours],
+            base=[a.estimated_arrival_hours],
+            orientation="h",
+            marker_color="#2563eb",
+            showlegend=False,
+        ))
+
+    fig.update_layout(
+        title="Mission Schedule Gantt",
+        xaxis_title="Hours from start",
+        height=max(300, len(set(a.technician_name for a in result.assignments)) * 50),
+        margin=dict(t=50, b=40),
+    )
+    return fig

index.html

@@ -1,19 +1,183 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>FieldOps — Service Parts & Field Operations Optimizer</title>
+  <style>
+    :root {
+      --accent: #2563eb; --accent2: #4f46e5;
+      --bg: #0f172a; --surface: #1e293b; --border: #334155;
+      --text: #f8fafc; --muted: #94a3b8;
+      --gradient: linear-gradient(135deg, #2563eb 0%, #4f46e5 100%);
+      --ok: #34d399; --warn: #fbbf24;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: Inter, system-ui, sans-serif; background: var(--bg); color: var(--text); line-height: 1.6; }
+    a { color: #93c5fd; text-decoration: none; }
+    .hero { padding: 3rem 1.5rem 1.5rem; text-align: center;
+      background: radial-gradient(ellipse at 50% 0%, rgba(37,99,235,.15), transparent 60%); }
+    .badge { display: inline-block; background: var(--gradient); color: #fff; font-size: .7rem;
+      font-weight: 700; letter-spacing: .12em; padding: .35rem 1rem; border-radius: 999px; margin-bottom: 1rem; }
+    h1 { font-size: clamp(1.7rem, 5vw, 2.5rem); font-weight: 800; }
+    h1 span { background: var(--gradient); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+    .subtitle { color: var(--muted); max-width: 780px; margin: .75rem auto 1rem; font-size: .95rem; }
+    .container { max-width: 1180px; margin: 0 auto; padding: 0 1.5rem 3rem; }
+    .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(130px, 1fr)); gap: .85rem; margin: 1.5rem 0; }
+    .kpi { background: var(--surface); border: 1px solid var(--border); border-radius: .75rem; padding: 1rem; text-align: center; }
+    .kpi .val { font-size: 1.45rem; font-weight: 800; color: var(--accent); }
+    .kpi .lbl { color: var(--muted); font-size: .75rem; margin-top: .2rem; }
+    .links { display: flex; gap: .75rem; justify-content: center; flex-wrap: wrap; margin-top: .75rem; }
+    .cta { padding: .65rem 1.2rem; background: var(--gradient); color: #fff; border-radius: .5rem; font-weight: 600; font-size: .85rem; }
+    .cta-out { padding: .65rem 1.2rem; border: 1px solid var(--border); border-radius: .5rem; font-size: .85rem; }
+    .scenario-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 1rem; margin: 1.25rem 0; }
+    .scenario { background: var(--surface); border: 1px solid var(--border); border-radius: .75rem; padding: 1.1rem; border-left: 4px solid var(--accent); }
+    .scenario h3 { font-size: 1rem; margin-bottom: .5rem; }
+    .scenario .meta { font-size: .82rem; color: var(--muted); margin: .35rem 0; }
+    .scenario .metric { font-size: 1.1rem; font-weight: 700; color: var(--ok); }
+    select { background: var(--surface); color: var(--text); border: 1px solid var(--border); border-radius: .5rem; padding: .5rem .75rem; margin: .5rem 0; }
+    table { width: 100%; border-collapse: collapse; background: var(--surface); border-radius: .75rem; overflow: hidden;
+      border: 1px solid var(--border); margin: 1rem 0; font-size: .8rem; }
+    th { background: #152238; text-align: left; padding: .6rem .9rem; color: var(--muted); font-weight: 600; }
+    td { padding: .55rem .9rem; border-top: 1px solid var(--border); }
+    h2 { font-size: 1.15rem; margin: 1.5rem 0 .5rem; }
+    .note { color: var(--muted); font-size: .85rem; margin: .5rem 0 1rem; }
+    .footer { text-align: center; color: var(--muted); font-size: .82rem; padding: 1.5rem; border-top: 1px solid var(--border); }
+    .stage { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; margin: 1rem 0; }
+    .stage-card { background: var(--surface); border: 1px solid var(--border); border-radius: .75rem; padding: 1rem; }
+    .stage-card h3 { font-size: .9rem; color: var(--accent); margin-bottom: .5rem; }
+    .stage-card ul { font-size: .82rem; color: var(--muted); padding-left: 1.2rem; }
+    @media (max-width: 640px) { .stage { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <section class="hero">
+    <div class="badge">FIELD SERVICE · SPARE PARTS · OPTIMIZATION</div>
+    <h1><span>Service Parts & Field Operations Optimizer</span></h1>
+    <p class="subtitle">Predict-then-optimize platform for aftermarket field service. ML failure prediction, multi-echelon inventory, technician routing, and Monte Carlo SLA validation.</p>
+    <div class="links">
+      <a class="cta" href="https://huggingface.co/datasets/alirezaaminzadeh/fieldops-sample-scenarios">Dataset</a>
+      <a class="cta-out" href="https://huggingface.co/alirezaaminzadeh/fieldops-solver-config">Solver Config</a>
+      <a class="cta-out" href="https://huggingface.co/datasets/alirezaaminzadeh/fieldops-sample-scenarios/tree/main/space-bundle">Gradio Bundle</a>
+    </div>
+  </section>
+
+  <div class="container">
+    <div class="kpi-grid">
+      <div class="kpi"><div class="val">7</div><div class="lbl">Algorithms</div></div>
+      <div class="kpi"><div class="val">9</div><div class="lbl">Industries</div></div>
+      <div class="kpi"><div class="val" id="k-sla">—</div><div class="lbl">Avg SLA %</div></div>
+      <div class="kpi"><div class="val" id="k-mttr">—</div><div class="lbl">Avg MTTR</div></div>
+      <div class="kpi"><div class="val" id="k-ftf">—</div><div class="lbl">FTF Rate</div></div>
+    </div>
+
+    <h2>Two-Stage Decision Model</h2>
+    <div class="stage">
+      <div class="stage-card">
+        <h3>Stage 1 — Pre-Failure Planning</h3>
+        <ul>
+          <li>Technician positioning across regions</li>
+          <li>Multi-echelon spare parts inventory</li>
+          <li>Supply contract parameters</li>
+          <li>Repair shop capacity allocation</li>
+        </ul>
+      </div>
+      <div class="stage-card">
+        <h3>Stage 2 — Post-Failure Response</h3>
+        <ul>
+          <li>Mission assignment to technicians</li>
+          <li>OR-Tools route optimization</li>
+          <li>Parts sourcing (stock / substitute / expedite)</li>
+          <li>Repair scheduling with deferral</li>
+        </ul>
+      </div>
+    </div>
+
+    <h2>Scenario Explorer</h2>
+    <p class="note">Pre-computed two-stage stochastic optimization results. Select an industry scenario.</p>
+    <label>Industry: <select id="scenario-select"></select></label>
+    <div class="scenario-grid" id="scenarios"></div>
+
+    <h2>Benchmark Summary</h2>
+    <div style="overflow-x:auto">
+      <table>
+        <thead>
+          <tr><th>Industry</th><th>Stress</th><th>SLA %</th><th>MTTR (h)</th><th>FTF %</th><th>Logistics $</th><th>Solve (s)</th></tr>
+        </thead>
+        <tbody id="bench-body"></tbody>
+      </table>
+    </div>
+
+    <h2>Stack</h2>
+    <p class="note">OR-Tools VRP · Multi-echelon inventory · Two-stage stochastic · ALNS · SAA · Monte Carlo · Pre-trained ML · Plotly · Gradio console (bundled)</p>
+  </div>
+
+  <footer class="footer">FieldOps v1.0 · Apache 2.0 · Field Service Engineering</footer>
+
+  <script>
+    const SCENARIOS = ["industrial_equipment", "medical_equipment", "telecom", "data_center", "elevators"];
+    const LABELS = {
+      industrial_equipment: "Industrial Equipment",
+      medical_equipment: "Medical Equipment",
+      telecom: "Telecom Infrastructure",
+      data_center: "Data Center",
+      elevators: "Elevators & Lifts"
+    };
+    const SAMPLES = {};
+
+    async function load() {
+      const [summary, benchmarks, ...samples] = await Promise.all([
+        fetch("assets/demo/summary.json").then(r => r.json()),
+        fetch("assets/demo/benchmarks.json").then(r => r.json()),
+        ...SCENARIOS.map(s => fetch(`assets/samples/sample_${s}.json`).then(r => r.json()).catch(() => null))
+      ]);
+      SCENARIOS.forEach((s, i) => { if (samples[i]) SAMPLES[s] = samples[i]; });
+
+      const sel = document.getElementById("scenario-select");
+      SCENARIOS.forEach(s => {
+        const o = document.createElement("option");
+        o.value = s; o.textContent = LABELS[s] || s;
+        sel.appendChild(o);
+      });
+
+      const avgSla = benchmarks.reduce((a, b) => a + b.sla_compliance_pct, 0) / benchmarks.length;
+      const avgMttr = benchmarks.reduce((a, b) => a + b.mttr_hours, 0) / benchmarks.length;
+      const avgFtf = benchmarks.reduce((a, b) => a + b.ftf_rate_pct, 0) / benchmarks.length;
+      document.getElementById("k-sla").textContent = avgSla.toFixed(0) + "%";
+      document.getElementById("k-mttr").textContent = avgMttr.toFixed(1) + "h";
+      document.getElementById("k-ftf").textContent = avgFtf.toFixed(0) + "%";
+
+      const tbody = document.getElementById("bench-body");
+      benchmarks.forEach(b => {
+        const tr = document.createElement("tr");
+        tr.innerHTML = `<td>${LABELS[b.industry] || b.industry}</td><td>${b.stress}</td>
+          <td>${b.sla_compliance_pct}%</td><td>${b.mttr_hours}</td>
+          <td>${b.ftf_rate_pct}%</td><td>$${b.logistics_cost.toLocaleString()}</td>
+          <td>${b.solve_time_sec.toFixed(2)}s</td>`;
+        tbody.appendChild(tr);
+      });
+
+      function renderScenario(sc) {
+        const data = SAMPLES[sc];
+        if (!data) return;
+        const m = data.optimization.metrics;
+        const sim = data.optimization.simulation;
+        const grid = document.getElementById("scenarios");
+        grid.innerHTML = `
+          <div class="scenario">
+            <h3>${data.scenario_label}</h3>
+            <div class="meta">Sites: ${data.summary.sites} · Technicians: ${data.summary.technicians} · Warehouses: ${data.summary.warehouses}</div>
+            <div class="metric">SLA Compliance: ${m.sla_compliance_pct}%</div>
+            <div class="meta">MTTR: ${m.mean_time_to_repair_hours}h · FTF: ${m.first_time_fix_rate_pct}% · Utilization: ${m.technician_utilization_pct}%</div>
+            <div class="meta">Logistics: $${m.total_logistics_cost.toLocaleString()} · Downtime: $${m.total_downtime_cost.toLocaleString()} · Expedite: ${m.expedite_shipments}</div>
+            ${sim ? `<div class="meta">Monte Carlo: SLA ${sim.sla_compliance_mean}% (95% CI: ${sim.confidence_interval_95.sla_compliance[0]}–${sim.confidence_interval_95.sla_compliance[1]}%)</div>` : ""}
+          </div>`;
+      }
+
+      sel.addEventListener("change", () => renderScenario(sel.value));
+      renderScenario(SCENARIOS[0]);
+    }
+    load();
+  </script>
+</body>
+</html>