[FIX] Resolve percent caps against each method's standalone potential

Previously, "percent" caps were applied as a fraction of the combined
portfolio output — a self-referential formula where one method's cap
depended on every other active method's output. An out-of-range cap
(e.g. from a corrupted scenario file) could silently zero the entire
portfolio.

Now, each method's percent cap is resolved against its own isolated
maximum: the output it would achieve if it were the only active method,
unconstrained. Adds compute_standalone_potential() in optimization.py
and integrates the conversion in run_optimization() before the LP is
solved. Clamps cap_value to [0, 100] before computing.

Wording updated across tab0, tab2, tab4, tab5, and data_utils:
"% of total potential" / "% of potential" → "% of its potential".

optimization/optimization.py

@@ -452,6 +452,41 @@ def run_perturbation(constraint_labels, A_ub, b_ub, objective_coefficients, boun
     return resource_actual_gain
 
 
+def compute_standalone_potential(method, resource_caps, method_costs, custom_resources, enabled_methods):
+    """Compute a method's own maximum achievable output, in isolation.
+
+    "Isolation" means solving as if this were the only active method — no
+    competition for shared resources from any other method, and no cap of
+    its own applied. This is what "% of its total potential" (the method's
+    OWN ceiling) should be a percentage of, as opposed to a self-referential
+    "% of the combined output of every active method", which depends on
+    what every other method happens to be doing.
+
+    Args:
+        method (str): the method to isolate.
+        resource_caps (dict): {resource: available amount}.
+        method_costs (dict): {method: {resource: coefficient}} — already
+            reflecting any enabled_methods zeroing.
+        custom_resources (list | None): custom batch dicts (safe to pass the
+            full list — batches tied to other methods simply produce no
+            usage pairs once every other method is excluded).
+        enabled_methods (dict | None): {resource: {method: bool}}.
+
+    Returns:
+        float: the method's standalone potential in MtCO₂ (0.0 if it can't
+            produce anything on its own).
+    """
+    _UNCAPPED = 1e15
+    success, result = run_optimization(
+        resource_caps=resource_caps,
+        method_constraints={method: {"active": True, "cap_type": "absolute", "cap_value": _UNCAPPED}},
+        method_costs={method: dict(method_costs.get(method, {}))},
+        custom_resources=custom_resources,
+        enabled_methods=enabled_methods,
+    )
+    return result["total_removed"] if success else 0.0
+
+
 def run_optimization(
     resource_caps,
     method_constraints,
@@ -503,6 +538,30 @@ def run_optimization(
                 m: {**c, "cap_value": 0.0},
             }
 
+    # Convert "percent" caps into an equivalent absolute cap computed from the
+    # method's OWN standalone potential (its max output if it were the only
+    # active method, unconstrained by any cap) — matches the documented
+    # meaning of "% of its total potential", instead of a self-referential
+    # "% of the combined output of every active method". The old
+    # self-referential form made one method's cap depend on what every other
+    # active method happened to produce, and — since it's a ratio against a
+    # value that includes the capped method itself — an out-of-range percent
+    # (e.g. a negative value from a corrupted import) could force the ENTIRE
+    # portfolio to zero, not just the misconfigured method. Clamp cap_value to
+    # [0, 100] first (the UI slider already restricts to this range, but a
+    # loaded scenario file might not).
+    resolved_constraints = {}
+    for m, c in method_constraints.items():
+        if c.get("cap_type") == "percent" and c.get("active", True):
+            cap_value = max(0.0, min(100.0, c.get("cap_value", 100)))
+            potential = compute_standalone_potential(
+                m, resource_caps, method_costs, custom_resources, enabled_methods,
+            )
+            resolved_constraints[m] = {**c, "cap_type": "absolute", "cap_value": potential * cap_value / 100.0}
+        else:
+            resolved_constraints[m] = c
+    method_constraints = resolved_constraints
+
     custom_batch_specs, group_to_custom_batches, custom_batch_names = build_custom_batch_structures(
         method_costs, resource_caps, custom_resources
     )

tabs/tab0_welcome.py

@@ -34,7 +34,7 @@ def render_tab():
 
     <h3 class="wt wt-2">Optional:</h3>
     <ol start="2">
-        <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of total potential or absolute value in {CO2_UNIT}/yr).</li>
+        <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of its total potential or absolute value in {CO2_UNIT}/yr).</li>
         <li><b>Resource efficiency coefficients</b>: adjust the resource usage for each method.</li>
     </ol>
 

tabs/tab2_constraints.py

@@ -274,7 +274,7 @@ def render_method(m, cols, i, cost_sliders_norm):
             ["percent", "absolute"],
             horizontal=True,
             key=cap_type_key,
-            format_func=lambda x: "% of total potential"
+            format_func=lambda x: "% of its total potential"
             if x == "percent"
             else f"Absolute ({CO2_UNIT}/yr)",
             label_visibility="collapsed",

tabs/tab4_optimization.py

@@ -984,7 +984,7 @@ def export_scenario():
         method_constraints_export = scenario.get("method_constraints", {})
         alloc_df["Cap constraint"] = pd.Series({
             m: (f"{c['cap_value']:,g} {CO2_UNIT}/yr" if c.get("cap_type") == "absolute"
-                else f"{int(c.get('cap_value', 100))}% of potential")
+                else f"{int(c.get('cap_value', 100))}% of its potential")
             for m, c in method_constraints_export.items()
         })
         alloc_df = alloc_df.sort_values(f"{CO2_UNIT} removed", ascending=False)

tabs/tab5_sensitivity.py

@@ -153,7 +153,7 @@ def panel_method_sensitivity(baseline_removed):
     )
     st.markdown(
         '<p class="caption">Each line shows how total CO₂ removal changes as one method\'s maximum deployment cap varies from 0% to 100% of its current setting: '
-        'whether that cap was defined as a percentage of potential or as an absolute value in the Method constraints tab. '
+        'whether that cap was defined as a percentage of its potential or as an absolute value in the Method constraints tab. '
         '<br>The scale stops at 100% because the cap represents a ceiling you set: going beyond it would mean overriding your own constraint. '
         '<br>A steep curve means the cap is a binding constraint: relaxing it would allow more removal. '
         '<br>A flat line means the method is already limited by resource availability, not by its cap.</p>',
@@ -220,7 +220,7 @@ def panel_method_sensitivity(baseline_removed):
             if cap_type == "percent":
                 actual_cap = min(100, current_cap * pct / 100)
                 perturbed_constraints[method]["cap_value"] = actual_cap
-                cap_label = f"{actual_cap:.0f}% of potential"
+                cap_label = f"{actual_cap:.0f}% of its potential"
             else:
                 actual_cap = current_cap * pct / 100
                 perturbed_constraints[method]["cap_value"] = actual_cap

utils/data_utils.py

@@ -598,7 +598,7 @@ def build_results_df(allocations: dict, method_constraints: dict | None = None)
             if c.get("cap_type") == "absolute":
                 caps[m] = f"{c['cap_value']:,g} {CO2_UNIT}/yr"
             elif c.get("cap_type") == "percent":
-                caps[m] = f"{int(c.get('cap_value', 100))}% of potential"
+                caps[m] = f"{int(c.get('cap_value', 100))}% of its potential"
             else:
                 caps[m] = f"⚠️ Invalid type ({c.get('cap_type')!r}) — fix in Tab 2"
         df["Cap"] = pd.Series(caps)