fix(workflows): unwrap groups in the remediation parser too

Addressing review feedback. The evaluator now unwraps a parenthesised
group, but _unresolvable_term did not, so a grouped operand reached the
path check as literal text. A condition the evaluator resolves was
therefore reported unresolvable and format_condition_remediation
withheld the wrap correction from it:

  inputs.a or inputs.b                 -> Wrap the expression: ...
  (inputs.a or inputs.b) and inputs.c  -> No correction is offered
                                          because '(inputs.a or inputs.b)'
                                          is not a name ...

Mirror the unwrap branch, and cover grouped bare conditions both ways:
a valid group keeps the correction, and an unresolvable name inside a
group still refuses it.

Author: NgoQuocViet2001

src/specify_cli/workflows/expressions.py

@@ -1179,6 +1179,13 @@ def _unresolvable_term(text: str) -> str | None:
     if not stripped:
         return "an operand is empty"
 
+    # Mirror the evaluator's group unwrapping. Without this a grouped operand
+    # reached the path check as literal text, so `(inputs.a or inputs.b) and
+    # inputs.c` -- which the evaluator resolves -- was reported unresolvable and
+    # the wrap correction was withheld from a condition that would have worked.
+    if _is_wrapped_in_parens(stripped):
+        return _unresolvable_term(stripped[1:-1])
+
     if _find_top_level(stripped, "|") != -1:
         segments = _split_top_level(stripped, "|")
         reason = _unresolvable_term(segments[0])

tests/unit/test_condition_expression_block.py

@@ -804,6 +804,36 @@ def test_resolvable_filter_arguments_keep_the_correction(condition):
     assert _wrapped_evaluates(condition)
 
 
+@pytest.mark.parametrize(
+    "condition",
+    [
+        "(inputs.a or inputs.b) and inputs.c",
+        "(inputs.a)",
+        "((inputs.a))",
+        "(inputs.a) and (inputs.c)",
+    ],
+)
+def test_a_grouped_bare_condition_keeps_the_correction(condition):
+    """Remediation tracks the evaluator, which now unwraps a parenthesised group.
+
+    Before the evaluator learned to unwrap, a grouped operand reached the path
+    check as literal text, so a condition that wrapping would have fixed was
+    reported unresolvable and the correction was withheld.
+    """
+    ctx = StepContext(inputs={"a": True, "b": False, "c": True})
+    assert CORRECTION_OFFERED in format_condition_remediation(condition)
+    assert evaluate_condition("{{ " + condition + " }}", ctx) is True
+
+
+@pytest.mark.parametrize(
+    "condition",
+    ["(bogus or inputs.b) and inputs.c", "(inputs.a or bogus)"],
+)
+def test_an_unresolvable_name_inside_a_group_still_refuses(condition):
+    """The unwrap must not become a blanket pass for anything parenthesised."""
+    assert CORRECTION_OFFERED not in format_condition_remediation(condition)
+
+
 @pytest.mark.parametrize("condition", ["item[0] == 'x'", "item[1] == 'y'"])
 def test_an_indexed_item_root_keeps_the_correction(condition):
     """`item` is the only root that is not always a mapping.