[FIX] Optimization: harden LP robustness + clip floating-point residuals

- Clip resource_used_total to 10 decimal places and resource_remaining to 0
when within 1e-9 of zero, eliminating LP solver noise in exported values
- Guard against None resource_caps input
- Clamp negative absolute method caps to 0 to avoid infeasible LP
- Deactivate methods whose effective coefficients are all zero to prevent
unbounded LP variables
- Return zero result early when no resource caps are defined at all

optimization/optimization.py

@@ -333,14 +333,20 @@ def extract_resource_usage(
             if used > 1e-9:
                 resource_usage[batch_name][m] = float(used)
 
-    resource_used_total = {r: sum(v.values()) for r, v in resource_usage.items()}
+    _EPS = 1e-9
+    resource_used_total = {
+        r: round(sum(v.values()), 10) for r, v in resource_usage.items()
+    }
     all_caps = {
         **resource_caps,
         **{batch_name: specs["amount"] for batch_name, specs in custom_batch_specs.items()},
     }
     resource_remaining = {
-        r: all_caps.get(r, 0.0) - resource_used_total.get(r, 0.0)
-        for r in all_caps
+        r: max(0.0, v) if abs(v) >= _EPS else 0.0
+        for r, v in {
+            r: all_caps.get(r, 0.0) - resource_used_total.get(r, 0.0)
+            for r in all_caps
+        }.items()
     }
     return resource_usage, resource_used_total, resource_remaining
 
@@ -418,19 +424,63 @@ def run_optimization(
                 resource_actual_gain (dict).
             (False, {"message": str}) on failure.
     """
+    if resource_caps is None:
+        return False, {"message": "resource_caps cannot be None."}
+
     resource_caps = dict(resource_caps)
     method_costs  = apply_enabled_methods(method_costs, enabled_methods)
 
+    # Clamp negative absolute caps to 0 to avoid infeasible LP.
+    for m, c in method_constraints.items():
+        if c.get("cap_type") == "absolute" and c.get("cap_value", 0) < 0:
+            method_constraints = {
+                **method_constraints,
+                m: {**c, "cap_value": 0.0},
+            }
+
     custom_batch_specs, group_to_custom_batches, custom_batch_names = build_custom_batch_structures(
         method_costs, resource_caps, custom_resources
     )
 
+    # Deactivate methods whose effective coefficients are all zero — they would
+    # otherwise create unconstrained LP variables and cause an unbounded problem.
+    # Runs AFTER build_custom_batch_structures so that batch coefficients injected
+    # into method_costs are visible here. Without this ordering, a method that relies
+    # solely on a custom batch (standard pool blocked via enabled_methods) would be
+    # wrongly deactivated because its standard coefficients all appear zero.
+    # Iterate over method_costs (not just method_constraints) to catch methods
+    # that are active by default (not present in method_constraints at all).
+    safe = {m: c.copy() for m, c in method_constraints.items()}
+    for m in method_costs:
+        c = safe.get(m, {"active": True, "cap_type": "percent", "cap_value": 100})
+        if not c.get("active", True):
+            continue
+        coeffs = method_costs.get(m, {})
+        if all(v == 0 for v in coeffs.values()) if coeffs else True:
+            safe[m] = {**c, "active": False}
+    method_constraints = safe
+
     active_methods  = [m for m in method_costs if method_constraints.get(m, {}).get("active", True)]
     num_methods     = len(active_methods)
     method_to_index = {m: j for j, m in enumerate(active_methods)}
     if not num_methods:
         return False, {"message": "No active methods."}
 
+    # If there are no resource caps at all (not even custom batches), the LP has no
+    # upper bound on y_m — only percent-type method caps apply, which are relative and
+    # don't fix the scale. Return zero rather than letting HiGHS report "unbounded".
+    all_caps = {**resource_caps, **{b["name"]: float(b.get("amount", 0)) for b in (custom_resources or [])}}
+    if not all_caps:
+        empty_result = {
+            "total_removed": 0.0,
+            "method_usage": {},
+            "resource_usage": {},
+            "resource_used_total": {},
+            "resource_remaining": {},
+            "resource_actual_gain": {},
+        }
+        return True, empty_result
+
     custom_usage_pairs, custom_pair_to_index, num_lp_vars = build_lp_indices(
         active_methods, num_methods, custom_batch_specs, resource_caps, method_costs
     )