@@ -651,7 +651,7 @@ Available filters: `default`, `join`, `contains`, `map`, `from_json`, `to_json`,
 
 Notes on the newer filters:
 
-- **Types are validated, not coerced.** `upper` and `lower` accept strings only, `split` requires both a string value and a non-empty string separator, and `length` accepts lists and strings but rejects mappings. Anything else raises a `ValueError` naming the problem. Coercion is deliberately not performed: a type mismatch nearly always means the workflow is wired to the wrong variable, and a coerced result would hide that. A filter given the wrong number of arguments (`| upper('x')`, `| split` with no separator, `| split(',', 1)`) is reported as a known filter misused, which is distinct from an entirely unknown filter name; arity is checked before the argument expression is evaluated, so the extra argument is what gets named. The older filters (`join`, `map`, `contains`) are more permissive and unchanged: `join` stringifies unsupported values and `map`/`contains` return fallbacks rather than raising.
+- **Types are validated, not coerced.** `upper` and `lower` accept strings only, `split` requires both a string value and a non-empty string separator, and `length` accepts lists and strings but rejects mappings. Anything else raises a `ValueError` naming the problem. Coercion is deliberately not performed: a type mismatch nearly always means the workflow is wired to the wrong variable, and a coerced result would hide that. A filter given the wrong number of arguments (`| upper('x')`, `| split` with no separator, `| split(',', 1)`) is reported as a known filter misused, which is distinct from an entirely unknown filter name: a call carrying more than one argument falls through to that same unsupported-form error rather than being evaluated as a single expression. The older filters (`join`, `map`, `contains`) are more permissive and unchanged: `join` stringifies unsupported values and `map`/`contains` return fallbacks rather than raising.
 - **`to_json` output is deterministic.** Object keys are sorted and non-ASCII characters are left as-is rather than escaped, so the same value always serializes to the same bytes. That buys reproducibility only — it does **not** make the result safe to pass through a shell, because [interpolation adds no quoting or escaping](#interpolation-and-shell-safety). Do not interpolate unconstrained JSON into a `run` field.
 - **`to_json` rejects non-finite floats.** `NaN`, `Infinity`, and `-Infinity` raise a `ValueError` naming `to_json` instead of serializing to bare tokens. None of the three is valid JSON, so emitting them would hand a standards-compliant downstream parser a string it must reject.
 - **`to_json` requires string mapping keys.** JSON objects have string keys, so a mapping with any other key type — `{1: "a"}`, `{True: "a"}` — raises a `ValueError` naming the key type instead. Left to `json.dumps`, an integer key would be coerced to `"1"` and collide with an existing `"1"` key, while mixed key types would fail `sort_keys` with an ordering `TypeError` reported only as "not JSON-serializable".
 
@@ -291,14 +291,6 @@ def _check_json_keys(value: Any) -> None:
     "to_json": _filter_to_json,
 }
 
-# Parenthesized filters that take exactly one argument. Used to report an
-# extra argument by name *before* the argument expression is evaluated:
-# _evaluate_simple_expression has no comma operator, so ``| split(',', 1)``
-# would otherwise hand split an unparseable fragment, which reads back as
-# "expected a string separator, got NoneType" -- the arity mistake, which is
-# what the author actually got wrong, never surfaces.
-_SINGLE_ARG_FILTERS = frozenset({"default", "join", "map", "contains", "split"})
-
 
 # -- Expression resolution ------------------------------------------------
 
@@ -682,15 +674,7 @@ def _apply_filter(value: Any, filter_expr: str, namespace: dict[str, Any]) -> An
         filter_match = None
     if filter_match:
         fname = filter_match.group(1)
-        farg_text = filter_match.group(2).strip()
-        if fname in _SINGLE_ARG_FILTERS:
-            arg_parts = _split_top_level_commas(farg_text)
-            if len(arg_parts) > 1:
-                raise ValueError(
-                    f"{fname}: expected exactly one argument, got "
-                    f"{len(arg_parts)}: '| {filter_expr}'"
-                )
-        farg = _evaluate_simple_expression(farg_text, namespace)
+        farg = _evaluate_simple_expression(filter_match.group(2).strip(), namespace)
         if fname == "default":
             return _filter_default(value, farg)
         if fname == "join":
 
@@ -853,29 +853,28 @@ def test_filter_to_json_rejects_non_string_keys(self):
             == '{"1": "a", "2": "b"}'
         )
 
-    def test_single_arg_filters_reject_extra_argument(self):
-        # Arity is checked before the argument expression is evaluated.
-        # split(',', 1) used to evaluate that fragment first, so the reported
-        # error was "expected a string separator, got NoneType" -- the arity
-        # mistake, which is what the author got wrong, stayed hidden behind a
-        # type error.
+    def test_split_with_extra_argument_reports_unsupported_form(self):
+        # split is new in this PR, so main's multi-argument guard has to cover
+        # it as well. Without that it evaluated the argument fragment first and
+        # reported "expected a string separator, got NoneType" -- the extra
+        # argument, which is what the author actually got wrong, never
+        # surfaced. main already pins default() and join() the same way; this
+        # pins the filter added here.
         import pytest
         from specify_cli.workflows.expressions import evaluate_expression
         from specify_cli.workflows.base import StepContext
 
-        ctx = StepContext(inputs={"s": "a,b,c", "n": 0})
+        ctx = StepContext(inputs={"s": "a,b,c"})
         with pytest.raises(
-            ValueError, match="split: expected exactly one argument, got 2"
+            ValueError, match="filter 'split' used in an unsupported form"
         ):
             evaluate_expression("{{ inputs.s | split(',', 1) }}", ctx)
-        with pytest.raises(
-            ValueError, match="default: expected exactly one argument, got 2"
-        ):
-            evaluate_expression("{{ inputs.n | default(0, 'x') }}", ctx)
-        # A comma inside quotes or brackets is still one argument.
-        assert (
-            evaluate_expression("{{ inputs.s | split(',') }}", ctx) == ["a", "b", "c"]
-        )
+        # A comma inside quotes is still a single argument.
+        assert evaluate_expression("{{ inputs.s | split(',') }}", ctx) == [
+            "a",
+            "b",
+            "c",
+        ]
 
     def test_zero_arg_filters_reject_miswired_forms(self):
         # The strict no-argument branch is shared by from_json/upper/lower/