From 0d74e8251b3e7be1ae467c92fc8f4ee2f5ec4c1a Mon Sep 17 00:00:00 2001
From: David Smith <davidsmith@hamiltonfour.tech>
Date: Thu, 15 Oct 2026 23:38:41 -0400
Subject: [PATCH 1/3] Validate container item types in probe inputs; parse
 signatures bracket-aware (#160)

validate_probe_input skipped every parameter whose hint was not a bare
primitive, so list[str] accepted integers and bare list accepted a
string. It now checks list/tuple/set[T] and dict[K, V] with primitive
item types (bool is not int, int is accepted for float), bare forms by
shape, and leaves nested and Any items unchecked as before. Hidden
signatures keep the generic message. dict keys are checked only when the
key type is str, because JSON object keys always arrive as strings.

parse_function_signature split the parameter list on every comma, so
dict[str, int] became two parameters. It now splits on top-level commas
only, honouring brackets and quotes, and both probeable handlers
delegate to it instead of carrying their own copy.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../handlers/probeable_code/handler.py        |  28 +-
 .../handlers/probeable_spec/handler.py        |  28 +-
 .../problems_app/services/probe_service.py    | 294 +++++++++++++++++-
 tests/unit/test_probe_input_containers.py     | 285 +++++++++++++++++
 tests/unit/test_probe_input_validation.py     |   4 +-
 5 files changed, 586 insertions(+), 53 deletions(-)
 create mode 100644 tests/unit/test_probe_input_containers.py

diff --git a/purplex/problems_app/handlers/probeable_code/handler.py b/purplex/problems_app/handlers/probeable_code/handler.py
index 47740c5..12f4e07 100644
--- a/purplex/problems_app/handlers/probeable_code/handler.py
+++ b/purplex/problems_app/handlers/probeable_code/handler.py
@@ -15,7 +15,6 @@
 """
 
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from .. import register_handler
@@ -34,22 +33,17 @@
 
 
 def _parse_function_params(signature: str) -> list[dict[str, str]]:
-    """Parse function signature to extract parameter names and types."""
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
-        return []
-    params_str = match.group(1).strip()
-    if not params_str:
-        return []
-    params = []
-    for param in params_str.split(","):
-        param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
-            params.append({"name": name.strip(), "type": type_hint.strip()})
-        else:
-            params.append({"name": param, "type": "Any"})
-    return params
+    """Parse function signature to extract parameter names and types.
+
+    Delegates to probe_service.parse_function_signature so the probe panel and
+    the probe validator agree on how parameters are split.
+    """
+    # Imported here: the services package imports the handler registry.
+    from purplex.problems_app.services.probe_service import (
+        parse_function_signature,
+    )
+
+    return parse_function_signature(signature)
 
 
 @register_handler("probeable_code")
diff --git a/purplex/problems_app/handlers/probeable_spec/handler.py b/purplex/problems_app/handlers/probeable_spec/handler.py
index fb6ae16..881b33f 100644
--- a/purplex/problems_app/handlers/probeable_spec/handler.py
+++ b/purplex/problems_app/handlers/probeable_spec/handler.py
@@ -16,7 +16,6 @@
 """
 
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from .. import register_handler
@@ -34,22 +33,17 @@
 
 
 def _parse_function_params(signature: str) -> list[dict[str, str]]:
-    """Parse function signature to extract parameter names and types."""
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
-        return []
-    params_str = match.group(1).strip()
-    if not params_str:
-        return []
-    params = []
-    for param in params_str.split(","):
-        param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
-            params.append({"name": name.strip(), "type": type_hint.strip()})
-        else:
-            params.append({"name": param, "type": "Any"})
-    return params
+    """Parse function signature to extract parameter names and types.
+
+    Delegates to probe_service.parse_function_signature so the probe panel and
+    the probe validator agree on how parameters are split.
+    """
+    # Imported here: the services package imports the handler registry.
+    from purplex.problems_app.services.probe_service import (
+        parse_function_signature,
+    )
+
+    return parse_function_signature(signature)
 
 
 @register_handler("probeable_spec")
diff --git a/purplex/problems_app/services/probe_service.py b/purplex/problems_app/services/probe_service.py
index f1ca709..5147ac9 100644
--- a/purplex/problems_app/services/probe_service.py
+++ b/purplex/problems_app/services/probe_service.py
@@ -9,7 +9,6 @@
 
 import json
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from django.conf import settings
@@ -468,33 +467,135 @@ def _build_cooldown_message(
             return f"No probes remaining. Submit {submissions_to_next} more times to unlock more probes."
 
 
+_OPENERS = {"(": ")", "[": "]", "{": "}"}
+_CLOSERS = frozenset(_OPENERS.values())
+
+
+def _split_top_level(text: str, sep: str = ",") -> list[str]:
+    """Split ``text`` on ``sep`` where it is not nested or quoted.
+
+    Brackets ``()``, ``[]`` and ``{}`` raise the nesting depth; single- and
+    double-quoted strings (with backslash escapes) are skipped. Unbalanced
+    input is tolerated: depth never drops below zero.
+
+    Args:
+        text: Text to split, such as a parameter list.
+        sep: Single-character separator.
+
+    Returns:
+        The pieces between top-level separators, unstripped.
+    """
+    parts: list[str] = []
+    depth = 0
+    quote: str | None = None
+    current: list[str] = []
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if quote:
+            current.append(ch)
+            if ch == "\\" and i + 1 < len(text):
+                current.append(text[i + 1])
+                i += 1
+            elif ch == quote:
+                quote = None
+        elif ch in ("'", '"'):
+            quote = ch
+            current.append(ch)
+        elif ch in _OPENERS:
+            depth += 1
+            current.append(ch)
+        elif ch in _CLOSERS:
+            depth = max(depth - 1, 0)
+            current.append(ch)
+        elif ch == sep and depth == 0:
+            parts.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+        i += 1
+    parts.append("".join(current))
+    return parts
+
+
+def _extract_params_str(signature: str) -> str | None:
+    """Return the text between the signature's outermost parentheses.
+
+    Scans from the first ``(`` to its matching ``)``, so parentheses inside
+    defaults (``x: tuple = (1, 2)``) do not end the parameter list early.
+
+    Args:
+        signature: Function signature like ``"f(x: int) -> bool"``.
+
+    Returns:
+        The parameter list text, or None when there is no ``(``.
+    """
+    open_idx = signature.find("(")
+    if open_idx == -1:
+        return None
+    depth = 0
+    quote: str | None = None
+    i = open_idx
+    while i < len(signature):
+        ch = signature[i]
+        if quote:
+            if ch == "\\":
+                i += 1
+            elif ch == quote:
+                quote = None
+        elif ch in ("'", '"'):
+            quote = ch
+        elif ch in _OPENERS:
+            depth += 1
+        elif ch in _CLOSERS:
+            depth -= 1
+            if depth == 0:
+                return signature[open_idx + 1 : i]
+        i += 1
+    # Unterminated: take everything after "(".
+    return signature[open_idx + 1 :]
+
+
 def parse_function_signature(signature: str) -> list[dict[str, str]]:
     """
     Parse function signature to extract parameter names and types.
 
+    Parameters are split on top-level commas only, so bracketed annotations
+    such as ``dict[str, int]`` or ``tuple[int, str]`` and bracketed defaults
+    stay one parameter (issue #160). The type keeps any default text
+    (``"int = 3"``); normalize_primitive_type and normalize_container_type
+    strip it.
+
     Args:
         signature: Function signature like "f(x: int, y: str) -> bool"
 
     Returns:
         List of dicts with 'name' and 'type' keys
     """
-    # Extract the part between parentheses
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
+    params_str = _extract_params_str(signature)
+    if params_str is None:
         return []
 
-    params_str = match.group(1).strip()
+    params_str = params_str.strip()
     if not params_str:
         return []
 
     params = []
-    for param in params_str.split(","):
+    for param in _split_top_level(params_str):
         param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
+        if not param:
+            continue  # trailing comma
+        # Typed only when the colon comes before any default, so an untyped
+        # default containing a colon (sep="a:b") stays one name (mirrors
+        # parseSignatureParams in probeArgs.ts)
+        colon = param.find(":")
+        equals = param.find("=")
+        if colon != -1 and (equals == -1 or colon < equals):
+            name, type_hint = param[:colon], param[colon + 1 :]
             params.append({"name": name.strip(), "type": type_hint.strip()})
         else:
-            params.append({"name": param, "type": "Any"})
+            name = param.split("=", 1)[0]
+            params.append({"name": name.strip(), "type": "Any"})
 
     return params
 
@@ -545,15 +646,167 @@ def _matches_primitive(value: Any, kind: str) -> bool:
     return True
 
 
+_CONTAINER_ALIASES: dict[str, str] = {
+    "list": "list",
+    "tuple": "tuple",
+    "set": "set",
+    "dict": "dict",
+}
+
+
+def _split_type_hint(type_hint: str | None) -> str | None:
+    """Drop a default from a type hint; None for missing or implicit Optional.
+
+    Args:
+        type_hint: Raw type hint such as ``"list[int] = []"``.
+
+    Returns:
+        The stripped annotation, or None when the hint is empty or the default
+        is ``None`` (an implicit ``Optional``, which is not checked).
+    """
+    if not type_hint:
+        return None
+    # "=" never appears inside an annotation, but may appear in a default
+    # string, so split at the first top-level "=" only.
+    base = _split_top_level(type_hint, "=")[0]
+    default = type_hint[len(base) + 1 :] if len(base) < len(type_hint) else ""
+    if default.strip() == "None":
+        return None
+    base = base.strip()
+    return base or None
+
+
+def normalize_container_type(type_hint: str | None) -> dict[str, Any] | None:
+    """Map a parameter type hint to a one-level container description.
+
+    Recognises ``list``, ``tuple``, ``set`` and ``dict`` (and the ``typing``
+    aliases ``List``, ``Tuple``, ``Set``, ``Dict``; case-insensitive), bare or
+    subscripted. Item, key and value kinds are canonical primitive kinds from
+    the alias table, or None when the argument is not a primitive (nested
+    containers, ``Any``, classes), in which case only the shape is checked.
+
+    ``tuple[T]`` and ``tuple[T, ...]`` are treated as homogeneous tuples of
+    ``T``. A fixed-shape tuple such as ``tuple[int, str]`` is checked as shape
+    only (no per-position checks).
+
+    ``Optional[...]``, ``X | None`` and a ``None`` default are not containers
+    here, so they stay unchecked.
+
+    Args:
+        type_hint: Raw type hint such as ``"list[int]"`` or ``"Dict[str, int]"``.
+
+    Returns:
+        None when the hint is not a checked container, otherwise
+        ``{"kind": "list"|"tuple"|"set", "item": kind|None}`` or
+        ``{"kind": "dict", "key": kind|None, "value": kind|None}``.
+    """
+    base = _split_type_hint(type_hint)
+    if base is None:
+        return None
+    if len(_split_top_level(base, "|")) > 1:
+        return None
+
+    bracket = base.find("[")
+    if bracket == -1:
+        head, args = base, None
+    else:
+        if not base.endswith("]"):
+            return None
+        head, args = base[:bracket], base[bracket + 1 : -1]
+
+    kind = _CONTAINER_ALIASES.get(head.strip().lower())
+    if kind is None:
+        return None
+
+    arg_list = [a.strip() for a in _split_top_level(args)] if args is not None else []
+
+    def _primitive(arg: str) -> str | None:
+        return _PRIMITIVE_ALIASES.get(arg.lower())
+
+    if kind == "dict":
+        if len(arg_list) == 2:
+            return {
+                "kind": "dict",
+                "key": _primitive(arg_list[0]),
+                "value": _primitive(arg_list[1]),
+            }
+        return {"kind": "dict", "key": None, "value": None}
+
+    item = None
+    if len(arg_list) == 1 or (
+        kind == "tuple" and len(arg_list) == 2 and arg_list[1] == "..."
+    ):
+        item = _primitive(arg_list[0])
+    return {"kind": kind, "item": item}
+
+
+def _matches_container(value: Any, spec: dict[str, Any]) -> bool:
+    """Check a JSON-decoded value against a normalize_container_type spec.
+
+    list, tuple and set values arrive as JSON arrays. Dict keys arrive as JSON
+    object keys, which are always strings, so keys are only checked against a
+    ``str`` key kind; other key kinds are not checkable on the wire.
+
+    Args:
+        value: The probe value.
+        spec: Output of normalize_container_type.
+
+    Returns:
+        True if the value has the container shape and every checked item,
+        key and value matches its primitive kind.
+    """
+    if spec["kind"] == "dict":
+        if not isinstance(value, dict):
+            return False
+        key_kind, value_kind = spec["key"], spec["value"]
+        if key_kind == "str" and not all(_matches_primitive(k, "str") for k in value):
+            return False
+        if value_kind and not all(
+            _matches_primitive(v, value_kind) for v in value.values()
+        ):
+            return False
+        return True
+
+    if not isinstance(value, list):
+        return False
+    item_kind = spec["item"]
+    if item_kind and not all(_matches_primitive(v, item_kind) for v in value):
+        return False
+    return True
+
+
+def _container_description(spec: dict[str, Any]) -> str:
+    """Describe a container spec for a revealed-type error message.
+
+    Args:
+        spec: Output of normalize_container_type.
+
+    Returns:
+        Text such as ``"a list of str"``, ``"a dict of str to int"`` or
+        ``"a list"`` when the item kinds are unchecked.
+    """
+    kind = spec["kind"]
+    if kind == "dict":
+        if spec["key"] and spec["value"]:
+            return f"a dict of {spec['key']} to {spec['value']}"
+        return "a dict"
+    if spec["item"]:
+        return f"a {kind} of {spec['item']}"
+    return f"a {kind}"
+
+
 def validate_probe_input(
     signature: str, probe_input: dict[str, Any], *, reveal_types: bool = True
 ) -> tuple[bool, str | None]:
     """
     Validate probe input against function signature.
 
-    Parameter names are checked first (missing, then unknown). Then each
-    parameter with a primitive type hint (int, float, bool, str and their
-    aliases) is checked against its value; other hints are not checked.
+    Parameter names are checked first (missing, then unknown). Then, in
+    signature order, each parameter with a primitive type hint (int, float,
+    bool, str and their aliases) is checked against its value, and each
+    one-level container hint (list/tuple/set/dict, see
+    normalize_container_type) is checked for shape and primitive items.
+    Other hints (Any, Optional, nested item types, classes) are not checked.
 
     Args:
         signature: The function signature
@@ -583,15 +836,22 @@ def validate_probe_input(
     if extra:
         return False, f"Unknown parameters: {', '.join(extra)}"
 
-    # Check primitive types in signature order
+    # Check primitive and container types in signature order
     for param in params:
-        kind = normalize_primitive_type(param["type"])
-        if kind is None:
-            continue
         name = param["name"]
-        if not _matches_primitive(probe_input[name], kind):
+        value = probe_input[name]
+        kind = normalize_primitive_type(param["type"])
+        if kind is not None:
+            if _matches_primitive(value, kind):
+                continue
             if not reveal_types:
                 return False, f"That value is not valid for parameter '{name}'"
             return False, f"Parameter '{name}' must be {_KIND_ARTICLES[kind]} {kind}"
+        spec = normalize_container_type(param["type"])
+        if spec is None or _matches_container(value, spec):
+            continue
+        if not reveal_types:
+            return False, f"That value is not valid for parameter '{name}'"
+        return False, f"Parameter '{name}' must be {_container_description(spec)}"
 
     return True, None
diff --git a/tests/unit/test_probe_input_containers.py b/tests/unit/test_probe_input_containers.py
new file mode 100644
index 0000000..bfd3740
--- /dev/null
+++ b/tests/unit/test_probe_input_containers.py
@@ -0,0 +1,285 @@
+"""Unit tests for container probe input validation and signature parsing.
+
+Covers bracket-aware ``parse_function_signature`` (issue #160) and the
+one-level container checks in ``validate_probe_input``: ``list[str]`` used to
+accept integers silently. No database access.
+
+Fixed-shape tuples such as ``tuple[int, str]`` are checked as shape only
+(must be a JSON array); per-position checks are deliberately not done.
+"""
+
+import pytest
+
+from purplex.problems_app.services.probe_service import (
+    normalize_container_type,
+    parse_function_signature,
+    validate_probe_input,
+)
+
+pytestmark = [pytest.mark.unit]
+
+HIDDEN = "That value is not valid for parameter '{}'"
+
+
+class TestSignatureParsing:
+    def test_dict_annotation_is_one_parameter(self):
+        assert parse_function_signature("def f(m: dict[str, int], k: str)") == [
+            {"name": "m", "type": "dict[str, int]"},
+            {"name": "k", "type": "str"},
+        ]
+
+    def test_tuple_annotation_is_one_parameter(self):
+        assert parse_function_signature("def f(p: tuple[int, str]) -> int") == [
+            {"name": "p", "type": "tuple[int, str]"}
+        ]
+
+    def test_bracketed_defaults(self):
+        sig = "def f(items: list[int] = [], pair: tuple = (1, 2), x: int = 5)"
+        assert parse_function_signature(sig) == [
+            {"name": "items", "type": "list[int] = []"},
+            {"name": "pair", "type": "tuple = (1, 2)"},
+            {"name": "x", "type": "int = 5"},
+        ]
+
+    def test_quoted_comma_in_default(self):
+        assert parse_function_signature('def f(sep: str = ",", n: int)') == [
+            {"name": "sep", "type": 'str = ","'},
+            {"name": "n", "type": "int"},
+        ]
+
+    def test_untyped_default_keeps_bare_name(self):
+        assert parse_function_signature("def f(x=5, y)") == [
+            {"name": "x", "type": "Any"},
+            {"name": "y", "type": "Any"},
+        ]
+
+    def test_untyped_default_with_colon_keeps_bare_name(self):
+        assert parse_function_signature('def f(sep="a:b", n: int)') == [
+            {"name": "sep", "type": "Any"},
+            {"name": "n", "type": "int"},
+        ]
+
+    def test_trailing_comma_and_empty(self):
+        assert parse_function_signature("def f(a: int,)") == [
+            {"name": "a", "type": "int"}
+        ]
+        assert parse_function_signature("def f()") == []
+        assert parse_function_signature("no parens") == []
+
+
+class TestNormalizeContainer:
+    @pytest.mark.parametrize(
+        ("hint", "expected"),
+        [
+            ("list[int]", {"kind": "list", "item": "int"}),
+            ("List[String]", {"kind": "list", "item": "str"}),
+            ("set[float]", {"kind": "set", "item": "float"}),
+            ("tuple[int]", {"kind": "tuple", "item": "int"}),
+            ("tuple[int, ...]", {"kind": "tuple", "item": "int"}),
+            ("tuple[int, str]", {"kind": "tuple", "item": None}),
+            ("list", {"kind": "list", "item": None}),
+            ("list[list[int]]", {"kind": "list", "item": None}),
+            ("list[Any]", {"kind": "list", "item": None}),
+            ("Dict[str, int]", {"kind": "dict", "key": "str", "value": "int"}),
+            ("dict", {"kind": "dict", "key": None, "value": None}),
+            ("list[int] = []", {"kind": "list", "item": "int"}),
+        ],
+    )
+    def test_containers(self, hint, expected):
+        assert normalize_container_type(hint) == expected
+
+    @pytest.mark.parametrize(
+        "hint",
+        [
+            None,
+            "",
+            "int",
+            "Any",
+            "Optional[list[int]]",
+            "list[int] | None",
+            "list[int] = None",
+            "MyClass[int]",
+        ],
+    )
+    def test_not_checked(self, hint):
+        assert normalize_container_type(hint) is None
+
+
+class TestListItems:
+    def test_list_int_accepts_ints(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, -2, 3]}) == (
+            True,
+            None,
+        )
+
+    def test_empty_list_accepted(self):
+        assert validate_probe_input("def f(x: list[str])", {"x": []}) == (True, None)
+
+    def test_list_int_rejects_string_item(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, "2"]}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_list_str_rejects_int_item(self):
+        """The maintainer's bug: list[str] silently accepted integers."""
+        ok, err = validate_probe_input(
+            "def schedule(tasks: list[str])", {"tasks": ["a", 2]}
+        )
+        assert ok is False
+        assert err == "Parameter 'tasks' must be a list of str"
+
+    def test_list_int_rejects_bool_item(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, True]}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_list_float_accepts_ints(self):
+        assert validate_probe_input("def f(x: list[float])", {"x": [1, 2.5]}) == (
+            True,
+            None,
+        )
+
+    @pytest.mark.parametrize("value", ["[1, 2]", 5, None, {"a": 1}])
+    def test_list_rejects_non_array(self, value):
+        assert validate_probe_input("def f(x: list[int])", {"x": value}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_typing_alias(self):
+        assert validate_probe_input("def f(x: List[str])", {"x": [1]}) == (
+            False,
+            "Parameter 'x' must be a list of str",
+        )
+
+
+class TestTupleAndSet:
+    def test_tuple_of_int(self):
+        assert validate_probe_input("def f(x: tuple[int, ...])", {"x": [1, 2]}) == (
+            True,
+            None,
+        )
+        assert validate_probe_input("def f(x: tuple[int])", {"x": ["a"]}) == (
+            False,
+            "Parameter 'x' must be a tuple of int",
+        )
+
+    def test_set_of_str(self):
+        assert validate_probe_input("def f(x: set[str])", {"x": ["a", 1]}) == (
+            False,
+            "Parameter 'x' must be a set of str",
+        )
+
+    def test_fixed_shape_tuple_is_shape_only(self):
+        sig = "def f(p: tuple[int, str], n: int)"
+        assert validate_probe_input(sig, {"p": [1, "a"], "n": 2}) == (True, None)
+        # Positions are not checked, only that the value is an array.
+        assert validate_probe_input(sig, {"p": ["a", 1], "n": 2}) == (True, None)
+        assert validate_probe_input(sig, {"p": "1,a", "n": 2}) == (
+            False,
+            "Parameter 'p' must be a tuple",
+        )
+
+
+class TestBareAndNested:
+    def test_bare_list_rejects_dict(self):
+        assert validate_probe_input("def f(x: list)", {"x": {"a": 1}}) == (
+            False,
+            "Parameter 'x' must be a list",
+        )
+
+    def test_bare_list_accepts_mixed_items(self):
+        assert validate_probe_input("def f(x: list)", {"x": [1, "a", None]}) == (
+            True,
+            None,
+        )
+
+    def test_bare_dict_rejects_list(self):
+        assert validate_probe_input("def f(x: dict)", {"x": [1]}) == (
+            False,
+            "Parameter 'x' must be a dict",
+        )
+
+    def test_nested_list_checked_for_shape_only(self):
+        sig = "def f(x: list[list[int]])"
+        assert validate_probe_input(sig, {"x": [["a"], [1]]}) == (True, None)
+        assert validate_probe_input(sig, {"x": [1, 2]}) == (True, None)
+        assert validate_probe_input(sig, {"x": "nope"}) == (
+            False,
+            "Parameter 'x' must be a list",
+        )
+
+
+class TestDict:
+    SIG = "def f(counts: dict[str, int], label: str)"
+
+    def test_accepts_matching(self):
+        assert validate_probe_input(
+            self.SIG, {"counts": {"a": 1, "b": 2}, "label": "x"}
+        ) == (True, None)
+
+    def test_rejects_bad_value(self):
+        assert validate_probe_input(self.SIG, {"counts": {"a": "1"}, "label": "x"}) == (
+            False,
+            "Parameter 'counts' must be a dict of str to int",
+        )
+
+    def test_rejects_non_object(self):
+        assert validate_probe_input(self.SIG, {"counts": [], "label": "x"}) == (
+            False,
+            "Parameter 'counts' must be a dict of str to int",
+        )
+
+    def test_non_str_keys_not_checkable_on_the_wire(self):
+        """JSON object keys are always strings, so int keys are not checked."""
+        sig = "def f(m: dict[int, str])"
+        assert validate_probe_input(sig, {"m": {"1": "a"}}) == (True, None)
+        assert validate_probe_input(sig, {"m": {"1": 2}}) == (
+            False,
+            "Parameter 'm' must be a dict of int to str",
+        )
+
+    def test_signature_order_first_mismatch(self):
+        assert validate_probe_input(
+            "def f(a: list[int], b: str)", {"b": 5, "a": ["x"]}
+        ) == (False, "Parameter 'a' must be a list of int")
+
+
+class TestHiddenAndDefaults:
+    @pytest.mark.parametrize(
+        ("hint", "bad_value"),
+        [
+            ("list[str]", [1]),
+            ("list", {"a": 1}),
+            ("dict[str, int]", {"a": "b"}),
+            ("tuple[int, str]", "x"),
+        ],
+    )
+    def test_hidden_message_is_generic(self, hint, bad_value):
+        ok, err = validate_probe_input(
+            f"def f(tasks: {hint})", {"tasks": bad_value}, reveal_types=False
+        )
+        assert ok is False
+        assert err == HIDDEN.format("tasks")
+        for word in ("list", "dict", "tuple", "int", "str"):
+            assert word not in err
+
+    def test_default_with_brackets_still_checked(self):
+        sig = "def f(items: list[int] = [], n: int = 0)"
+        assert validate_probe_input(sig, {"items": [1], "n": 2}) == (True, None)
+        assert validate_probe_input(sig, {"items": ["a"], "n": 2}) == (
+            False,
+            "Parameter 'items' must be a list of int",
+        )
+
+    def test_none_default_is_unchecked(self):
+        sig = "def f(items: list[int] = None)"
+        assert validate_probe_input(sig, {"items": None}) == (True, None)
+        assert validate_probe_input(sig, {"items": ["a"]}) == (True, None)
+
+    def test_name_checks_still_first(self):
+        assert validate_probe_input(
+            "def f(m: dict[str, int], k: str)", {"m": "bad"}
+        ) == (False, "Missing required parameters: k")
diff --git a/tests/unit/test_probe_input_validation.py b/tests/unit/test_probe_input_validation.py
index af2a740..4352dba 100644
--- a/tests/unit/test_probe_input_validation.py
+++ b/tests/unit/test_probe_input_validation.py
@@ -129,14 +129,14 @@ class TestUncheckedHints:
         [
             "def f(x)",
             "def f(x: Any)",
-            "def f(x: list[int])",
-            "def f(x: dict)",
             "def f(x: Optional[int])",
             "def f(x: MyClass)",
         ],
     )
     @pytest.mark.parametrize("value", ["abc", 5, None, [1, 2], {"k": 1}])
     def test_non_primitive_hints_skipped(self, signature, value):
+        # Container hints (list[int], dict, ...) are checked since the call
+        # line; see test_probe_input_containers.py.
         assert _valid(signature, {"x": value}) == (True, None)
 
     @pytest.mark.parametrize("hint", [None, "", "Any", "list[int]", "Optional[int]"])

From 11ce32fb69ca72dcff734beb9117c4b85d9e2db4 Mon Sep 17 00:00:00 2001
From: David Smith <davidsmith@hamiltonfour.tech>
Date: Thu, 15 Oct 2026 23:38:51 -0400
Subject: [PATCH 2/3] Probe panel: replace per-parameter boxes with a call line

The probe panel showed one 72px text box per parameter inside a rendered
call, which clipped lists and strings and wrapped badly past two
arguments. The function name and parentheses are now fixed text and the
student edits one inline, wrapping argument list between them, as Python
literals, positional or keyword: mystery([3, 1, 2]) or
greet("Ann", times=2). Tab on an empty line or the "Fill in argument
names" button drops in name= placeholders; Enter probes; paste is plain
text. The region is a role=textbox with aria-label, aria-placeholder,
aria-invalid and aria-describedby, and the closing parenthesis trails
the last character.

Parsing lives in probeArgs.ts and pythonLiteral.ts: a top-level comma
split that honours nesting and quotes, keyword/positional mapping with
line errors (unknown, duplicate, too many positional, positional after
keyword, empty argument), and a Python-literal reader (True/False/None,
single quotes, escapes, tuples, sets, trailing commas). Mapped values go
through the existing per-parameter parser, which now validates container
item types to match the backend, so list[str] given integers shows
"Every item must be str" and Probe stays disabled; a quoted str argument
is read as the Python literal, not kept with its quotes. The request
body is unchanged.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../activities/inputs/ProbeableCodeInput.vue  |  12 +-
 .../activities/inputs/ProbeableSpecInput.vue  |  12 +-
 .../activities/inputs/shared/ProbePanel.vue   | 364 ++++++++++---
 .../shared/__tests__/parseInputValue.test.ts  | 203 +++++++-
 .../shared/__tests__/probeArgsLine.test.ts    | 484 ++++++++++++++++++
 .../__tests__/probeBudgetGuards.test.ts       |  10 +-
 .../activities/inputs/shared/probeArgs.ts     | 393 ++++++++++++++
 .../activities/inputs/shared/pythonLiteral.ts | 266 ++++++++++
 .../activities/inputs/shared/useProbeState.ts | 181 ++-----
 .../client/src/i18n/locales/en/problems.json  |  20 +-
 .../client/src/i18n/locales/es/problems.json  |  20 +-
 11 files changed, 1739 insertions(+), 226 deletions(-)
 create mode 100644 purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts
 create mode 100644 purplex/client/src/components/activities/inputs/shared/probeArgs.ts
 create mode 100644 purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts

diff --git a/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue b/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
index bf01991..21ea9b6 100644
--- a/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
+++ b/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
@@ -19,7 +19,9 @@
       :probe-count-display="probeCountDisplay"
       :probe-status-text="probeStatusHint"
       :probe-params="parameters"
-      :probe-inputs="probeInputs"
+      :args-line="argsLine"
+      :args-template="argsTemplate"
+      :line-error="lineError"
       :can-probe="canProbe"
       :is-executing="probing"
       :has-valid-inputs="hasValidInputs"
@@ -31,7 +33,7 @@
       :format-function-call="formatFunctionCall"
       :format-output="formatOutput"
       @execute-probe="executeProbe"
-      @update-input="updateProbeInput"
+      @update-args="setArgsLine"
     />
 
     <!-- Divider between probe and editor -->
@@ -140,7 +142,7 @@ const {
   probing,
   probeError,
   probeHistory,
-  probeInputs,
+  argsLine,
   functionName,
   parameters,
   canProbe,
@@ -149,12 +151,14 @@ const {
   probeStatusClass,
   hasValidInputs,
   inputErrors,
+  lineError,
+  argsTemplate,
   isDuplicate,
   cachedResult,
   executeProbe,
   formatFunctionCall,
   formatOutput,
-  updateProbeInput,
+  setArgsLine,
 } = useProbeState(() => props.problem, { isSubmitting: () => props.disabled })
 
 const { t } = useI18n()
diff --git a/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue b/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
index b2503e3..b59e111 100644
--- a/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
+++ b/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
@@ -19,7 +19,9 @@
       :probe-count-display="probeCountDisplay"
       :probe-status-text="probeStatusHint"
       :probe-params="parameters"
-      :probe-inputs="probeInputs"
+      :args-line="argsLine"
+      :args-template="argsTemplate"
+      :line-error="lineError"
       :can-probe="canProbe"
       :is-executing="probing"
       :has-valid-inputs="hasValidInputs"
@@ -31,7 +33,7 @@
       :format-function-call="formatFunctionCall"
       :format-output="formatOutput"
       @execute-probe="executeProbe"
-      @update-input="updateProbeInput"
+      @update-args="setArgsLine"
     />
 
     <!-- NL Description Input -->
@@ -142,7 +144,7 @@ const {
   probing,
   probeError,
   probeHistory,
-  probeInputs,
+  argsLine,
   functionName,
   parameters,
   canProbe,
@@ -151,12 +153,14 @@ const {
   probeStatusClass,
   hasValidInputs,
   inputErrors,
+  lineError,
+  argsTemplate,
   isDuplicate,
   cachedResult,
   executeProbe,
   formatFunctionCall,
   formatOutput,
-  updateProbeInput,
+  setArgsLine,
 } = useProbeState(() => props.problem, { isSubmitting: () => props.disabled })
 
 const { t } = useI18n()
diff --git a/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue b/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
index 2687eaf..e67a4ee 100644
--- a/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
+++ b/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
@@ -3,36 +3,35 @@
     <div class="probe-input-wrapper">
       <div class="probe-row">
         <div class="probe-call">
-          <span class="fn-name">{{ functionName }}</span>
-          <span class="fn-paren">(</span>
-          <template
-            v-for="(param, i) in probeParams"
-            :key="param.name"
+          <!-- Call line: only the argument list between the parentheses is editable -->
+          <!-- Whitespace between these spans contains newlines, so Vue drops it -->
+          <div
+            class="call-shell"
+            :class="{ 'has-error': hasErrors, 'is-disabled': !editable }"
+            @click="focusArgs"
           >
+            <span class="fn-name">{{ functionName }}</span>
+            <span class="fn-paren">(</span>
             <span
-              v-if="i > 0"
-              class="fn-comma"
-            >, </span>
-            <span class="param-name">{{ param.name }}</span>
-            <span class="param-eq">=</span>
-            <input
-              :id="`probe-${param.name}`"
-              :value="probeInputs[param.name]"
-              type="text"
-              class="param-input"
-              :class="{ 'has-error': !!inputErrors[param.name] }"
-              :placeholder="param.type || $t('problems.probe.valuePlaceholderHint')"
-              :aria-label="param.type
-                ? $t('problems.probe.paramAriaLabel', { name: param.name, type: param.type })
-                : $t('problems.probe.paramAriaLabelNoType', { name: param.name })"
-              :aria-invalid="inputErrors[param.name] ? 'true' : undefined"
-              :aria-describedby="inputErrors[param.name] ? `probe-err-${param.name}` : undefined"
-              :disabled="!canProbe || isExecuting"
-              @input="$emit('update-input', param.name, ($event.target as HTMLInputElement).value)"
-              @keydown.enter="!isExecuting && canProbe && hasValidInputs && !isDuplicate && $emit('execute-probe')"
-            >
-          </template>
-          <span class="fn-paren">)</span>
+              id="probe-args"
+              ref="argsRef"
+              class="call-args"
+              :contenteditable="editable ? EDITABLE_MODE : 'false'"
+              role="textbox"
+              aria-multiline="false"
+              spellcheck="false"
+              :data-placeholder="argsPlaceholder"
+              :aria-placeholder="argsPlaceholder"
+              :aria-label="$t('problems.probe.argsAriaLabel', { name: functionName })"
+              :aria-disabled="editable ? undefined : 'true'"
+              :aria-invalid="hasErrors ? 'true' : undefined"
+              :aria-describedby="hasErrors ? 'probe-field-errors probe-args-help' : 'probe-args-help'"
+              @input="onArgsInput"
+              @keydown="onArgsKeydown"
+              @paste="onArgsPaste"
+            />
+            <span class="fn-paren">)</span>
+          </div>
           <span class="fn-arrow">→</span>
           <span
             class="fn-result"
@@ -57,11 +56,28 @@
         </button>
       </div>
 
-      <!-- Per-field type errors -->
+      <button
+        v-if="argsTemplate"
+        type="button"
+        class="fill-args-btn"
+        :disabled="!editable"
+        @click="fillArgs"
+      >
+        {{ $t('problems.probe.fillArgs') }}
+      </button>
+
+      <!-- Line-level and per-parameter errors -->
       <ul
+        id="probe-field-errors"
         class="probe-field-errors"
         aria-live="polite"
       >
+        <li
+          v-if="lineError"
+          id="probe-err-line"
+        >
+          {{ lineError }}
+        </li>
         <li
           v-for="(message, name) in inputErrors"
           :id="`probe-err-${name}`"
@@ -102,6 +118,14 @@
         </template>
       </button>
 
+      <!-- Keyboard instructions for the call line (visually hidden, via aria-describedby) -->
+      <div
+        id="probe-args-help"
+        class="sr-only"
+      >
+        {{ $t('problems.probe.argsHelp') }}
+      </div>
+
       <!-- Screen reader announcement (visually hidden) -->
       <div
         class="sr-only"
@@ -174,10 +198,11 @@
 </template>
 
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import type { ProbeHistoryEntry, ProbeParameter } from '../../types'
 import { useFocusTrap } from '@/composables/useFocusTrap'
+import { stableStringify } from './probeArgs'
 
 const { t } = useI18n()
 
@@ -187,7 +212,9 @@ interface Props {
   probeCountDisplay: string
   probeStatusText?: string
   probeParams: ProbeParameter[]
-  probeInputs: Record<string, string>
+  argsLine: string
+  argsTemplate: string
+  lineError: string | null
   canProbe: boolean
   isExecuting: boolean
   hasValidInputs: boolean
@@ -202,11 +229,175 @@ interface Props {
 
 const props = defineProps<Props>()
 
-defineEmits<{
+const emit = defineEmits<{
   (e: 'execute-probe'): void
-  (e: 'update-input', paramName: string, value: string): void
+  (e: 'update-args', text: string): void
 }>()
 
+/** 'plaintext-only' where supported; older browsers reject it and get plain 'true'. */
+function detectEditableMode(): 'plaintext-only' | 'true' {
+  try {
+    const probe = document.createElement('span')
+    probe.contentEditable = 'plaintext-only'
+    return probe.contentEditable === 'plaintext-only' ? 'plaintext-only' : 'true'
+  } catch {
+    return 'true'
+  }
+}
+
+const EDITABLE_MODE = detectEditableMode()
+
+const argsRef = ref<HTMLElement | null>(null)
+
+const editable = computed(() => props.canProbe && !props.isExecuting)
+const hasErrors = computed(() => !!props.lineError || Object.keys(props.inputErrors).length > 0)
+// Parameter names are not secret, so they show even when the signature is hidden
+// Types show only when the signature is visible: the backend sends '' otherwise
+const argsPlaceholder = computed(() =>
+  props.probeParams.map(p => (p.type ? `${p.name}: ${p.type}` : p.name)).join(', ')
+)
+
+// Keep the DOM in step when the line changes from outside (e.g. reset on a new
+// problem); while typing the two already match, so the caret is left alone.
+watch(
+  () => props.argsLine,
+  (line) => {
+    const el = argsRef.value
+    if (el && (el.textContent ?? '') !== line) {
+      el.textContent = line
+    }
+  },
+)
+
+// The line is not editable while a probe runs, which drops focus; give it back
+// afterwards so a keyboard user can keep probing with Enter. This watcher runs
+// before the DOM update, so focus is still on the line when a probe starts.
+let argsFocusedBeforeProbe = false
+watch(
+  () => props.isExecuting,
+  (executing) => {
+    if (executing) {
+      argsFocusedBeforeProbe = !!argsRef.value && document.activeElement === argsRef.value
+      return
+    }
+    if (!argsFocusedBeforeProbe) {
+      return
+    }
+    argsFocusedBeforeProbe = false
+    nextTick(() => {
+      const el = argsRef.value
+      if (el && editable.value) {
+        el.focus()
+        placeCaret(el, null)
+      }
+    })
+  },
+)
+
+onMounted(() => {
+  if (argsRef.value && props.argsLine) {
+    argsRef.value.textContent = props.argsLine
+  }
+})
+
+function emitArgs() {
+  const el = argsRef.value
+  if (!el) {
+    return
+  }
+  const text = el.textContent ?? ''
+  // A browser may leave a stray <br> once emptied; clear it so :empty shows the placeholder
+  if (text === '' && el.childNodes.length > 0) {
+    el.replaceChildren()
+  }
+  emit('update-args', text)
+}
+
+function onArgsInput() {
+  emitArgs()
+}
+
+function placeCaret(el: HTMLElement, offset: number | null) {
+  const selection = window.getSelection()
+  if (!selection) {
+    return
+  }
+  const range = document.createRange()
+  const textNode = el.firstChild
+  if (offset !== null && textNode?.nodeType === Node.TEXT_NODE) {
+    range.setStart(textNode, Math.min(offset, textNode.textContent?.length ?? 0))
+    range.collapse(true)
+  } else {
+    range.selectNodeContents(el)
+    range.collapse(false)
+  }
+  selection.removeAllRanges()
+  selection.addRange(range)
+}
+
+/** Insert `name=, name=, ...` with the caret after the first `=`. */
+function fillArgs() {
+  const el = argsRef.value
+  if (!el || !editable.value || !props.argsTemplate) {
+    return
+  }
+  el.textContent = props.argsTemplate
+  emitArgs()
+  el.focus()
+  placeCaret(el, props.argsTemplate.indexOf('=') + 1)
+}
+
+function focusArgs(event: MouseEvent) {
+  const el = argsRef.value
+  if (el && editable.value && event.target !== el) {
+    el.focus()
+    placeCaret(el, null)
+  }
+}
+
+function onArgsKeydown(event: KeyboardEvent) {
+  if (event.key === 'Enter') {
+    // One logical line: Enter probes, Shift+Enter does nothing
+    event.preventDefault()
+    if (!event.shiftKey && !props.isExecuting && props.canProbe && props.hasValidInputs && !props.isDuplicate) {
+      emit('execute-probe')
+    }
+    return
+  }
+  if (event.key === 'Tab' && !event.shiftKey && (argsRef.value?.textContent ?? '').trim() === '' && props.argsTemplate) {
+    event.preventDefault()
+    fillArgs()
+  }
+}
+
+/** Paste as plain text on one line, for browsers that ignore plaintext-only. */
+function onArgsPaste(event: ClipboardEvent) {
+  event.preventDefault()
+  const text = (event.clipboardData?.getData('text/plain') ?? '').replace(/\r?\n/g, ' ')
+  if (!text) {
+    return
+  }
+  // execCommand keeps the native undo stack; it is deprecated but still the only way to
+  // do that, so fall back to a Selection edit where it is unsupported
+  if (document.execCommand?.('insertText', false, text)) {
+    return
+  }
+  const selection = window.getSelection()
+  if (!selection || selection.rangeCount === 0) {
+    return
+  }
+  const range = selection.getRangeAt(0)
+  range.deleteContents()
+  const node = document.createTextNode(text)
+  range.insertNode(node)
+  range.setStartAfter(node)
+  range.collapse(true)
+  selection.removeAllRanges()
+  selection.addRange(range)
+  argsRef.value?.normalize()
+  emitArgs()
+}
+
 const showModal = ref(false)
 const showResultFlash = ref(false)
 
@@ -217,7 +408,7 @@ const { modalContentRef } = useFocusTrap(showModal)
 const uniqueHistory = computed(() => {
   const seen = new Set<string>()
   return props.probeHistory.filter(entry => {
-    const key = JSON.stringify(entry.input)
+    const key = stableStringify(entry.input)
     if (seen.has(key)) {return false}
     seen.add(key)
     return true
@@ -296,9 +487,11 @@ watch(() => props.probeHistory.length, () => {
   border-color: var(--color-primary-gradient-start);
 }
 
-/* Row containing probe-call and history button */
+/* Row containing probe-call and history button; wraps so a narrow screen
+   gives the call line the full width */
 .probe-row {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   justify-content: space-between;
   gap: var(--spacing-md);
@@ -312,7 +505,9 @@ watch(() => props.probeHistory.length, () => {
   font-size: var(--font-size-base);
   color: var(--color-text-primary);
   flex-wrap: wrap;
-  flex: 1;
+
+  /* A real basis (not 0) so the history button wraps below on narrow screens */
+  flex: 1 1 16rem;
   min-width: 0;
 }
 
@@ -348,60 +543,101 @@ watch(() => props.probeHistory.length, () => {
   font-weight: 600;
 }
 
-.fn-paren,
-.fn-comma {
-  color: var(--color-text-muted);
-}
-
-.param-name {
-  color: var(--color-text-secondary);
-}
-
-.param-eq {
+.fn-paren {
   color: var(--color-text-muted);
-  margin: 0 2px;
+  font-weight: 400;
 }
 
-.param-input {
-  width: 72px;
-  height: 28px;
-  padding: 0 var(--spacing-sm);
+/* Call line: inline flow, so the closing paren trails the last argument character */
+.call-shell {
+  flex: 1 1 16rem;
+  min-width: 0;
+  min-height: 32px;
+  padding: var(--spacing-xs) var(--spacing-sm);
   background: var(--color-bg-input);
   border: 1px solid var(--color-bg-border);
   border-radius: var(--radius-sm);
-  color: var(--color-text-primary);
-  font-family: var(--font-family-mono);
+  font-family: var(--font-family-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
   font-size: var(--font-size-sm);
-  text-align: center;
+  line-height: 1.6;
+  text-align: left;
+  overflow-wrap: anywhere;
+  cursor: text;
   transition: border-color 0.2s ease, box-shadow 0.2s ease;
 }
 
-.param-input::placeholder {
-  color: var(--color-text-muted);
-  opacity: 0.5;
-  font-size: var(--font-size-xs);
+.call-shell .fn-name,
+.call-shell .fn-paren {
+  user-select: none;
 }
 
-.param-input:focus {
-  outline: none;
+.call-shell:focus-within {
   border-color: var(--color-primary);
   box-shadow: 0 0 0 2px var(--color-primary-overlay);
 }
 
-.param-input.has-error {
-  border-color: var(--color-error);
+/* Forced-colors mode drops box-shadow and recolours borders: keep a visible focus ring */
+@media (forced-colors: active) {
+  .call-shell:focus-within {
+    outline: 2px solid CanvasText;
+    outline-offset: 2px;
+  }
 }
 
-.param-input.has-error:focus {
+.call-shell.has-error {
   border-color: var(--color-error);
+}
+
+.call-shell.has-error:focus-within {
   box-shadow: 0 0 0 2px var(--color-error-overlay);
 }
 
-.param-input:disabled {
+.call-shell.is-disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.call-args {
+  padding: 0 2px;
+  color: var(--color-text-primary);
+  white-space: pre-wrap;
+  outline: none;
+}
+
+.call-args:empty::before {
+  content: attr(data-placeholder);
+  color: var(--color-text-muted);
+  pointer-events: none;
+}
+
+.fill-args-btn {
+  display: block;
+  margin-top: var(--spacing-xs);
+  padding: 2px var(--spacing-sm);
+  background: var(--color-bg-hover);
+  border: 1px solid var(--color-bg-border);
+  border-radius: var(--radius-sm);
+  color: var(--color-text-secondary);
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+  transition: border-color 0.2s ease, color 0.2s ease;
+}
+
+.fill-args-btn:focus-visible {
+  outline: 2px solid var(--color-primary-gradient-start);
+  outline-offset: 2px;
+}
+
+.fill-args-btn:disabled {
   opacity: 0.5;
   cursor: not-allowed;
 }
 
+.fill-args-btn:hover:not(:disabled) {
+  border-color: var(--color-primary-gradient-start);
+  color: var(--color-text-primary);
+}
+
 .fn-arrow {
   color: var(--color-text-muted);
   margin: 0 var(--spacing-sm);
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
index 05c00ca..d7c038c 100644
--- a/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
@@ -2,7 +2,13 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import { nextTick } from 'vue'
 import { flushPromises } from '@vue/test-utils'
 import axios from 'axios'
-import { normalizePrimitiveType, parseInputValue, useProbeState } from '../useProbeState'
+import {
+  normalizeContainerType,
+  normalizePrimitiveType,
+  parseInputValue,
+  parseSignatureParams,
+} from '../probeArgs'
+import { useProbeState } from '../useProbeState'
 import type { ActivityProblem } from '../../../types'
 import { withSetup } from '@/test/setup'
 
@@ -28,7 +34,8 @@ const EXPECTED: Record<string, Record<(typeof INPUTS)[number], unknown>> = {
     '5': '5',
     abc: 'abc',
     '"abc"': 'abc',
-    "'abc'": "'abc'",
+    // A quoted str is a Python string literal, single or double quotes alike
+    "'abc'": 'abc',
     True: 'True',
     None: 'None',
     '1.5': '1.5',
@@ -58,7 +65,8 @@ const EXPECTED: Record<string, Record<(typeof INPUTS)[number], unknown>> = {
     '5': 5,
     abc: 'abc',
     '"abc"': 'abc',
-    "'abc'": "'abc'",
+    // Untyped values are Python literals, so single quotes delimit a string
+    "'abc'": 'abc',
     True: true,
     None: null,
     '1.5': 1.5,
@@ -145,19 +153,180 @@ describe('parseInputValue', () => {
     expect(parseInputValue('', 'str')).toEqual({ value: '', error: null })
   })
 
-  it('keeps malformed quoted strings as raw text', () => {
-    expect(parseInputValue('"a" + "b"', 'str')).toEqual({ value: '"a" + "b"', error: null })
+  it('rejects quoted str text that is not one string literal', () => {
+    for (const text of ['"a" + "b"', '"abc', "'abc", `'it's'`, '"x" 1']) {
+      expect(parseInputValue(text, 'str')).toEqual({ value: text, error: 'literal' })
+    }
+  })
+
+  it('unquotes single- and double-quoted str literals, escapes included', () => {
+    expect(parseInputValue("'x'", 'str')).toEqual({ value: 'x', error: null })
+    expect(parseInputValue(`"it's"`, 'str')).toEqual({ value: "it's", error: null })
+    expect(parseInputValue(`'a\\'b'`, 'str')).toEqual({ value: "a'b", error: null })
+    expect(parseInputValue("''", 'str')).toEqual({ value: '', error: null })
+    // Unquoted text is still taken as typed, quotes inside included
+    expect(parseInputValue(`it's`, 'str')).toEqual({ value: "it's", error: null })
   })
 
-  it('does not check unknown or compound types', () => {
-    for (const type of ['Any', 'list', 'list[int]', 'Optional[int]', 'dict', 'MyClass']) {
+  it('decodes Python octal and \\U escapes, and rejects \\N{...}', () => {
+    expect(parseInputValue(`"\\012"`, 'str')).toEqual({ value: '\n', error: null })
+    expect(parseInputValue(`"\\0"`, 'str')).toEqual({ value: '\0', error: null })
+    expect(parseInputValue(`"\\1019"`, 'str')).toEqual({ value: 'A9', error: null })
+    expect(parseInputValue(`"\\U0001F600"`, 'str')).toEqual({ value: '\u{1F600}', error: null })
+    expect(parseInputValue(`["\\x41\\u0042"]`, 'list[str]')).toEqual({ value: ['AB'], error: null })
+    expect(parseInputValue(`["\\N{EM DASH}"]`, 'list[str]').error).toBe('list')
+    expect(parseInputValue(`["\\U00110000"]`, 'list[str]').error).toBe('list')
+  })
+
+  it('does not check unknown types, Optionals or unions', () => {
+    for (const type of ['Any', 'Optional[int]', 'Optional[list[int]]', 'list[int] | None', 'list[int] = None', 'MyClass']) {
       expect(normalizePrimitiveType(type)).toBeNull()
+      expect(normalizeContainerType(type)).toBeNull()
       expect(parseInputValue('abc', type)).toEqual({ value: 'abc', error: null })
     }
     expect(parseInputValue('False', 'Any')).toEqual({ value: false, error: null })
   })
 })
 
+describe('parseInputValue container types', () => {
+  it('rejects integers in a list[str] (the item type is checked)', () => {
+    expect(parseInputValue('[1, 2]', 'list[str]')).toEqual({
+      value: '[1, 2]',
+      error: 'listItems',
+      errorParams: { kind: 'str' },
+    })
+    expect(parseInputValue('["a", 2]', 'list[str]').error).toBe('listItems')
+    expect(parseInputValue(`['a', "b"]`, 'list[str]')).toEqual({ value: ['a', 'b'], error: null })
+  })
+
+  it('does not accept a bool or a float literal as an int item', () => {
+    expect(parseInputValue('[1, True]', 'list[int]').error).toBe('listItems')
+    expect(parseInputValue('[1, 2.0]', 'list[int]').error).toBe('listItems')
+    expect(parseInputValue('[1, -2, +3]', 'list[int]')).toEqual({ value: [1, -2, 3], error: null })
+  })
+
+  it('accepts int items for float, as the backend does', () => {
+    expect(parseInputValue('[1, 2.5, .5]', 'list[float]')).toEqual({ value: [1, 2.5, 0.5], error: null })
+    expect(parseInputValue('[True]', 'list[float]').error).toBe('listItems')
+  })
+
+  it('accepts Python literals: tuples, trailing commas, True/False/None', () => {
+    expect(parseInputValue('(1, 2)', 'list[int]')).toEqual({ value: [1, 2], error: null })
+    expect(parseInputValue('[1, 2,]', 'list[int]')).toEqual({ value: [1, 2], error: null })
+    expect(parseInputValue('(5,)', 'tuple[int, ...]')).toEqual({ value: [5], error: null })
+    expect(parseInputValue('{3, 1}', 'set[int]')).toEqual({ value: [3, 1], error: null })
+    expect(parseInputValue('[True, False]', 'List[bool]')).toEqual({ value: [true, false], error: null })
+    expect(parseInputValue('[None, "x", 1]', 'list')).toEqual({ value: [null, 'x', 1], error: null })
+  })
+
+  it('requires a list shape for list, tuple and set types', () => {
+    for (const type of ['list', 'list[int]', 'tuple', 'set[str]', 'tuple[int, str]']) {
+      expect(parseInputValue('abc', type).error).toBe('list')
+      expect(parseInputValue('{"a": 1}', type).error).toBe('list')
+      expect(parseInputValue('[1, 2', type).error).toBe('list')
+      expect(parseInputValue('5', type).error).toBe('list')
+    }
+  })
+
+  it('checks dict keys and values', () => {
+    expect(parseInputValue(`{'a': 1, "b": 2,}`, 'dict[str, int]')).toEqual({ value: { a: 1, b: 2 }, error: null })
+    expect(parseInputValue(`{'a': 'x'}`, 'Dict[str, int]')).toEqual({
+      value: `{'a': 'x'}`,
+      error: 'dictItems',
+      errorParams: { key: 'str', value: 'int' },
+    })
+    expect(parseInputValue('{1: 2}', 'dict[str, int]').error).toBe('dictItems')
+    expect(parseInputValue('{1: "a"}', 'dict[int, str]')).toEqual({ value: { 1: 'a' }, error: null })
+    expect(parseInputValue('{}', 'dict[str, int]')).toEqual({ value: {}, error: null })
+  })
+
+  it('requires a dict shape for dict types', () => {
+    for (const type of ['dict', 'dict[str, int]']) {
+      expect(parseInputValue('[1]', type).error).toBe('dict')
+      expect(parseInputValue('abc', type).error).toBe('dict')
+      expect(parseInputValue('{1, 2}', type).error).toBe('dict')
+    }
+    expect(parseInputValue(`{'a': [1, 'x']}`, 'dict')).toEqual({ value: { a: [1, 'x'] }, error: null })
+  })
+
+  it('checks only the outer shape of nested containers', () => {
+    expect(parseInputValue('[[1], ["a"]]', 'list[list[int]]')).toEqual({ value: [[1], ['a']], error: null })
+    expect(parseInputValue('[1]', 'dict[str, list[int]]').error).toBe('dict')
+    expect(parseInputValue(`{'a': 'x'}`, 'dict[str, list[int]]')).toEqual({ value: { a: 'x' }, error: null })
+  })
+
+  it('refuses ints too large for JSON inside a container', () => {
+    expect(parseInputValue('[12345678901234567891]', 'list[int]').error).toBe('intRange')
+  })
+
+  it('keeps a "__proto__" key as plain data', () => {
+    const { value } = parseInputValue('{"__proto__": 1}', 'dict[str, int]')
+    expect(Object.keys(value as object)).toEqual(['__proto__'])
+    expect(Object.getPrototypeOf(value)).toBe(Object.prototype)
+  })
+})
+
+describe('parseInputValue untyped literals', () => {
+  it('rejects text that starts like a literal but does not parse', () => {
+    for (const raw of ['[1, 2', '(1, 2', '{"a": 1', '"abc', "'abc", '[1 2]', '[1,, 2]']) {
+      expect(parseInputValue(raw, '')).toEqual({ value: raw, error: 'literal' })
+    }
+  })
+
+  it('parses Python literals and keeps other text as a string', () => {
+    expect(parseInputValue('[True, None, \'x\']', 'Any')).toEqual({ value: [true, null, 'x'], error: null })
+    expect(parseInputValue('(1,)', '')).toEqual({ value: [1], error: null })
+    expect(parseInputValue('(1)', '')).toEqual({ value: 1, error: null })
+    expect(parseInputValue(`'it\\'s'`, '')).toEqual({ value: "it's", error: null })
+    expect(parseInputValue('"tab\\there"', '')).toEqual({ value: 'tab\there', error: null })
+    expect(parseInputValue('hello world', '')).toEqual({ value: 'hello world', error: null })
+    expect(parseInputValue('0x10', '')).toEqual({ value: '0x10', error: null })
+  })
+})
+
+describe('normalizeContainerType', () => {
+  it('recognises one-level containers and their primitive items', () => {
+    expect(normalizeContainerType('list[str]')).toEqual({ container: 'list', item: 'str' })
+    expect(normalizeContainerType('Tuple[Integer, ...]')).toEqual({ container: 'list', item: 'int' })
+    expect(normalizeContainerType('tuple[int, str]')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('set')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('list[Any] = []')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('dict[str, int]')).toMatchObject({ container: 'dict', key: 'str', value: 'int' })
+    expect(normalizeContainerType('dict')).toMatchObject({ container: 'dict', key: null, value: null })
+  })
+
+  it('returns null for non-containers', () => {
+    for (const type of ['int', 'str', 'Any', 'listing', 'Optional[list[int]]', 'dict[str, int] | None']) {
+      expect(normalizeContainerType(type)).toBeNull()
+    }
+  })
+})
+
+describe('parseSignatureParams', () => {
+  it('keeps bracketed types and defaults as one parameter (#160)', () => {
+    expect(
+      parseSignatureParams(
+        `def schedule(tasks: list[str], weights: dict[str, int], pair: tuple[int, str] = (1, "a,b"), opts={'k': 1}) -> int`
+      )
+    ).toEqual([
+      { name: 'tasks', type: 'list[str]' },
+      { name: 'weights', type: 'dict[str, int]' },
+      { name: 'pair', type: 'tuple[int, str] = (1, "a,b")' },
+      { name: 'opts', type: 'Any' },
+    ])
+  })
+
+  it('handles empty and trailing-comma parameter lists', () => {
+    expect(parseSignatureParams('def f() -> int')).toEqual([])
+    expect(parseSignatureParams('def f(x: int,) -> int')).toEqual([{ name: 'x', type: 'int' }])
+    expect(parseSignatureParams('no parens')).toEqual([])
+    expect(parseSignatureParams(`def f(open: str = '(', x: int) -> int`)).toEqual([
+      { name: 'open', type: "str = '('" },
+      { name: 'x', type: 'int' },
+    ])
+  })
+})
+
 describe('normalizePrimitiveType', () => {
   it('maps the alias table to canonical types', () => {
     expect(normalizePrimitiveType('int')).toBe('int')
@@ -195,12 +364,12 @@ describe('useProbeState input validation', () => {
   it('flags a non-integer value for an int parameter and clears once fixed', async () => {
     const state = setup('def f(x: int) -> int')
 
-    state.updateProbeInput('x', 'abc')
+    state.setArgsLine('abc')
     await nextTick()
     expect(state.hasValidInputs.value).toBe(false)
     expect(state.inputErrors.value.x).toBe('Must be a whole number (e.g. 5)')
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await nextTick()
     expect(state.hasValidInputs.value).toBe(true)
     expect(state.inputErrors.value).toEqual({})
@@ -220,17 +389,29 @@ describe('useProbeState input validation', () => {
     ])
   })
 
+  it('translates container errors with their expected kinds', () => {
+    const state = setup('def f(tasks: list[str], weights: dict[str, int]) -> int')
+    state.setArgsLine('[1, 2], [1]')
+    expect(state.inputErrors.value).toEqual({
+      tasks: 'Every item must be str',
+      weights: 'Must be a dict, e.g. {"a": 1}',
+    })
+    state.setArgsLine(`[1, 2], {'a': 'b'}`)
+    expect(state.inputErrors.value.weights).toBe('Keys must be str and values int')
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
   it('posts only type-valid, parsed inputs', async () => {
     vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 10 } })
     const state = setup('def f(x: int) -> int')
     await flushPromises()
     expect(state.canProbe.value).toBe(true)
 
-    state.updateProbeInput('x', 'abc')
+    state.setArgsLine('abc')
     await state.executeProbe()
     expect(axios.post).not.toHaveBeenCalled()
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await state.executeProbe()
     expect(axios.post).toHaveBeenCalledWith('/api/problems/typed-probe/probe/', { input: { x: 5 } })
   })
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts
new file mode 100644
index 0000000..d9e3c2b
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts
@@ -0,0 +1,484 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import axios from 'axios'
+import { parseArgsLine, splitTopLevel, stableStringify } from '../probeArgs'
+import { useProbeState } from '../useProbeState'
+import ProbePanel from '../ProbePanel.vue'
+import type { ActivityProblem } from '../../../types'
+import { withSetup } from '@/test/setup'
+
+vi.mock('axios')
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+const PARAMS = ['tasks', 'start', 'label']
+
+describe('splitTopLevel', () => {
+  it('ignores commas nested in brackets or inside strings', () => {
+    expect(splitTopLevel(`[1, 2], (3, 4), {'a': 1, 'b': 2}, "x, y", 'p\\', q'`)).toEqual([
+      '[1, 2]',
+      ' (3, 4)',
+      ` {'a': 1, 'b': 2}`,
+      ' "x, y"',
+      ` 'p\\', q'`,
+    ])
+  })
+})
+
+describe('stableStringify', () => {
+  it('ignores object key order at every level but keeps list order', () => {
+    expect(stableStringify({ b: 2, a: { d: 1, c: [2, 1] } })).toBe(stableStringify({ a: { c: [2, 1], d: 1 }, b: 2 }))
+    expect(stableStringify([1, 2])).not.toBe(stableStringify([2, 1]))
+  })
+})
+
+describe('parseArgsLine', () => {
+  it('maps positional arguments in signature order', () => {
+    expect(parseArgsLine('["a", "b"], 9, "ci"', PARAMS)).toEqual({
+      raw: { tasks: '["a", "b"]', start: '9', label: '"ci"' },
+      lineError: null,
+    })
+  })
+
+  it('maps keyword arguments by name, in any order', () => {
+    expect(parseArgsLine('label="ci", tasks=[1, 2], start = 9', PARAMS)).toEqual({
+      raw: { tasks: '[1, 2]', start: '9', label: '"ci"' },
+      lineError: null,
+    })
+  })
+
+  it('mixes positional and keyword arguments, keyword first included', () => {
+    expect(parseArgsLine('[1], label="x", 3', PARAMS).raw).toEqual({ tasks: '[1]', start: '3', label: '"x"' })
+    expect(parseArgsLine('label="x", [1], 3', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '3', label: '"x"' },
+      lineError: null,
+    })
+  })
+
+  it('keeps commas inside brackets and strings within one argument', () => {
+    expect(parseArgsLine(`{'a': 1, 'b': 2}, (1, 2), "x, y=3"`, PARAMS).raw).toEqual({
+      tasks: `{'a': 1, 'b': 2}`,
+      start: '(1, 2)',
+      label: '"x, y=3"',
+    })
+  })
+
+  it('does not treat == or a string containing = as a keyword', () => {
+    expect(parseArgsLine('x == 1, "a=b"', PARAMS).raw).toEqual({ tasks: 'x == 1', start: '"a=b"', label: '' })
+  })
+
+  it('allows a trailing comma', () => {
+    expect(parseArgsLine('[1], 2, "z",', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '2', label: '"z"' },
+      lineError: null,
+    })
+  })
+
+  it('reports an unknown keyword', () => {
+    expect(parseArgsLine('[1], stop=3', PARAMS).lineError).toEqual({ code: 'unknownKeyword', name: 'stop' })
+  })
+
+  it('reports an argument given twice, by keyword or by position', () => {
+    expect(parseArgsLine('start=1, start=2', PARAMS).lineError).toEqual({ code: 'duplicateArgument', name: 'start' })
+    expect(parseArgsLine('1, tasks=[2]', PARAMS).lineError).toEqual({ code: 'duplicateArgument', name: 'tasks' })
+  })
+
+  it('reports a positional argument whose slot a keyword already took', () => {
+    expect(parseArgsLine('tasks=[1], [2]', PARAMS).lineError).toEqual({
+      code: 'positionalAfterKeyword',
+      name: 'tasks',
+    })
+    expect(parseArgsLine('x=1, 2', ['x', 'y']).lineError).toEqual({ code: 'positionalAfterKeyword', name: 'x' })
+    // A keyword for a later parameter leaves the earlier slots to positionals
+    expect(parseArgsLine('label="c", [1], 2', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '2', label: '"c"' },
+      lineError: null,
+    })
+  })
+
+  it('accepts non-ASCII parameter names as keywords', () => {
+    expect(parseArgsLine('número=1', ['número'])).toEqual({ raw: { número: '1' }, lineError: null })
+    expect(parseArgsLine('café = 2', ['x', 'café']).raw).toEqual({ x: '', café: '2' })
+  })
+
+  it('reports too many positional arguments', () => {
+    expect(parseArgsLine('1, 2, 3, 4', PARAMS)).toEqual({
+      raw: { tasks: '1', start: '2', label: '3' },
+      lineError: { code: 'tooManyPositional', name: '' },
+    })
+  })
+
+  it('reports an empty argument between commas without using a slot', () => {
+    expect(parseArgsLine('1,,2', PARAMS)).toEqual({
+      raw: { tasks: '1', start: '2', label: '' },
+      lineError: { code: 'emptyArgument', name: '' },
+    })
+    expect(parseArgsLine('1, ,2', ['x', 'y']).lineError).toEqual({ code: 'emptyArgument', name: '' })
+    expect(parseArgsLine(',1', ['x']).lineError).toEqual({ code: 'emptyArgument', name: '' })
+  })
+
+  it('maps empty text to empty values with no error', () => {
+    for (const text of ['', '   ']) {
+      expect(parseArgsLine(text, PARAMS)).toEqual({
+        raw: { tasks: '', start: '', label: '' },
+        lineError: null,
+      })
+    }
+  })
+
+  it('leaves the values of the template empty', () => {
+    expect(parseArgsLine('tasks=, start=, label=', PARAMS)).toEqual({
+      raw: { tasks: '', start: '', label: '' },
+      lineError: null,
+    })
+  })
+})
+
+describe('useProbeState call line', () => {
+  function setup(signature: string) {
+    vi.mocked(axios.get).mockResolvedValue({ data: { can_probe: true, mode: 'explore' } })
+    const problem = {
+      slug: 'line-probe',
+      function_name: 'schedule',
+      probe_config: { function_signature: signature, function_name: 'schedule' },
+    } as unknown as ActivityProblem
+    return withSetup(() => useProbeState(problem))
+  }
+
+  it('builds the keyword template from the parameters', () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    expect(state.argsTemplate.value).toBe('tasks=, start=')
+  })
+
+  it('posts the parsed values of a valid line', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+
+    state.setArgsLine(`['a', "b"], start=9`)
+    await nextTick()
+    expect(state.argsLine.value).toBe(`['a', "b"], start=9`)
+    expect(state.probeInputs).toEqual({ tasks: `['a', "b"]`, start: '9' })
+    expect(state.hasValidInputs.value).toBe(true)
+
+    await state.executeProbe()
+    expect(axios.post).toHaveBeenCalledWith('/api/problems/line-probe/probe/', {
+      input: { tasks: ['a', 'b'], start: 9 },
+    })
+  })
+
+  it('posts a single-quoted str argument without its quotes', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: ['xa'] } })
+    const state = setup('def schedule(tasks: list[str], prefix: str) -> list[str]')
+    await flushPromises()
+    state.setArgsLine(`['a'], 'x'`)
+    expect(state.hasValidInputs.value).toBe(true)
+    await state.executeProbe()
+    expect(axios.post).toHaveBeenCalledWith('/api/problems/line-probe/probe/', {
+      input: { tasks: ['a'], prefix: 'x' },
+    })
+  })
+
+  it('blocks an unterminated str literal with a per-parameter error', async () => {
+    const state = setup('def schedule(tasks: list[str], prefix: str) -> list[str]')
+    await flushPromises()
+    state.setArgsLine(`['a'], "abc`)
+    expect(state.inputErrors.value).toEqual({ prefix: 'Not a valid Python value' })
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
+  it('blocks a list[str] given integers, with a per-parameter error', async () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+    state.setArgsLine('[1, 2], 9')
+    expect(state.inputErrors.value).toEqual({ tasks: 'Every item must be str' })
+    expect(state.hasValidInputs.value).toBe(false)
+    await state.executeProbe()
+    expect(axios.post).not.toHaveBeenCalled()
+  })
+
+  it('translates line errors and blocks the probe while one is present', async () => {
+    const state = setup('def schedule(start: int) -> int')
+    await flushPromises()
+
+    state.setArgsLine('5, stop=3')
+    expect(state.lineError.value).toBe('Unknown argument stop')
+    expect(state.hasValidInputs.value).toBe(false)
+
+    state.setArgsLine('5, start=3')
+    expect(state.lineError.value).toBe('Argument start given twice')
+
+    state.setArgsLine('5, 6')
+    expect(state.lineError.value).toBe('Too many arguments for schedule')
+    expect(state.probeInputs.start).toBe('5')
+    await state.executeProbe()
+    expect(axios.post).not.toHaveBeenCalled()
+
+    state.setArgsLine('5,,')
+    expect(state.lineError.value).toBe('Empty argument between commas')
+
+    state.setArgsLine('5')
+    expect(state.lineError.value).toBeNull()
+    expect(state.hasValidInputs.value).toBe(true)
+  })
+
+  it('requires every parameter to have a value', () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    state.setArgsLine('tasks=["a"]')
+    expect(state.probeInputs.start).toBe('')
+    expect(state.lineError.value).toBeNull()
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
+  it('treats a matching probe as a duplicate regardless of argument style', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+    state.setArgsLine('["a"], 9')
+    await state.executeProbe()
+    state.setArgsLine(`start=9, tasks=['a']`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(true)
+  })
+
+  it('treats a dict with its keys in another order as a duplicate', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def total(m: dict[str, int]) -> int')
+    await flushPromises()
+    state.setArgsLine(`{'a': 1, 'b': 2}`)
+    await state.executeProbe()
+    state.setArgsLine(`{'b': 2, 'a': 1}`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(true)
+    state.setArgsLine(`{'b': 2, 'a': 3}`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(false)
+  })
+})
+
+function mountPanel(overrides: Record<string, unknown> = {}) {
+  return mount(ProbePanel, {
+    attachTo: document.body,
+    props: {
+      functionName: 'schedule',
+      probeStatusClass: 'status-available',
+      probeCountDisplay: '2 left',
+      probeStatusText: '',
+      probeParams: [
+        { name: 'tasks', type: 'list[str]' },
+        { name: 'start', type: 'int' },
+      ],
+      argsLine: '',
+      argsTemplate: 'tasks=, start=',
+      lineError: null,
+      canProbe: true,
+      isExecuting: false,
+      hasValidInputs: false,
+      inputErrors: {},
+      probeHistory: [],
+      probeError: null,
+      isDuplicate: false,
+      cachedResult: null,
+      formatFunctionCall: (input: Record<string, unknown>) => `schedule(${Object.values(input).join(', ')})`,
+      formatOutput: (output: unknown) => JSON.stringify(output),
+      ...overrides,
+    },
+  })
+}
+
+describe('ProbePanel call line', () => {
+  it('renders the function name and parentheses around one accessible argument editor', () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    expect(wrapper.find('.call-shell').text().replace(/\s/g, '')).toBe('schedule()')
+    expect(args.attributes('role')).toBe('textbox')
+    // Enter probes rather than breaking the line, so it is single-line to AT
+    expect(args.attributes('aria-multiline')).toBe('false')
+    // The keyboard behaviour (Enter probes, Tab fills names) is described to AT
+    expect(args.attributes('aria-describedby')).toBe('probe-args-help')
+    expect(wrapper.find('#probe-args-help').text()).toBe(
+      'Enter probes. Tab on an empty line fills in the argument names.'
+    )
+    expect(args.attributes('aria-label')).toBe('Arguments for schedule')
+    // Signature visible: the placeholder carries each parameter's declared type
+    expect(args.attributes('data-placeholder')).toBe('tasks: list[str], start: int')
+    expect(args.attributes('contenteditable')).toBe('plaintext-only')
+    expect(args.attributes('aria-invalid')).toBeUndefined()
+    // ")" follows the editor directly, with no whitespace text between them
+    expect(args.element.nextSibling).toBe(wrapper.findAll('.fn-paren')[1].element)
+    wrapper.unmount()
+  })
+
+  it('shows parameter names in the placeholder even when types are hidden', () => {
+    const wrapper = mountPanel({ probeParams: [{ name: 'a', type: '' }, { name: 'b', type: '' }] })
+    expect(wrapper.find('#probe-args').attributes('data-placeholder')).toBe('a, b')
+    wrapper.unmount()
+  })
+
+  it('emits the typed text', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    args.element.textContent = '[1], 2'
+    await args.trigger('input')
+    expect(wrapper.emitted('update-args')).toEqual([['[1], 2']])
+    wrapper.unmount()
+  })
+
+  it('inserts the template on Tab only when the line is empty', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    await args.trigger('keydown', { key: 'Tab' })
+    expect(args.element.textContent).toBe('tasks=, start=')
+    expect(wrapper.emitted('update-args')).toEqual([['tasks=, start=']])
+    // Caret sits after the first "="
+    const range = window.getSelection()?.getRangeAt(0)
+    expect(range?.startOffset).toBe('tasks='.length)
+
+    await args.trigger('keydown', { key: 'Tab' })
+    expect(wrapper.emitted('update-args')).toHaveLength(1)
+    wrapper.unmount()
+  })
+
+  it('inserts the template from the fill button', async () => {
+    const wrapper = mountPanel()
+    await wrapper.find('button.fill-args-btn').trigger('click')
+    expect(wrapper.find('#probe-args').element.textContent).toBe('tasks=, start=')
+    expect(wrapper.emitted('update-args')).toEqual([['tasks=, start=']])
+    wrapper.unmount()
+  })
+
+  it('probes on Enter only when valid, and never on Shift+Enter', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toBeUndefined()
+
+    await wrapper.setProps({ hasValidInputs: true })
+    await args.trigger('keydown', { key: 'Enter', shiftKey: true })
+    expect(wrapper.emitted('execute-probe')).toBeUndefined()
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toHaveLength(1)
+
+    await wrapper.setProps({ isExecuting: true })
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toHaveLength(1)
+    wrapper.unmount()
+  })
+
+  it('gives focus back to the line after a probe started from it', async () => {
+    const wrapper = mountPanel({ hasValidInputs: true })
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    el.focus()
+    await wrapper.setProps({ isExecuting: true })
+    // A browser drops focus from an element that stops being editable
+    el.blur()
+    expect(document.activeElement).not.toBe(el)
+    await wrapper.setProps({ isExecuting: false })
+    await nextTick()
+    expect(document.activeElement).toBe(el)
+    wrapper.unmount()
+  })
+
+  it('does not steal focus after a probe started from elsewhere', async () => {
+    const wrapper = mountPanel({ hasValidInputs: true })
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    await wrapper.setProps({ isExecuting: true })
+    await wrapper.setProps({ isExecuting: false })
+    await nextTick()
+    expect(document.activeElement).not.toBe(el)
+    wrapper.unmount()
+  })
+
+  it('pastes plain text on one line', () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    const el = args.element as HTMLElement
+    el.focus()
+    const range = document.createRange()
+    range.selectNodeContents(el)
+    window.getSelection()?.removeAllRanges()
+    window.getSelection()?.addRange(range)
+
+    const event = new Event('paste', { bubbles: true, cancelable: true }) as ClipboardEvent
+    Object.defineProperty(event, 'clipboardData', { value: { getData: () => '[1,\n2]' } })
+    el.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(true)
+    expect(el.textContent).toBe('[1, 2]')
+    expect(wrapper.emitted('update-args')?.slice(-1)).toEqual([['[1, 2]']])
+    wrapper.unmount()
+  })
+
+  it('shows line and per-parameter errors and marks the editor invalid', () => {
+    const wrapper = mountPanel({
+      lineError: 'Unknown argument stop',
+      inputErrors: { tasks: 'Every item must be str' },
+    })
+    expect(wrapper.find('li#probe-err-line').text()).toBe('Unknown argument stop')
+    expect(wrapper.find('li#probe-err-tasks').text()).toBe('tasks: Every item must be str')
+    const args = wrapper.find('#probe-args')
+    expect(args.attributes('aria-invalid')).toBe('true')
+    expect(args.attributes('aria-describedby')).toBe('probe-field-errors probe-args-help')
+    expect(wrapper.find('ul#probe-field-errors').exists()).toBe(true)
+    wrapper.unmount()
+  })
+
+  it('locks the editor and the fill button when probing is not allowed', () => {
+    const wrapper = mountPanel({ canProbe: false })
+    const args = wrapper.find('#probe-args')
+    expect(args.attributes('contenteditable')).toBe('false')
+    expect(args.attributes('aria-disabled')).toBe('true')
+    expect(wrapper.find('button.fill-args-btn').attributes('disabled')).toBeDefined()
+    wrapper.unmount()
+  })
+
+  it('follows a reset of the line from outside', async () => {
+    const wrapper = mountPanel({ argsLine: '[1], 2' })
+    const args = wrapper.find('#probe-args')
+    expect(args.element.textContent).toBe('[1], 2')
+    await wrapper.setProps({ argsLine: '' })
+    expect(args.element.textContent).toBe('')
+    wrapper.unmount()
+  })
+
+  it('falls back to contenteditable="true" and still pastes plain text where plaintext-only is unsupported', () => {
+    // A browser without plaintext-only keeps its previous contentEditable value
+    const descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'contentEditable')
+    Object.defineProperty(HTMLElement.prototype, 'contentEditable', {
+      configurable: true,
+      get: () => 'inherit',
+      set: () => {},
+    })
+    let wrapper: ReturnType<typeof mountPanel> | undefined
+    try {
+      wrapper = mountPanel()
+    } finally {
+      if (descriptor) {
+        Object.defineProperty(HTMLElement.prototype, 'contentEditable', descriptor)
+      } else {
+        delete (HTMLElement.prototype as { contentEditable?: string }).contentEditable
+      }
+    }
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    expect(el.getAttribute('contenteditable')).toBe('true')
+
+    el.focus()
+    const range = document.createRange()
+    range.selectNodeContents(el)
+    window.getSelection()?.removeAllRanges()
+    window.getSelection()?.addRange(range)
+    const event = new Event('paste', { bubbles: true, cancelable: true }) as ClipboardEvent
+    Object.defineProperty(event, 'clipboardData', { value: { getData: () => '<b>[1,</b>\r\n2]' } })
+    el.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(true)
+    // Inserted as text: markup stays literal, line breaks become spaces
+    expect(el.children).toHaveLength(0)
+    expect(el.textContent).toBe('<b>[1,</b> 2]')
+    expect(wrapper.emitted('update-args')?.slice(-1)).toEqual([['<b>[1,</b> 2]']])
+    wrapper.unmount()
+  })
+})
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
index 1f11487..1295ef6 100644
--- a/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
@@ -25,7 +25,7 @@ describe('useProbeState budget guards', () => {
     const state = withSetup(() => useProbeState(problem))
     await flushPromises()
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await state.executeProbe()
     expect(axios.post).toHaveBeenCalledTimes(1)
 
@@ -66,7 +66,9 @@ function mountPanel(overrides: Record<string, unknown>) {
       probeCountDisplay: '2 left',
       probeStatusText: '',
       probeParams: [{ name: 'x', type: 'int' }],
-      probeInputs: { x: '5' },
+      argsLine: '5',
+      argsTemplate: 'x=',
+      lineError: null,
       canProbe: true,
       isExecuting: false,
       hasValidInputs: true,
@@ -85,11 +87,11 @@ function mountPanel(overrides: Record<string, unknown>) {
 describe('ProbePanel duplicate and exhausted states', () => {
   it('does not emit a probe when Enter is pressed on a duplicate input', async () => {
     const wrapper = mountPanel({})
-    await wrapper.find('#probe-x').trigger('keydown', { key: 'Enter' })
+    await wrapper.find('#probe-args').trigger('keydown', { key: 'Enter' })
     expect(wrapper.emitted('execute-probe')).toBeUndefined()
 
     await wrapper.setProps({ isDuplicate: false, cachedResult: null })
-    await wrapper.find('#probe-x').trigger('keydown', { key: 'Enter' })
+    await wrapper.find('#probe-args').trigger('keydown', { key: 'Enter' })
     expect(wrapper.emitted('execute-probe')).toHaveLength(1)
   })
 
diff --git a/purplex/client/src/components/activities/inputs/shared/probeArgs.ts b/purplex/client/src/components/activities/inputs/shared/probeArgs.ts
new file mode 100644
index 0000000..03a0fe1
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/probeArgs.ts
@@ -0,0 +1,393 @@
+/**
+ * probeArgs - Parsing for the probe call line.
+ *
+ * Splits the argument list on top-level commas, maps positional and keyword
+ * arguments onto the signature's parameters, and parses each value as a
+ * Python literal checked against its declared type. Pure functions, no Vue.
+ */
+import type { ProbeParameter } from '../../types'
+import { hasUnsafeInt, parsePythonLiteral, type PyNode, toValue } from './pythonLiteral'
+
+/** Canonical primitive parameter types that probe inputs are validated against. */
+export type PrimitiveType = 'int' | 'float' | 'bool' | 'str'
+
+/** Error code for a probe input that does not match its declared type. */
+export type ProbeInputError =
+  | 'int'
+  | 'intRange'
+  | 'float'
+  | 'bool'
+  | 'list'
+  | 'listItems'
+  | 'dict'
+  | 'dictItems'
+  | 'literal'
+
+export interface ParsedProbeInput {
+  value: unknown
+  error: ProbeInputError | null
+  /** Interpolation values for the error message (e.g. the expected item kind). */
+  errorParams?: Record<string, string>
+}
+
+/** A declared one-level container type: list/tuple/set[T] or dict[K, V]. */
+export type ContainerType =
+  | { container: 'list'; item: PrimitiveType | null }
+  | {
+      container: 'dict'
+      key: PrimitiveType | null
+      value: PrimitiveType | null
+      keyLabel: string
+      valueLabel: string
+    }
+
+// Must stay identical to _PRIMITIVE_ALIASES in
+// purplex/problems_app/services/probe_service.py (issue #135).
+const PRIMITIVE_ALIASES = new Map<string, PrimitiveType>([
+  ['int', 'int'],
+  ['integer', 'int'],
+  ['float', 'float'],
+  ['number', 'float'],
+  ['bool', 'bool'],
+  ['boolean', 'bool'],
+  ['str', 'str'],
+  ['string', 'str'],
+])
+
+const INT_PATTERN = /^[+-]?\d+$/
+const BOOL_PATTERN = /^(true|false)$/i
+// Python float literal syntax: no hex/binary/octal, which Number() would otherwise accept
+const FLOAT_PATTERN = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/
+
+const OPENERS: Record<string, string> = { '(': ')', '[': ']', '{': '}' }
+const CLOSERS = new Set([')', ']', '}'])
+
+/**
+ * Split text on a separator (default a comma) that is not nested in (), [], {}
+ * or inside a quoted string. Mirrors _split_top_level in probe_service.py.
+ *
+ * Parts are returned untrimmed; a backslash escapes the next character inside
+ * quotes, and an unbalanced closer never takes the depth below zero.
+ */
+export function splitTopLevel(text: string, sep = ','): string[] {
+  const parts: string[] = []
+  let depth = 0
+  let quote: string | null = null
+  let current = ''
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    current += ch
+    if (quote) {
+      if (ch === '\\' && i + 1 < text.length) {
+        current += text[++i]
+      } else if (ch === quote) {
+        quote = null
+      }
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch in OPENERS) {
+      depth++
+    } else if (CLOSERS.has(ch)) {
+      depth = Math.max(depth - 1, 0)
+    } else if (ch === sep && depth === 0) {
+      parts.push(current.slice(0, -1))
+      current = ''
+    }
+  }
+  parts.push(current)
+  return parts
+}
+
+/** Strip a trailing `= default` from a type hint; null when the default is None (implicit Optional). */
+function stripTypeDefault(type: string): string | null {
+  const [base, ...defaultParts] = type.split('=')
+  if (defaultParts.join('=').trim() === 'None') {
+    return null
+  }
+  return base.trim()
+}
+
+/**
+ * Map a declared parameter type hint to its canonical primitive type.
+ *
+ * Strips a trailing ` = default`, trims, lowercases, and resolves aliases.
+ * A `= None` default is an implicit Optional and is not checked.
+ * Returns null for anything that is not a primitive (missing hint, Any,
+ * list[int], Optional[int], dict, custom classes, ...).
+ */
+export function normalizePrimitiveType(type: string | null | undefined): PrimitiveType | null {
+  if (!type) {
+    return null
+  }
+  const base = stripTypeDefault(type)
+  return base === null ? null : PRIMITIVE_ALIASES.get(base.toLowerCase()) ?? null
+}
+
+/**
+ * Map a declared parameter type hint to a one-level container type.
+ *
+ * Recognises list/tuple/set (bare, [T] or tuple[T, ...]) and dict (bare or [K, V]),
+ * case-insensitively. Item types that are not primitives (Any, nested containers,
+ * heterogeneous tuples) are left unchecked; only the container shape is checked.
+ * Returns null for everything else, including Optional[...], unions and `= None`
+ * defaults. Mirrors normalize_container_type in probe_service.py.
+ */
+export function normalizeContainerType(type: string | null | undefined): ContainerType | null {
+  if (!type) {
+    return null
+  }
+  const base = stripTypeDefault(type)
+  // Unions such as `list[int] | None` are not checked
+  if (base === null || splitTopLevel(base, '|').length > 1) {
+    return null
+  }
+  const match = base.match(/^(list|tuple|set|dict)\s*(?:\[([\s\S]*)\])?$/i)
+  if (!match) {
+    return null
+  }
+  const kind = match[1].toLowerCase()
+  const args = match[2] === undefined ? [] : splitTopLevel(match[2]).map(a => a.trim())
+  if (kind === 'dict') {
+    const [keyLabel = 'Any', valueLabel = 'Any'] = args.length === 2 ? args : []
+    return {
+      container: 'dict',
+      key: args.length === 2 ? normalizePrimitiveType(keyLabel) : null,
+      value: args.length === 2 ? normalizePrimitiveType(valueLabel) : null,
+      keyLabel,
+      valueLabel,
+    }
+  }
+  const homogeneous = args.length === 1 || (kind === 'tuple' && args.length === 2 && args[1] === '...')
+  return { container: 'list', item: homogeneous ? normalizePrimitiveType(args[0]) : null }
+}
+
+/**
+ * JSON with object keys sorted at every level. Python dicts are unordered, so two
+ * probe inputs that differ only in key order are the same call. Lists keep order.
+ */
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(value, (_key, v: unknown) =>
+    v !== null && typeof v === 'object' && !Array.isArray(v)
+      ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+      : v
+  )
+}
+
+/** Mirrors _matches_primitive: bool is not an int, an int is accepted for float. */
+function matchesPrimitive(node: PyNode, kind: PrimitiveType): boolean {
+  switch (kind) {
+    case 'int':
+      return node.k === 'int'
+    case 'float':
+      return node.k === 'int' || node.k === 'float'
+    case 'bool':
+      return node.k === 'bool'
+    case 'str':
+      return node.k === 'str'
+  }
+}
+
+function parseContainer(text: string, spec: ContainerType): ParsedProbeInput {
+  const node = parsePythonLiteral(text)
+  if (spec.container === 'dict') {
+    if (node?.k !== 'dict') {
+      return { value: text, error: 'dict' }
+    }
+    if (hasUnsafeInt(node)) {
+      return { value: text, error: 'intRange' }
+    }
+    const { key, value } = spec
+    const itemsMatch = node.entries.every(
+      ([k, v]) => (!key || matchesPrimitive(k, key)) && (!value || matchesPrimitive(v, value))
+    )
+    return itemsMatch
+      ? { value: toValue(node), error: null }
+      : { value: text, error: 'dictItems', errorParams: { key: spec.keyLabel, value: spec.valueLabel } }
+  }
+  if (node?.k !== 'list') {
+    return { value: text, error: 'list' }
+  }
+  if (hasUnsafeInt(node)) {
+    return { value: text, error: 'intRange' }
+  }
+  const { item } = spec
+  return !item || node.items.every(n => matchesPrimitive(n, item))
+    ? { value: toValue(node), error: null }
+    : { value: text, error: 'listItems', errorParams: { kind: item } }
+}
+
+/**
+ * Parse a raw probe input string according to its declared parameter type.
+ *
+ * Primitive types (int/float/bool/str) are validated strictly; a str is either a
+ * quoted Python string literal or, unquoted, the bare text as typed.
+ * One-level containers (list/tuple/set[T], dict[K, V]) must be Python literals of
+ * that shape whose items match T (or K and V). Unknown or missing types accept any
+ * Python literal and fall back to the raw text, unless the text starts like a
+ * literal (a bracket or a quote) and does not parse as one.
+ */
+export function parseInputValue(rawValue: string, type: string | null | undefined): ParsedProbeInput {
+  const text = rawValue.trim()
+
+  switch (normalizePrimitiveType(type)) {
+    case 'int':
+      if (!INT_PATTERN.test(text)) {
+        return { value: text, error: 'int' }
+      }
+      // JSON cannot carry ints above 2^53 losslessly, so refuse rather than corrupt
+      return Number.isSafeInteger(Number(text))
+        ? { value: Number(text), error: null }
+        : { value: text, error: 'intRange' }
+    case 'float': {
+      const num = Number(text)
+      return FLOAT_PATTERN.test(text) && Number.isFinite(num)
+        ? { value: num, error: null }
+        : { value: text, error: 'float' }
+    }
+    case 'bool':
+      return BOOL_PATTERN.test(text)
+        ? { value: text.toLowerCase() === 'true', error: null }
+        : { value: text, error: 'bool' }
+    case 'str': {
+      // A quoted value is a Python string literal ('x' or "x"); bare text stays as typed
+      if (!/^["']/.test(text)) {
+        return { value: text, error: null }
+      }
+      const node = parsePythonLiteral(text)
+      return node?.k === 'str' ? { value: node.v, error: null } : { value: text, error: 'literal' }
+    }
+    default: {
+      const container = normalizeContainerType(type)
+      if (container) {
+        return parseContainer(text, container)
+      }
+      // Untyped / unchecked: any Python literal, else the raw text
+      const node = parsePythonLiteral(text)
+      if (node) {
+        return hasUnsafeInt(node) ? { value: text, error: 'intRange' } : { value: toValue(node), error: null }
+      }
+      return /^[[({"']/.test(text) ? { value: text, error: 'literal' } : { value: text, error: null }
+    }
+  }
+}
+
+/** Line-level problem in the argument list, independent of any one parameter's value. */
+export interface ArgsLineError {
+  code: 'unknownKeyword' | 'duplicateArgument' | 'positionalAfterKeyword' | 'tooManyPositional' | 'emptyArgument'
+  /**
+   * The offending argument name ('' for tooManyPositional and emptyArgument); for
+   * positionalAfterKeyword, the keyword that already took the positional's slot.
+   */
+  name: string
+}
+
+const KEYWORD_ARG = /^([\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*)\s*=(?!=)([\s\S]*)$/u
+
+/**
+ * Map a call's argument list text (Python-style, positional or keyword) to raw
+ * per-parameter strings.
+ *
+ * Positional arguments fill parameters in signature order; `name=value` sets that
+ * parameter. A trailing comma is allowed. Every parameter appears in `raw`, with ''
+ * when not given. The first line-level error is reported.
+ */
+export function parseArgsLine(
+  text: string,
+  paramNames: string[]
+): { raw: Record<string, string>; lineError: ArgsLineError | null } {
+  const raw: Record<string, string> = Object.fromEntries(paramNames.map(name => [name, '']))
+  const parts = splitTopLevel(text).map(part => part.trim())
+  if (parts[parts.length - 1] === '') {
+    parts.pop()
+  }
+
+  const given = new Set<string>()
+  let lineError: ArgsLineError | null = null
+  let position = 0
+  for (const part of parts) {
+    if (part === '') {
+      // `1,,2` is a syntax error in Python; it must not consume a positional slot
+      lineError ??= { code: 'emptyArgument', name: '' }
+      continue
+    }
+    const keyword = part.match(KEYWORD_ARG)
+    let name: string
+    let value: string
+    if (keyword) {
+      name = keyword[1]
+      value = keyword[2].trim()
+      if (!paramNames.includes(name)) {
+        lineError ??= { code: 'unknownKeyword', name }
+        continue
+      }
+    } else {
+      if (position >= paramNames.length) {
+        lineError ??= { code: 'tooManyPositional', name: '' }
+        continue
+      }
+      name = paramNames[position++]
+      value = part
+      if (given.has(name)) {
+        // Only a keyword can have taken a positional slot already: `x=1, 2`
+        lineError ??= { code: 'positionalAfterKeyword', name }
+        continue
+      }
+    }
+    if (given.has(name)) {
+      lineError ??= { code: 'duplicateArgument', name }
+      continue
+    }
+    given.add(name)
+    raw[name] = value
+  }
+  return { raw, lineError }
+}
+
+/**
+ * Parameters of a `def name(...)` signature, splitting only on top-level commas so
+ * `dict[str, int]` or a `(1, 2)` default stays one parameter (issue #160).
+ *
+ * The default stays on the type (e.g. "int = None") so normalizePrimitiveType can
+ * see it; it is stripped from the name for untyped defaults like "x=3".
+ */
+export function parseSignatureParams(signature: string): ProbeParameter[] {
+  const open = signature.indexOf('(')
+  if (open === -1) {
+    return []
+  }
+  // Find the matching close paren, skipping nested brackets and quoted defaults
+  // (mirrors _extract_params_str in probe_service.py)
+  let depth = 0
+  let quote: string | null = null
+  let close = -1
+  for (let i = open; i < signature.length && close === -1; i++) {
+    const ch = signature[i]
+    if (quote) {
+      if (ch === '\\') {
+        i++
+      } else if (ch === quote) {
+        quote = null
+      }
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch in OPENERS) {
+      depth++
+    } else if (CLOSERS.has(ch) && --depth === 0) {
+      close = i
+    }
+  }
+  const inner = signature.slice(open + 1, close === -1 ? undefined : close)
+  return splitTopLevel(inner)
+    .map(part => part.trim())
+    .filter(part => part !== '')
+    .map(part => {
+      const colon = part.indexOf(':')
+      const equals = part.indexOf('=')
+      if (colon === -1 || (equals !== -1 && equals < colon)) {
+        return { name: part.split('=')[0].trim(), type: 'Any' }
+      }
+      return { name: part.slice(0, colon).trim(), type: part.slice(colon + 1).trim() || 'Any' }
+    })
+}
diff --git a/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts b/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts
new file mode 100644
index 0000000..0783c15
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts
@@ -0,0 +1,266 @@
+/**
+ * pythonLiteral - Parse a Python literal (or JSON) typed in the probe call line.
+ *
+ * Keeps int vs float apart so probeArgs can check container item types, and
+ * converts the result to the JSON value the probe API receives. Pure functions.
+ */
+
+/** A parsed Python literal, keeping int vs float so item types can be checked. */
+export type PyNode =
+  | { k: 'int'; v: number }
+  | { k: 'float'; v: number }
+  | { k: 'str'; v: string }
+  | { k: 'bool'; v: boolean }
+  | { k: 'none' }
+  | { k: 'list'; items: PyNode[] }
+  | { k: 'dict'; entries: [PyNode, PyNode][] }
+
+const NAME_LITERALS: Record<string, PyNode> = {
+  True: { k: 'bool', v: true },
+  False: { k: 'bool', v: false },
+  None: { k: 'none' },
+  // JSON spellings, accepted as before
+  true: { k: 'bool', v: true },
+  false: { k: 'bool', v: false },
+  null: { k: 'none' },
+}
+
+const STRING_ESCAPES: Record<string, string> = {
+  n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', a: '\x07', '\\': '\\', "'": "'", '"': '"', '/': '/',
+}
+
+const OCTAL_ESCAPE = /[0-7]{1,3}/y
+
+const NUMBER_TOKEN = /[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/y
+// Python identifiers are Unicode (PEP 3131), so `número` is a valid name
+const NAME_TOKEN = /[\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*/uy
+
+/**
+ * Parse a Python literal (or JSON): numbers, quoted strings, True/False/None,
+ * lists, tuples and sets (all become lists), and dicts with scalar keys.
+ * Trailing commas are accepted. Returns null when the text is not a literal.
+ */
+export function parsePythonLiteral(text: string): PyNode | null {
+  let pos = 0
+
+  const skipSpace = () => {
+    while (pos < text.length && /\s/.test(text[pos])) {
+      pos++
+    }
+  }
+
+  const parseString = (): PyNode | null => {
+    const quote = text[pos++]
+    let out = ''
+    while (pos < text.length) {
+      const ch = text[pos++]
+      if (ch === quote) {
+        return { k: 'str', v: out }
+      }
+      if (ch !== '\\') {
+        out += ch
+        continue
+      }
+      const esc = text[pos++]
+      if (esc === undefined) {
+        return null
+      }
+      if (esc === 'N') {
+        // \N{NAME} needs Python's Unicode name table; reject rather than mis-decode
+        return null
+      }
+      if (/[0-7]/.test(esc)) {
+        // \0 .. \377: one to three octal digits, as in Python
+        OCTAL_ESCAPE.lastIndex = pos - 1
+        const octal = OCTAL_ESCAPE.exec(text)?.[0] ?? esc
+        out += String.fromCharCode(parseInt(octal, 8))
+        pos += octal.length - 1
+        continue
+      }
+      const hexLength = esc === 'U' ? 8 : esc === 'u' ? 4 : esc === 'x' ? 2 : 0
+      if (hexLength) {
+        const hex = text.slice(pos, pos + hexLength)
+        if (!new RegExp(`^[0-9a-fA-F]{${hexLength}}$`).test(hex)) {
+          return null
+        }
+        const code = parseInt(hex, 16)
+        if (code > 0x10ffff) {
+          return null
+        }
+        out += String.fromCodePoint(code)
+        pos += hexLength
+      } else {
+        // Python keeps unknown escapes verbatim
+        out += STRING_ESCAPES[esc] ?? `\\${esc}`
+      }
+    }
+    return null
+  }
+
+  // Items up to `close`, separated by commas, trailing comma allowed
+  const parseItems = (close: string, first: PyNode[] = []): { items: PyNode[]; sawComma: boolean } | null => {
+    const items = first
+    // Called with a first item only once its trailing comma is consumed
+    let sawComma = first.length > 0
+    for (;;) {
+      skipSpace()
+      if (text[pos] === close) {
+        pos++
+        return { items, sawComma }
+      }
+      if (items.length > 0 && !sawComma) {
+        return null
+      }
+      const item = parseValue()
+      if (!item) {
+        return null
+      }
+      items.push(item)
+      skipSpace()
+      if (text[pos] === ',') {
+        pos++
+        sawComma = true
+      } else if (text[pos] !== close) {
+        return null
+      } else {
+        sawComma = false
+      }
+    }
+  }
+
+  const parseBrace = (): PyNode | null => {
+    pos++
+    skipSpace()
+    if (text[pos] === '}') {
+      pos++
+      return { k: 'dict', entries: [] }
+    }
+    const first = parseValue()
+    if (!first) {
+      return null
+    }
+    skipSpace()
+    if (text[pos] !== ':') {
+      // A set literal: the first item is parsed, continue as a sequence
+      if (text[pos] === ',') {
+        pos++
+        const rest = parseItems('}', [first])
+        return rest && { k: 'list', items: rest.items }
+      }
+      return text[pos++] === '}' ? { k: 'list', items: [first] } : null
+    }
+    const entries: [PyNode, PyNode][] = []
+    let key: PyNode | null = first
+    for (;;) {
+      // Keys must be scalars: a JSON object can only carry those
+      if (!key || key.k === 'list' || key.k === 'dict') {
+        return null
+      }
+      skipSpace()
+      if (text[pos++] !== ':') {
+        return null
+      }
+      const value = parseValue()
+      if (!value) {
+        return null
+      }
+      entries.push([key, value])
+      skipSpace()
+      const sep = text[pos++]
+      if (sep === '}') {
+        return { k: 'dict', entries }
+      }
+      if (sep !== ',') {
+        return null
+      }
+      skipSpace()
+      if (text[pos] === '}') {
+        pos++
+        return { k: 'dict', entries }
+      }
+      key = parseValue()
+    }
+  }
+
+  const parseValue = (): PyNode | null => {
+    skipSpace()
+    const ch = text[pos]
+    if (ch === '"' || ch === "'") {
+      return parseString()
+    }
+    if (ch === '[') {
+      pos++
+      const seq = parseItems(']')
+      return seq && { k: 'list', items: seq.items }
+    }
+    if (ch === '(') {
+      pos++
+      const seq = parseItems(')')
+      if (!seq) {
+        return null
+      }
+      // (x) is just x; (x,) and () are tuples
+      return seq.items.length === 1 && !seq.sawComma ? seq.items[0] : { k: 'list', items: seq.items }
+    }
+    if (ch === '{') {
+      return parseBrace()
+    }
+    NUMBER_TOKEN.lastIndex = pos
+    const num = NUMBER_TOKEN.exec(text)
+    if (num) {
+      pos = NUMBER_TOKEN.lastIndex
+      const v = Number(num[0])
+      if (num[1].includes('.') || num[2]) {
+        return Number.isFinite(v) ? { k: 'float', v } : null
+      }
+      return { k: 'int', v }
+    }
+    NAME_TOKEN.lastIndex = pos
+    const name = NAME_TOKEN.exec(text)
+    if (name && Object.prototype.hasOwnProperty.call(NAME_LITERALS, name[0])) {
+      pos = NAME_TOKEN.lastIndex
+      return NAME_LITERALS[name[0]]
+    }
+    return null
+  }
+
+  const node = parseValue()
+  skipSpace()
+  return node && pos === text.length ? node : null
+}
+
+/** Whether any int in the literal is too large to survive JSON losslessly. */
+export function hasUnsafeInt(node: PyNode): boolean {
+  switch (node.k) {
+    case 'int':
+      return !Number.isSafeInteger(node.v)
+    case 'list':
+      return node.items.some(hasUnsafeInt)
+    case 'dict':
+      return node.entries.some(([key, value]) => hasUnsafeInt(key) || hasUnsafeInt(value))
+    default:
+      return false
+  }
+}
+
+/** Python json.dumps spelling of a scalar dict key. */
+function keyToString(node: PyNode): string {
+  if (node.k === 'none') {
+    return 'null'
+  }
+  return 'v' in node ? String(node.v) : ''
+}
+
+export function toValue(node: PyNode): unknown {
+  switch (node.k) {
+    case 'none':
+      return null
+    case 'list':
+      return node.items.map(toValue)
+    case 'dict':
+      // fromEntries defines own properties, so a "__proto__" key stays data
+      return Object.fromEntries(node.entries.map(([key, value]) => [keyToString(key), toValue(value)]))
+    default:
+      return node.v
+  }
+}
diff --git a/purplex/client/src/components/activities/inputs/shared/useProbeState.ts b/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
index ba9acdd..1ce5c1b 100644
--- a/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
+++ b/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
@@ -8,105 +8,14 @@ import { computed, onMounted, reactive, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import axios from 'axios'
 import type { ActivityProblem, ProbeHistoryEntry, ProbeParameter, ProbeStatus } from '../../types'
-
-/** Canonical primitive parameter types that probe inputs are validated against. */
-export type PrimitiveType = 'int' | 'float' | 'bool' | 'str'
-
-/** Error code for a probe input that does not match its declared primitive type. */
-export type ProbeInputError = 'int' | 'intRange' | 'float' | 'bool'
-
-export interface ParsedProbeInput {
-  value: unknown
-  error: ProbeInputError | null
-}
-
-// Must stay identical to _PRIMITIVE_ALIASES in
-// purplex/problems_app/services/probe_service.py (issue #135).
-const PRIMITIVE_ALIASES = new Map<string, PrimitiveType>([
-  ['int', 'int'],
-  ['integer', 'int'],
-  ['float', 'float'],
-  ['number', 'float'],
-  ['bool', 'bool'],
-  ['boolean', 'bool'],
-  ['str', 'str'],
-  ['string', 'str'],
-])
-
-const INT_PATTERN = /^[+-]?\d+$/
-const BOOL_PATTERN = /^(true|false)$/i
-// Python float literal syntax: no hex/binary/octal, which Number() would otherwise accept
-const FLOAT_PATTERN = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/
-
-/**
- * Map a declared parameter type hint to its canonical primitive type.
- *
- * Strips a trailing ` = default`, trims, lowercases, and resolves aliases.
- * A `= None` default is an implicit Optional and is not checked.
- * Returns null for anything that is not checked (missing hint, Any, list[int],
- * Optional[int], dict, custom classes, ...).
- */
-export function normalizePrimitiveType(type: string | null | undefined): PrimitiveType | null {
-  if (!type) {
-    return null
-  }
-  const [base, ...defaultParts] = type.split('=')
-  if (defaultParts.join('=').trim() === 'None') {
-    return null
-  }
-  return PRIMITIVE_ALIASES.get(base.trim().toLowerCase()) ?? null
-}
-
-/**
- * Parse a raw probe input string according to its declared parameter type.
- *
- * Primitive types (int/float/bool/str) are validated strictly; str never errors.
- * Unknown or missing types fall back to JSON parsing, accepting Python-style
- * bare True/False/None, and fall back to the raw text when that fails.
- */
-export function parseInputValue(rawValue: string, type: string | null | undefined): ParsedProbeInput {
-  const text = rawValue.trim()
-
-  switch (normalizePrimitiveType(type)) {
-    case 'int':
-      if (!INT_PATTERN.test(text)) {
-        return { value: text, error: 'int' }
-      }
-      // JSON cannot carry ints above 2^53 losslessly, so refuse rather than corrupt
-      return Number.isSafeInteger(Number(text))
-        ? { value: Number(text), error: null }
-        : { value: text, error: 'intRange' }
-    case 'float': {
-      const num = Number(text)
-      return FLOAT_PATTERN.test(text) && Number.isFinite(num)
-        ? { value: num, error: null }
-        : { value: text, error: 'float' }
-    }
-    case 'bool':
-      return BOOL_PATTERN.test(text)
-        ? { value: text.toLowerCase() === 'true', error: null }
-        : { value: text, error: 'bool' }
-    case 'str':
-      if (text.length >= 2 && text.startsWith('"') && text.endsWith('"')) {
-        try {
-          return { value: JSON.parse(text), error: null }
-        } catch {
-          // Not a valid JSON string literal - keep the raw text
-        }
-      }
-      return { value: text, error: null }
-    default: {
-      // Untyped / unchecked: JSON first, accepting Python-style literals
-      const pythonLiterals: Record<string, string> = { True: 'true', False: 'false', None: 'null' }
-      const jsonText = pythonLiterals[text] ?? text
-      try {
-        return { value: JSON.parse(jsonText), error: null }
-      } catch {
-        return { value: text, error: null }
-      }
-    }
-  }
-}
+import {
+  type ArgsLineError,
+  parseArgsLine,
+  type ParsedProbeInput,
+  parseInputValue,
+  parseSignatureParams,
+  stableStringify,
+} from './probeArgs'
 
 export interface UseProbeStateOptions {
   /** Whether a submission is in flight; status is re-fetched when it ends (cooldown refills). */
@@ -124,6 +33,9 @@ export function useProbeState(
   const probeHistory = ref<ProbeHistoryEntry[]>([])
   const probeStatus = ref<ProbeStatus | null>(null)
   const probeInputs = reactive<Record<string, string>>({})
+  // The argument list as typed in the call line, and its line-level error
+  const argsLine = ref('')
+  const argsLineError = ref<ArgsLineError | null>(null)
 
   // Support both direct problem object and computed problem
   const getProblem = () => typeof problem === 'function' ? problem() : problem
@@ -163,25 +75,7 @@ export function useProbeState(
       return []
     }
 
-    const match = sig.match(/\(([^)]*)\)/)
-    if (!match) {
-      return []
-    }
-
-    const paramsStr = match[1].trim()
-    if (!paramsStr) {
-      return []
-    }
-
-    return paramsStr.split(',').map((p: string) => {
-      // Keep the default on the type (e.g. "int = None") so normalizePrimitiveType
-      // can see it; strip it from the name for untyped defaults like "x=3"
-      const [namePart, ...typeParts] = p.split(':')
-      return {
-        name: namePart.split('=')[0].trim(),
-        type: typeParts.join(':').trim() || 'Any'
-      }
-    })
+    return parseSignatureParams(sig)
   })
 
   const canProbe = computed(() => {
@@ -232,16 +126,19 @@ export function useProbeState(
     return 'status-exhausted'
   })
 
+  // Template for the call line: every parameter as a keyword with no value yet
+  const argsTemplate = computed(() => parameters.value.map(p => `${p.name}=`).join(', '))
+
   // Parse every current input once; shared by validation, duplicate detection and execution
   const parsedInputs = computed(() => {
     const values: Record<string, unknown> = {}
-    const errors: Record<string, ProbeInputError> = {}
+    const errors: Record<string, Pick<ParsedProbeInput, 'error' | 'errorParams'>> = {}
     for (const param of parameters.value) {
       const rawValue = probeInputs[param.name] ?? ''
-      const { value, error } = parseInputValue(rawValue, param.type)
+      const { value, error, errorParams } = parseInputValue(rawValue, param.type)
       values[param.name] = value
       if (error && rawValue !== '') {
-        errors[param.name] = error
+        errors[param.name] = { error, errorParams }
       }
     }
     return { values, errors }
@@ -250,28 +147,39 @@ export function useProbeState(
   // Translated per-field type errors, keyed by parameter name (non-empty fields only)
   const inputErrors = computed((): Record<string, string> => {
     const messages: Record<string, string> = {}
-    for (const [name, code] of Object.entries(parsedInputs.value.errors)) {
-      messages[name] = t(`problems.probe.invalidType.${code}`)
+    for (const [name, { error, errorParams }] of Object.entries(parsedInputs.value.errors)) {
+      messages[name] = t(`problems.probe.invalidType.${error}`, errorParams ?? {})
     }
     return messages
   })
 
+  // Translated line-level error of the argument list (unknown/duplicate/extra/empty argument)
+  const lineError = computed((): string | null => {
+    const error = argsLineError.value
+    if (!error) {
+      return null
+    }
+    const name = error.code === 'tooManyPositional' ? functionName.value : error.name
+    return t(`problems.probe.lineError.${error.code}`, { name })
+  })
+
   const hasValidInputs = computed(() => {
-    // Every parameter has a value and none fails its declared type
+    // Every parameter has a value, none fails its declared type, and the line maps cleanly
     const allFilled = parameters.value.every(p => {
       const value = probeInputs[p.name]
       return value !== undefined && value !== ''
     })
-    return allFilled && Object.keys(parsedInputs.value.errors).length === 0
+    return allFilled && Object.keys(parsedInputs.value.errors).length === 0 && !argsLineError.value
   })
 
   // Check if current inputs match any previous query (real-time duplicate detection)
   const duplicateEntry = computed(() => {
     if (!hasValidInputs.value) {return null}
 
-    const inputKey = JSON.stringify(parsedInputs.value.values)
+    // Key order is irrelevant: {'a': 1, 'b': 2} and {'b': 2, 'a': 1} are one call
+    const inputKey = stableStringify(parsedInputs.value.values)
     return probeHistory.value.find(
-      entry => JSON.stringify(entry.input) === inputKey
+      entry => stableStringify(entry.input) === inputKey
     ) || null
   })
 
@@ -302,6 +210,8 @@ export function useProbeState(
     Object.keys(probeInputs).forEach(key => {
       probeInputs[key] = ''
     })
+    argsLine.value = ''
+    argsLineError.value = null
   })
 
   // A completed submission can refill a cooldown budget server-side
@@ -341,7 +251,7 @@ export function useProbeState(
     if (!canProbe.value || probing.value || isDuplicate.value) {
       return
     }
-    if (Object.keys(parsedInputs.value.errors).length > 0) {
+    if (!hasValidInputs.value) {
       return
     }
 
@@ -398,8 +308,14 @@ export function useProbeState(
     return JSON.stringify(output)
   }
 
-  function updateProbeInput(paramName: string, value: string) {
-    probeInputs[paramName] = value
+  /** Set the call line's argument list and map it onto the per-parameter inputs. */
+  function setArgsLine(text: string) {
+    argsLine.value = text
+    const { raw, lineError: error } = parseArgsLine(text, parameters.value.map(p => p.name))
+    for (const param of parameters.value) {
+      probeInputs[param.name] = raw[param.name] ?? ''
+    }
+    argsLineError.value = error
   }
 
   function formatFunctionCall(input: Record<string, unknown>): string {
@@ -414,6 +330,7 @@ export function useProbeState(
     probeHistory,
     probeStatus,
     probeInputs,
+    argsLine,
     // Computed
     probeConfig,
     functionSignature,
@@ -426,6 +343,8 @@ export function useProbeState(
     probeStatusClass,
     hasValidInputs,
     inputErrors,
+    lineError,
+    argsTemplate,
     isDuplicate,
     cachedResult,
     // Methods
@@ -436,6 +355,6 @@ export function useProbeState(
     formatInput,
     formatOutput,
     formatFunctionCall,
-    updateProbeInput,
+    setArgsLine,
   }
 }
diff --git a/purplex/client/src/i18n/locales/en/problems.json b/purplex/client/src/i18n/locales/en/problems.json
index 6b4a218..08b6d44 100644
--- a/purplex/client/src/i18n/locales/en/problems.json
+++ b/purplex/client/src/i18n/locales/en/problems.json
@@ -217,15 +217,27 @@
       "tooltipExhausted": "No probes remaining",
       "tooltipDefault": "Query the oracle with these inputs",
       "srDuplicate": "These inputs were already probed. Result: {result}",
-      "paramAriaLabel": "Enter value for {name} (type: {type})",
-      "paramAriaLabelNoType": "Enter value for {name}",
       "cachedResultAriaLabel": "Cached result: {result}",
-      "valuePlaceholderHint": "value — quote text: \"abc\"",
+      "argsAriaLabel": "Arguments for {name}",
+      "argsHelp": "Enter probes. Tab on an empty line fills in the argument names.",
+      "fillArgs": "Fill in argument names",
+      "lineError": {
+        "unknownKeyword": "Unknown argument {name}",
+        "duplicateArgument": "Argument {name} given twice",
+        "positionalAfterKeyword": "Positional argument after {name}=; put positional arguments first",
+        "tooManyPositional": "Too many arguments for {name}",
+        "emptyArgument": "Empty argument between commas"
+      },
       "invalidType": {
         "int": "Must be a whole number (e.g. 5)",
         "intRange": "Whole number is too large (at most 15 digits)",
         "float": "Must be a number (e.g. 1.5)",
-        "bool": "Must be true or false"
+        "bool": "Must be true or false",
+        "list": "Must be a list, e.g. [1, 2, 3]",
+        "listItems": "Every item must be {kind}",
+        "dict": "Must be a dict, e.g. {'{'}\"a\": 1{'}'}",
+        "dictItems": "Keys must be {key} and values {value}",
+        "literal": "Not a valid Python value"
       }
     },
     "refute": {
diff --git a/purplex/client/src/i18n/locales/es/problems.json b/purplex/client/src/i18n/locales/es/problems.json
index 4ca3c30..c652d84 100644
--- a/purplex/client/src/i18n/locales/es/problems.json
+++ b/purplex/client/src/i18n/locales/es/problems.json
@@ -217,15 +217,27 @@
       "tooltipExhausted": "No quedan sondeos",
       "tooltipDefault": "Consultar el oráculo con estas entradas",
       "srDuplicate": "Estas entradas ya fueron sondeadas. Resultado: {result}",
-      "paramAriaLabel": "Ingresa valor para {name} (tipo: {type})",
-      "paramAriaLabelNoType": "Ingresa valor para {name}",
       "cachedResultAriaLabel": "Resultado en caché: {result}",
-      "valuePlaceholderHint": "valor — texto entre comillas: \"abc\"",
+      "argsAriaLabel": "Argumentos para {name}",
+      "argsHelp": "Enter sondea. Tab en una línea vacía rellena los nombres de los argumentos.",
+      "fillArgs": "Rellenar nombres de argumentos",
+      "lineError": {
+        "unknownKeyword": "Argumento desconocido {name}",
+        "duplicateArgument": "El argumento {name} se dio dos veces",
+        "positionalAfterKeyword": "Argumento posicional después de {name}=; pon primero los argumentos posicionales",
+        "tooManyPositional": "Demasiados argumentos para {name}",
+        "emptyArgument": "Argumento vacío entre comas"
+      },
       "invalidType": {
         "int": "Debe ser un número entero (p. ej. 5)",
         "intRange": "El número entero es demasiado grande (máximo 15 dígitos)",
         "float": "Debe ser un número (p. ej. 1.5)",
-        "bool": "Debe ser true o false"
+        "bool": "Debe ser true o false",
+        "list": "Debe ser una lista, p. ej. [1, 2, 3]",
+        "listItems": "Cada elemento debe ser {kind}",
+        "dict": "Debe ser un diccionario, p. ej. {'{'}\"a\": 1{'}'}",
+        "dictItems": "Las claves deben ser {key} y los valores {value}",
+        "literal": "No es un valor de Python válido"
       }
     },
     "refute": {

From 392937262965f9563fbbeaa60ad442eb96201562 Mon Sep 17 00:00:00 2001
From: David Smith <davidsmith@hamiltonfour.tech>
Date: Thu, 15 Oct 2026 23:38:57 -0400
Subject: [PATCH 3/3] E2E: probe specs use the call line; cover container item
 validation on both sides

All probe specs type into #probe-args through a shared helper instead of
the removed per-parameter inputs, keeping each test's assertions. A
seeded tag(items: list[str], prefix: str) problem reproduces the bug
that started this: A12 proves integers in a list[str] show the item
error in the UI and A16 proves the API rejects the same input with
"Parameter 'items' must be a list of str". Further tests cover keyword
and positional mapping with each line error, the Tab template, quoted
str arguments, Shift+Enter and Tab leaving the editable, the closing
parenthesis trailing a wrapped line, and the panel at phone width.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 e2e/helpers/probe.ts                          |  67 +++
 e2e/helpers/selectors.ts                      |  14 +-
 e2e/student/probeable-budget.spec.ts          |  40 +-
 e2e/student/probeable-probing.spec.ts         | 381 +++++++++++++++---
 e2e/student/probeable-spec.spec.ts            |   9 +-
 e2e/student/submission-probeable.spec.ts      |  20 +-
 .../management/commands/seed_e2e_data.py      |  21 +
 7 files changed, 453 insertions(+), 99 deletions(-)
 create mode 100644 e2e/helpers/probe.ts

diff --git a/e2e/helpers/probe.ts b/e2e/helpers/probe.ts
new file mode 100644
index 0000000..912facd
--- /dev/null
+++ b/e2e/helpers/probe.ts
@@ -0,0 +1,67 @@
+import { expect, Page } from '@playwright/test';
+import { probe } from './selectors';
+
+/**
+ * Probe panel call line (activities/inputs/shared/ProbePanel.vue).
+ *
+ * The student edits only the argument list between `name(` and `)`: one
+ * contenteditable #probe-args holding Python-style arguments, positional or
+ * keyword (`7`, `n=7`, `["a", "b"], prefix="x"`).
+ */
+
+/**
+ * Replace the argument list with `text` and wait until the editable holds it.
+ *
+ * Locator.fill selects the current contents and inserts the text as one input
+ * event, which a contenteditable accepts, brackets and quotes included.
+ */
+export async function fillProbeArgs(page: Page, text: string): Promise<void> {
+  const line = page.locator(probe.argsLine);
+  await line.fill(text);
+  await expect(line).toHaveJSProperty('textContent', text);
+}
+
+/** Text of the result slot after the arrow ('?' until a result). */
+export async function readProbeResult(page: Page): Promise<string> {
+  return (await page.locator(probe.result).innerText()).trim();
+}
+
+/** Text of the remaining-probe badge, e.g. '· ∞' or '· 2 left'. */
+export async function readBadge(page: Page): Promise<string> {
+  return (await page.locator(probe.badge).innerText()).trim();
+}
+
+/**
+ * Assert the error shown for one argument. `name` is a parameter name, or
+ * 'line' for a line-level error (unknown, duplicate, extra or empty argument).
+ */
+export async function expectArgError(page: Page, name: string, text: string | RegExp): Promise<void> {
+  await expect(page.locator(probe.fieldError(name))).toHaveText(text);
+}
+
+/**
+ * Assert whether the argument list can be edited. Locked means
+ * contenteditable="false" plus aria-disabled, as when probes are exhausted.
+ */
+export async function expectArgsEditable(page: Page, editable: boolean): Promise<void> {
+  const line = page.locator(probe.argsLine);
+  if (editable) {
+    // The e2e project is Chromium-only, which supports plaintext-only; the 'true'
+    // fallback for other browsers is covered in Vitest (probeArgsLine.test.ts)
+    await expect(line).toHaveAttribute('contenteditable', 'plaintext-only');
+    await expect(line).toBeEnabled();
+  } else {
+    await expect(line).toHaveAttribute('contenteditable', 'false');
+    await expect(line).toHaveAttribute('aria-disabled', 'true');
+    await expect(line).toBeDisabled();
+  }
+}
+
+/** The placeholder actually painted in the empty call line (CSS :empty::before). */
+export async function readArgsPlaceholder(page: Page): Promise<string> {
+  return page.locator(probe.argsLine).evaluate((el) => {
+    const content = getComputedStyle(el, '::before').content;
+    // 'none' when the line is not empty; otherwise a quoted CSS string
+    return content === 'none' ? '' : JSON.parse(content);
+  });
+}
diff --git a/e2e/helpers/selectors.ts b/e2e/helpers/selectors.ts
index 9190597..b2673b1 100644
--- a/e2e/helpers/selectors.ts
+++ b/e2e/helpers/selectors.ts
@@ -247,8 +247,16 @@ export const common = {
 export const probe = {
   /** Panel root */
   panel: '.probe-panel',
-  /** Input for one parameter (Enter triggers a probe) */
-  paramInput: (name: string) => `input#probe-${name}.param-input`,
+  /** Row holding the call and the History button (wraps on narrow screens) */
+  row: '.probe-panel .probe-row',
+  /** Box around the call line: `name(` + arguments + `)` (.has-error / .is-disabled) */
+  callShell: '.probe-panel .call-shell',
+  /** Editable argument list between the parentheses (Enter probes, Tab fills names) */
+  argsLine: '#probe-args',
+  /** Closing parenthesis after the argument list */
+  closeParen: '.probe-panel .call-shell .fn-paren:last-of-type',
+  /** 'Fill in argument names' button: inserts `name=, name=` */
+  fillArgsButton: 'button.fill-args-btn',
   /** Result slot ('?' until a result; .has-result / .is-cached) */
   result: '.probe-panel .fn-result',
   /** Probe button ('Probe' | 'Probing' | 'Already probed', .is-duplicate) */
@@ -263,6 +271,8 @@ export const probe = {
   fieldErrors: 'ul.probe-field-errors',
   /** One parameter's field error */
   fieldError: (name: string) => `li#probe-err-${name}`,
+  /** Line-level error (unknown keyword, duplicate/empty argument, too many arguments) */
+  lineError: 'li#probe-err-line',
   /** 'History (N)' button, rendered only when history is non-empty */
   historyButton: '.probe-panel .history-btn',
   /** History modal (teleported to body) */
diff --git a/e2e/student/probeable-budget.spec.ts b/e2e/student/probeable-budget.spec.ts
index 875c554..a15fab0 100644
--- a/e2e/student/probeable-budget.spec.ts
+++ b/e2e/student/probeable-budget.spec.ts
@@ -17,12 +17,15 @@
  *     keep their values, so the button switches to "Already probed"; the spec
  *     enters new values before it reads the badge.
  *   - A duplicate input is answered from the client-side history: no request.
+ *   - The arguments are typed into one call line (#probe-args) as `a=1, b=2`;
+ *     once probes are exhausted it is contenteditable="false" + aria-disabled.
  */
 
 import { test, expect, Page, Response } from '@playwright/test';
 import { navigateAsFreshStudent, freshStudent, injectUser, enrollUser } from '../helpers/users';
 import { submitCodeAndWait } from '../helpers/submission';
 import { probe } from '../helpers/selectors';
+import { expectArgsEditable, fillProbeArgs } from '../helpers/probe';
 
 const SET_URL = '/courses/CS101-2024/problem-set/e2e-probeable';
 const BLOCK_URL = `${SET_URL}?p=0`;
@@ -37,16 +40,16 @@ function isProbePost(resp: Response, slug: string): boolean {
   );
 }
 
-/** Wait until the probe panel and its add(a, b) inputs are on screen. */
+/** Wait until the probe panel and its add(a, b) call line are on screen. */
 async function waitForProbePanel(page: Page): Promise<void> {
   await expect(page.locator(probe.panel)).toBeVisible({ timeout: 15_000 });
-  await expect(page.locator(probe.paramInput('a'))).toBeVisible();
-  await expect(page.locator(probe.paramInput('b'))).toBeVisible();
+  await expect(page.locator('.probe-panel .fn-name')).toHaveText('add');
+  await expect(page.locator(probe.argsLine)).toBeVisible();
 }
 
+/** Type add(a=<a>, b=<b>) into the call line. */
 async function fillArgs(page: Page, a: string, b: string): Promise<void> {
-  await page.locator(probe.paramInput('a')).fill(a);
-  await page.locator(probe.paramInput('b')).fill(b);
+  await fillProbeArgs(page, `a=${a}, b=${b}`);
 }
 
 /**
@@ -128,7 +131,7 @@ test.describe('Probe budget: block mode', () => {
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
 
     // Confirming the duplicate from the keyboard must not probe either.
-    await page.locator(probe.paramInput('b')).press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
 
     // The duplicate was free: one probe is still left.
     await fillArgs(page, '3', '3');
@@ -144,8 +147,7 @@ test.describe('Probe budget: block mode', () => {
     // Exhausted state without a reload.
     await expect(page.locator(probe.hint)).toHaveText('No probes remaining.');
     await expect(page.locator(probe.button)).toBeDisabled();
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeDisabled();
+    await expectArgsEditable(page, false);
     await expect(page.locator(probe.historyButton)).toHaveText('History (3)');
 
     // Server-side state survives a fresh load (second tab, same student).
@@ -157,8 +159,7 @@ test.describe('Probe budget: block mode', () => {
       await expectBadge(freshTab, 0, 'status-exhausted');
       await expect(freshTab.locator(probe.hint)).toHaveText('No probes remaining.');
       await expect(freshTab.locator(probe.button)).toBeDisabled();
-      await expect(freshTab.locator(probe.paramInput('a'))).toBeDisabled();
-      await expect(freshTab.locator(probe.paramInput('b'))).toBeDisabled();
+      await expectArgsEditable(freshTab, false);
       await expect(freshTab.locator(probe.result)).toHaveText('6');
 
       // Earlier results stay readable from the history after exhaustion.
@@ -206,9 +207,9 @@ test.describe('Probe budget: block mode', () => {
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
     await expect(page.locator(probe.result)).toHaveText('3');
 
-    // Enter in a parameter field is the keyboard path to "Probe". On a
+    // Enter in the call line is the keyboard path to "Probe". On a
     // duplicate it must do nothing, like the disabled button.
-    await page.locator(probe.paramInput('b')).press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
 
     // Budget is server-side: a fresh load shows whether anything was spent.
     await page.reload({ waitUntil: 'networkidle' });
@@ -283,8 +284,7 @@ test.describe('Probe budget: cooldown mode', () => {
 
     await expect(page.locator(probe.hint)).toHaveText(refillHint);
     await expect(page.locator(probe.button)).toBeDisabled();
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeDisabled();
+    await expectArgsEditable(page, false);
 
     // One submission earns the refill.
     await submitCodeAndWait(page, ADD_SOLUTION);
@@ -298,8 +298,7 @@ test.describe('Probe budget: cooldown mode', () => {
       await waitForProbePanel(freshTab);
       await expectBadge(freshTab, 2, 'status-available');
       await expect(freshTab.locator(probe.hint)).toHaveCount(0);
-      await expect(freshTab.locator(probe.paramInput('a'))).toBeEnabled();
-      await expect(freshTab.locator(probe.paramInput('b'))).toBeEnabled();
+      await expectArgsEditable(freshTab, true);
     } finally {
       await freshTab.close();
     }
@@ -307,8 +306,7 @@ test.describe('Probe budget: cooldown mode', () => {
     // Without a reload, the page the student submitted from must show the
     // refilled budget too.
     await expect(page.locator(probe.hint)).toHaveCount(0);
-    await expect(page.locator(probe.paramInput('a'))).toBeEnabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeEnabled();
+    await expectArgsEditable(page, true);
     await fillArgs(page, '3', '3');
     await expectBadge(page, 2, 'status-available');
 
@@ -337,21 +335,21 @@ test.describe('Probe budget: cooldown mode', () => {
     await expect(page.locator(probe.hint)).toHaveText(
       'No probes remaining. Submit 2 more times to unlock more probes.',
     );
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
+    await expectArgsEditable(page, false);
 
     // First submission: one more is still needed, and the budget stays empty.
     await submitCodeAndWait(page, ADD_SOLUTION);
     await expect(page.locator(probe.hint)).toHaveText(
       'No probes remaining. Submit 1 more time to unlock more probes.',
     );
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
+    await expectArgsEditable(page, false);
     await expect(page.locator(probe.button)).toBeDisabled();
     await expectBadge(page, 0, 'status-exhausted');
 
     // Second submission earns the refill.
     await submitCodeAndWait(page, ADD_SOLUTION);
     await expect(page.locator(probe.hint)).toHaveCount(0);
-    await expect(page.locator(probe.paramInput('a'))).toBeEnabled();
+    await expectArgsEditable(page, true);
     await fillArgs(page, '2', '2');
     await expectBadge(page, 1, 'status-available');
 
diff --git a/e2e/student/probeable-probing.spec.ts b/e2e/student/probeable-probing.spec.ts
index cd0ed0f..4aa97be 100644
--- a/e2e/student/probeable-probing.spec.ts
+++ b/e2e/student/probeable-probing.spec.ts
@@ -5,14 +5,25 @@
  *   p=2 e2e-probeable-locked  clamp(n: int) -> max(0, min(n, 10)), explore mode
  *   p=3 e2e-probeable-errors  recip(x: int) -> 10 // x, block mode, 3 probes
  *   p=4 e2e-probeable-hidden  recip(x) with the signature hidden, explore mode
+ *   p=7 e2e-probeable-list    tag(items: list[str], prefix: str), explore mode
  *
  * Probe budgets and history live in Redis per (problem, user) with no reset,
  * so every test runs as a fresh student.
+ *
+ * The probe panel is a call line: `name(` and `)` are fixed text and the
+ * student types the argument list (#probe-args), positional or keyword.
  */
 
 import { test, expect, Page, Request } from '@playwright/test';
 import { apiAsUser, navigateAsFreshStudent, FreshUser } from '../helpers/users';
 import { probe } from '../helpers/selectors';
+import {
+  expectArgError,
+  expectArgsEditable,
+  fillProbeArgs,
+  readArgsPlaceholder,
+  readBadge,
+} from '../helpers/probe';
 
 const SET_PATH = '/courses/CS101-2024/problem-set/e2e-probeable';
 const PROBE_POST_PATH = /^\/api\/problems\/[^/]+\/probe\/$/;
@@ -37,20 +48,14 @@ async function openAsFreshStudent(
 }
 
 /**
- * Fill one parameter, trigger a probe (button click or Enter in the field),
- * and return the probe response body. Fails unless the API answers 200.
+ * Type the argument list, trigger a probe (button click or Enter in the call
+ * line), and return the probe response body. Fails unless the API answers 200.
  */
-async function probeWith(
-  page: Page,
-  param: string,
-  value: string,
-  via: 'click' | 'enter' = 'click',
-): Promise<any> {
-  const input = page.locator(probe.paramInput(param));
-  await input.fill(value);
+async function probeWith(page: Page, args: string, via: 'click' | 'enter' = 'click'): Promise<any> {
+  await fillProbeArgs(page, args);
   const responsePromise = page.waitForResponse((resp) => isProbePost(resp.request()));
   if (via === 'enter') {
-    await input.press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
   } else {
     await page.locator(probe.button).click();
   }
@@ -63,13 +68,17 @@ test.describe('A Probing the oracle', () => {
   test('A1 first probe shows the result, the explore badge and History (1)', async ({ page }) => {
     await openAsFreshStudent(page, 'a1-first-probe', 2, 'clamp');
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
     const result = page.locator(probe.result);
     const button = page.locator(probe.button);
 
-    // Fresh state: empty input, no result, no history, unlimited badge
-    await expect(input).toHaveValue('');
-    await expect(input).toHaveAttribute('placeholder', 'int');
+    // Fresh state: empty call line showing the parameter name and its declared
+    // type (the signature is visible here; A10 covers names only), no result,
+    // no history, unlimited badge
+    await expect(line).toHaveJSProperty('textContent', '');
+    await expect(line).toHaveAttribute('role', 'textbox');
+    await expect(line).toHaveAttribute('aria-label', 'Arguments for clamp');
+    expect(await readArgsPlaceholder(page)).toBe('n: int');
     await expect(result).toHaveText('?');
     await expect(result).not.toHaveClass(/has-result/);
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
@@ -78,7 +87,7 @@ test.describe('A Probing the oracle', () => {
     // No value yet: nothing to probe
     await expect(button).toBeDisabled();
 
-    const body = await probeWith(page, 'n', '7');
+    const body = await probeWith(page, '7');
     expect(body.success).toBe(true);
     expect(body.result).toBe(7);
     expect(body.probe_status.mode).toBe('explore');
@@ -89,7 +98,7 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.error)).toHaveCount(0);
 
     // A new value brings the Probe button back with the unlimited badge
-    await input.fill('8');
+    await fillProbeArgs(page, '8');
     await expect(button).toBeEnabled();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
   });
@@ -97,12 +106,12 @@ test.describe('A Probing the oracle', () => {
   test('A2 repeat probe with a new input (Enter key) replaces the result', async ({ page }) => {
     await openAsFreshStudent(page, 'a2-repeat-probe', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
+    await probeWith(page, '7');
     await expect(page.locator(probe.result)).toHaveText('7');
     await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
 
-    // Enter in the field triggers the probe
-    const body = await probeWith(page, 'n', '20', 'enter');
+    // Enter in the call line triggers the probe
+    const body = await probeWith(page, '20', 'enter');
     expect(body.success).toBe(true);
     expect(body.result).toBe(10);
 
@@ -113,8 +122,8 @@ test.describe('A Probing the oracle', () => {
   test('A3 duplicate probe returns the cached result without a request', async ({ page }) => {
     await openAsFreshStudent(page, 'a3-duplicate-probe', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
     await expect(page.locator(probe.result)).toHaveText('10');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
 
@@ -125,11 +134,11 @@ test.describe('A Probing the oracle', () => {
       }
     });
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
     const result = page.locator(probe.result);
     const button = page.locator(probe.button);
 
-    await input.fill('7');
+    await fillProbeArgs(page, '7');
     await expect(result).toHaveClass(/is-cached/);
     await expect(result).toHaveText('7');
     await expect(button).toHaveClass(/is-duplicate/);
@@ -137,12 +146,12 @@ test.describe('A Probing the oracle', () => {
     await expect(button).toBeDisabled();
     await expect(page.locator(probe.badge)).toHaveCount(0);
 
-    // Enter in the field is the other way to probe; it must not re-send either
-    await input.press('Enter');
+    // Enter in the call line is the other way to probe; it must not re-send either
+    await line.press('Enter');
 
     // A real probe afterwards orders the request stream: if the duplicate had
     // been sent, it would be recorded before this one.
-    const body = await probeWith(page, 'n', '3');
+    const body = await probeWith(page, '3');
     expect(body.result).toBe(3);
     expect(probePosts).toEqual([JSON.stringify({ input: { n: 3 } })]);
     await expect(page.locator(probe.historyButton)).toHaveText('History (3)');
@@ -158,25 +167,27 @@ test.describe('A Probing the oracle', () => {
       }
     });
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
+    const shell = page.locator(probe.callShell);
     const button = page.locator(probe.button);
     const fieldError = page.locator(probe.fieldError('n'));
 
-    await input.fill('abc');
-    await expect(fieldError).toHaveText('n: Must be a whole number (e.g. 5)');
-    await expect(input).toHaveClass(/has-error/);
-    await expect(input).toHaveAttribute('aria-invalid', 'true');
-    await expect(input).toHaveAttribute('aria-describedby', 'probe-err-n');
+    await fillProbeArgs(page, 'abc');
+    await expectArgError(page, 'n', 'n: Must be a whole number (e.g. 5)');
+    await expect(shell).toHaveClass(/has-error/);
+    await expect(line).toHaveAttribute('aria-invalid', 'true');
+    await expect(line).toHaveAttribute('aria-describedby', 'probe-field-errors probe-args-help');
     await expect(button).toBeDisabled();
     // Enter with an invalid value sends nothing
-    await input.press('Enter');
+    await line.press('Enter');
 
-    await input.fill('3');
+    await fillProbeArgs(page, '3');
     await expect(fieldError).toHaveCount(0);
-    await expect(input).not.toHaveClass(/has-error/);
+    await expect(shell).not.toHaveClass(/has-error/);
+    await expect(line).not.toHaveAttribute('aria-invalid', 'true');
     await expect(button).toBeEnabled();
 
-    const body = await probeWith(page, 'n', '3');
+    const body = await probeWith(page, '3');
     expect(body.result).toBe(3);
     expect(probePosts).toBe(1);
     await expect(page.locator(probe.result)).toHaveText('3');
@@ -185,9 +196,9 @@ test.describe('A Probing the oracle', () => {
   test('A5 history modal lists every probe, most recent first, and closes', async ({ page }) => {
     await openAsFreshStudent(page, 'a5-history-modal', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
-    await probeWith(page, 'n', '-3');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
+    await probeWith(page, '-3');
     await expect(page.locator(probe.result)).toHaveText('0');
 
     const historyButton = page.locator(probe.historyButton);
@@ -212,8 +223,8 @@ test.describe('A Probing the oracle', () => {
   test('A6 reload restores the probe history from the server', async ({ page }) => {
     const user = await openAsFreshStudent(page, 'a6-reload', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
 
     const server = await apiAsUser(
@@ -237,10 +248,10 @@ test.describe('A Probing the oracle', () => {
     await historyLoaded;
     await expect(page.locator(probe.panel)).toBeVisible();
 
-    // Both probes restored from the server, the latest result shown, inputs cleared
+    // Both probes restored from the server, the latest result shown, call line cleared
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
     await expect(page.locator(probe.result)).toHaveText('10');
-    await expect(page.locator(probe.paramInput('n'))).toHaveValue('');
+    await expect(page.locator(probe.argsLine)).toHaveJSProperty('textContent', '');
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
 
     await page.locator(probe.historyButton).click();
@@ -250,7 +261,7 @@ test.describe('A Probing the oracle', () => {
     await page.locator(probe.close).click();
 
     // Re-entering a value probed before the reload is still recognised
-    await page.locator(probe.paramInput('n')).fill('7');
+    await fillProbeArgs(page, '7');
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
     await expect(page.locator(probe.result)).toHaveText('7');
     await expect(page.locator(probe.button)).toContainText('Already probed');
@@ -264,7 +275,7 @@ test.describe('A Probing the oracle', () => {
     await expect(badge).toHaveClass(/status-explore/);
 
     for (let n = 1; n <= 15; n += 1) {
-      const body = await probeWith(page, 'n', String(n));
+      const body = await probeWith(page, String(n));
       expect(body.success).toBe(true);
       expect(body.result).toBe(Math.min(n, 10));
       expect(body.probe_status.mode).toBe('explore');
@@ -274,15 +285,14 @@ test.describe('A Probing the oracle', () => {
 
     await expect(page.locator(probe.historyButton)).toHaveText('History (15)');
 
-    const input = page.locator(probe.paramInput('n'));
-    await input.fill('16');
-    await expect(input).toBeEnabled();
+    await fillProbeArgs(page, '16');
+    await expectArgsEditable(page, true);
     await expect(page.locator(probe.button)).toBeEnabled();
     await expect(badge).toHaveText('· ∞');
     await expect(badge).toHaveClass(/status-explore/);
     await expect(page.locator(probe.hint)).toHaveCount(0);
 
-    const body = await probeWith(page, 'n', '16');
+    const body = await probeWith(page, '16');
     expect(body.success).toBe(true);
     expect(body.result).toBe(10);
     await expect(page.locator(probe.historyButton)).toHaveText('History (16)');
@@ -291,10 +301,10 @@ test.describe('A Probing the oracle', () => {
   test('A10 hidden signature hides types and sanitises oracle errors', async ({ page }) => {
     const user = await openAsFreshStudent(page, 'a10-hidden', 4, 'recip');
 
-    const input = page.locator(probe.paramInput('x'));
-    await expect(page.locator('.probe-panel .param-name')).toHaveText(['x']);
-    await expect(input).toHaveAttribute('placeholder', 'value — quote text: "abc"');
-    await expect(input).toHaveAttribute('aria-label', 'Enter value for x');
+    // Parameter names are not secret: the empty call line still shows them
+    const line = page.locator(probe.argsLine);
+    expect(await readArgsPlaceholder(page)).toBe('x');
+    await expect(line).toHaveAttribute('aria-label', 'Arguments for recip');
 
     // The types never reach the browser: the problem payload the page loads
     // carries no signature, untyped parameters and no oracle source.
@@ -307,15 +317,28 @@ test.describe('A Probing the oracle', () => {
     expect(hidden.reference_solution).toBeNull();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
 
-    const failed = await probeWith(page, 'x', '0');
-    expect(failed.success).toBe(false);
+    // Without the types the browser cannot pre-check 'abc', so only the backend
+    // can reject it: a 400 (not charged) whose generic message reaches the UI
     const error = page.locator(probe.error);
+    await fillProbeArgs(page, 'abc');
+    await expect(page.locator(probe.fieldError('x'))).toHaveCount(0);
+    const rejectedPromise = page.waitForResponse((resp) => isProbePost(resp.request()));
+    await page.locator(probe.button).click();
+    const rejected = await rejectedPromise;
+    expect(rejected.status()).toBe(400);
+    await expect(error).toHaveText("That value is not valid for parameter 'x'");
+    await expect(error).not.toContainText('int');
+    await expect(page.locator(probe.historyButton)).toHaveCount(0);
+    await expect(page.locator(probe.badge)).toHaveText('· ∞');
+
+    const failed = await probeWith(page, '0');
+    expect(failed.success).toBe(false);
     await expect(error).toHaveText('These inputs could not be evaluated. Try different values.');
     await expect(error).not.toContainText('division');
     await expect(page.locator(probe.result)).toHaveText('?');
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
-    const ok = await probeWith(page, 'x', '5');
+    const ok = await probeWith(page, '5');
     expect(ok.success).toBe(true);
     expect(ok.result).toBe(2);
     await expect(page.locator(probe.result)).toHaveText('2');
@@ -330,7 +353,7 @@ test.describe('A Probing the oracle', () => {
     await expect(badge).toHaveText('· 3 left');
     await expect(badge).toHaveClass(/status-available/);
 
-    const failed = await probeWith(page, 'x', '0');
+    const failed = await probeWith(page, '0');
     expect(failed.success).toBe(false);
     expect(failed.probe_status.remaining).toBe(3);
     // Exactly the exception text, nothing else (no traceback, no type name).
@@ -344,7 +367,7 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.result)).toHaveText('?');
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
-    const ok = await probeWith(page, 'x', '5');
+    const ok = await probeWith(page, '5');
     expect(ok.success).toBe(true);
     expect(ok.result).toBe(2);
     expect(ok.probe_status.remaining).toBe(2);
@@ -352,10 +375,244 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.error)).toHaveCount(0);
     await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
 
-    // The input still holds the probed value (duplicate state hides the badge);
-    // a new value shows the charged budget
-    await page.locator(probe.paramInput('x')).fill('6');
+    // The call line still holds the probed value (duplicate state hides the
+    // badge); a new value shows the charged budget
+    await fillProbeArgs(page, '6');
     await expect(badge).toHaveText('· 2 left');
     await expect(badge).toHaveClass(/status-available/);
   });
+
+  test('A12 list[str] given integers shows the item-type error and disables Probe', async ({
+    page,
+  }) => {
+    await openAsFreshStudent(page, 'a12-list-items', 7, 'tag');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+
+    const line = page.locator(probe.argsLine);
+    const button = page.locator(probe.button);
+
+    // Integers are not str: the item type is checked, not just the list shape
+    await fillProbeArgs(page, '[1, 2, 3], "x"');
+    await expectArgError(page, 'items', 'items: Every item must be str');
+    await expect(page.locator(probe.fieldError('prefix'))).toHaveCount(0);
+    await expect(page.locator(probe.callShell)).toHaveClass(/has-error/);
+    await expect(button).toBeDisabled();
+    // Enter with an invalid value sends nothing
+    await line.press('Enter');
+
+    await fillProbeArgs(page, '["a", "b"], "x"');
+    await expect(page.locator(`${probe.fieldErrors} li`)).toHaveCount(0);
+    await expect(button).toBeEnabled();
+    await expect.poll(() => readBadge(page)).toBe('· ∞');
+
+    const body = await probeWith(page, '["a", "b"], "x"');
+    expect(body.success).toBe(true);
+    expect(body.result).toEqual(['xa', 'xb']);
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    expect(probePosts).toEqual([JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } })]);
+  });
+
+  test('A13 keyword and positional arguments map onto the signature', async ({ page }) => {
+    await openAsFreshStudent(page, 'a13-arg-mapping', 2, 'clamp');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+
+    const result = page.locator(probe.result);
+    const button = page.locator(probe.button);
+    const lineError = page.locator(probe.lineError);
+
+    // Positional: the first argument is n
+    const body = await probeWith(page, '7');
+    expect(body.result).toBe(7);
+    await expect(result).toHaveText('7');
+
+    // Keyword: n=7 is the same call, so the cached result answers it
+    await fillProbeArgs(page, 'n=7');
+    await expect(lineError).toHaveCount(0);
+    await expect(result).toHaveClass(/is-cached/);
+    await expect(result).toHaveText('7');
+    await expect(button).toContainText('Already probed');
+
+    await fillProbeArgs(page, 'n=7, n=8');
+    await expectArgError(page, 'line', 'Argument n given twice');
+    await expect(page.locator(probe.callShell)).toHaveClass(/has-error/);
+    await expect(button).toBeDisabled();
+
+    await fillProbeArgs(page, 'm=7');
+    await expectArgError(page, 'line', 'Unknown argument m');
+    await expect(button).toBeDisabled();
+
+    await fillProbeArgs(page, '7, 8');
+    await expectArgError(page, 'line', 'Too many arguments for clamp');
+    await expect(button).toBeDisabled();
+
+    // A clean line clears the line error
+    await fillProbeArgs(page, 'n=8');
+    await expect(lineError).toHaveCount(0);
+    await expect(button).toBeEnabled();
+
+    // Only the one positional probe reached the server, as {"n": 7}
+    expect(probePosts).toEqual([JSON.stringify({ input: { n: 7 } })]);
+  });
+
+  test('A14 Tab on an empty line fills in the argument names', async ({ page }) => {
+    await openAsFreshStudent(page, 'a14-tab-template', 7, 'tag');
+
+    const line = page.locator(probe.argsLine);
+    await expect(line).toHaveJSProperty('textContent', '');
+    await line.focus();
+    await page.keyboard.press('Tab');
+
+    await expect(line).toHaveJSProperty('textContent', 'items=, prefix=');
+    await expect(line).toBeFocused();
+    // The caret sits right after the first '=', collapsed
+    const caret = await line.evaluate((el) => {
+      const selection = window.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        return null;
+      }
+      const range = selection.getRangeAt(0);
+      const before = document.createRange();
+      before.selectNodeContents(el);
+      before.setEnd(range.startContainer, range.startOffset);
+      return {
+        inside: el.contains(range.startContainer),
+        collapsed: range.collapsed,
+        offset: before.toString().length,
+      };
+    });
+    expect(caret).toEqual({ inside: true, collapsed: true, offset: 'items='.length });
+
+    // Typing continues from the caret
+    await page.keyboard.type('["a", "b"]');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix=');
+    await page.keyboard.press('End');
+    await page.keyboard.type('"x"');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    // Shift+Enter inserts nothing: the call is one logical line
+    await page.keyboard.press('Shift+Enter');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    await expect(line).toBeFocused();
+
+    const responsePromise = page.waitForResponse((resp) => isProbePost(resp.request()));
+    await page.keyboard.press('Enter');
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+    expect(response.request().postData()).toBe(
+      JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } }),
+    );
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    // Enter probes; it never adds a line break
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    // Focus comes back to the line, so the next probe needs no Tab back
+    await expect(line).toBeFocused();
+    await expect(line).toHaveAttribute('contenteditable', 'plaintext-only');
+
+    // Tab on a non-empty line is ordinary focus navigation: it leaves the line
+    // and changes nothing, so the editable is never a keyboard trap
+    await page.keyboard.press('Tab');
+    await expect(line).not.toBeFocused();
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+  });
+
+  test('A15 the closing parenthesis trails the arguments', async ({ page }) => {
+    await openAsFreshStudent(page, 'a15-close-paren', 7, 'tag');
+
+    const words = Array.from({ length: 40 }, (_, i) => `"word${String(i).padStart(2, '0')}"`);
+    const args = `[${words.join(', ')}], "x"`;
+    await fillProbeArgs(page, args);
+    await expect(page.locator(probe.button)).toBeEnabled();
+
+    const line = page.locator(probe.argsLine);
+    const lineRects = await line.evaluate((el) =>
+      Array.from(el.getClientRects()).map((r) => ({
+        top: r.top,
+        bottom: r.bottom,
+        right: r.right,
+      })),
+    );
+    // The long argument list wraps over several lines
+    expect(lineRects.length).toBeGreaterThan(1);
+    const last = lineRects[lineRects.length - 1];
+
+    const paren = await page.locator(probe.closeParen).boundingBox();
+    expect(paren).not.toBeNull();
+    await expect(page.locator(probe.closeParen)).toHaveText(')');
+    // ')' sits on the editable's last line, right after its last character
+    const parenMiddle = paren!.y + paren!.height / 2;
+    expect(parenMiddle).toBeGreaterThan(last.top);
+    expect(parenMiddle).toBeLessThan(last.bottom);
+    expect(paren!.x).toBeGreaterThanOrEqual(last.right - 1);
+  });
+
+  test('A16 the backend rejects a list[str] with integers too', async ({ page }) => {
+    const user = await openAsFreshStudent(page, 'a16-backend-list', 7, 'tag');
+
+    const { status, data } = await apiAsUser(
+      page,
+      user,
+      'POST',
+      '/api/problems/e2e-probeable-list/probe/',
+      { input: { items: [1, 2], prefix: 'x' } },
+    );
+    expect(status).toBe(400);
+    expect(data.error).toBe("Parameter 'items' must be a list of str");
+  });
+
+  test('A17 a quoted str argument is a Python string literal', async ({ page }) => {
+    await openAsFreshStudent(page, 'a17-str-quotes', 7, 'tag');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+    const button = page.locator(probe.button);
+
+    // An unterminated quote is not a string: error, and Probe stays disabled
+    await fillProbeArgs(page, `['a'], "abc`);
+    await expectArgError(page, 'prefix', 'prefix: Not a valid Python value');
+    await expect(button).toBeDisabled();
+    await page.locator(probe.argsLine).press('Enter');
+
+    // An empty argument between commas is a line error, not a skipped parameter
+    await fillProbeArgs(page, `['a'],, 'x'`);
+    await expectArgError(page, 'line', 'Empty argument between commas');
+    await expect(button).toBeDisabled();
+
+    // Single quotes delimit the str exactly as double quotes do
+    const body = await probeWith(page, `['a', 'b'], 'x'`, 'enter');
+    expect(body.success).toBe(true);
+    expect(body.result).toEqual(['xa', 'xb']);
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    expect(probePosts).toEqual([JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } })]);
+  });
+
+  test('A18 on a narrow screen History wraps below the call line', async ({ page }) => {
+    await page.setViewportSize({ width: 320, height: 800 });
+    await openAsFreshStudent(page, 'a18-narrow', 7, 'tag');
+
+    await probeWith(page, '["a"], "x"');
+    await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
+
+    const row = await page.locator(probe.row).boundingBox();
+    const shell = await page.locator(probe.callShell).boundingBox();
+    const history = await page.locator(probe.historyButton).boundingBox();
+    expect(row && shell && history).toBeTruthy();
+    // The call line gets the full row width; History sits on a line of its own
+    expect(shell!.width).toBeGreaterThanOrEqual(row!.width - 1);
+    expect(history!.y).toBeGreaterThanOrEqual(shell!.y + shell!.height);
+  });
 });
diff --git a/e2e/student/probeable-spec.spec.ts b/e2e/student/probeable-spec.spec.ts
index 63d38e2..3d3f353 100644
--- a/e2e/student/probeable-spec.spec.ts
+++ b/e2e/student/probeable-spec.spec.ts
@@ -23,6 +23,7 @@
 import { test, expect, Page } from '@playwright/test';
 import { setAceEditorValue } from '../helpers/ace-editor';
 import { probe, feedback, problemSet } from '../helpers/selectors';
+import { fillProbeArgs } from '../helpers/probe';
 import {
   FreshUser,
   apiAsUser,
@@ -64,9 +65,9 @@ async function openSpecProblem(
   return user;
 }
 
-/** Probe square(x=value) and wait for the oracle response. */
+/** Probe square(value) through the call line and wait for the oracle response. */
 async function probeX(page: Page, value: string): Promise<void> {
-  await page.locator(probe.paramInput('x')).fill(value);
+  await fillProbeArgs(page, value);
   const button = page.locator(probe.button);
   await expect(button).toBeEnabled();
   const responsePromise = page.waitForResponse(
@@ -110,13 +111,13 @@ test.describe('C24 Probeable Spec', () => {
     await probeX(page, '-2');
     await expect(page.locator(probe.result)).toHaveText('4');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
-    // The input still holds the last probed value, so the button reports it
+    // The call line still holds the last probed value, so the button reports it
     // as already probed (no badge while duplicate).
     await expect(page.locator(probe.button)).toHaveText(/Already probed/);
     await expect(page.locator(probe.button)).toHaveClass(/is-duplicate/);
     await expect(page.locator(probe.button)).toBeDisabled();
     // A new value re-enables probing; explore mode keeps the badge unlimited.
-    await page.locator(probe.paramInput('x')).fill('7');
+    await fillProbeArgs(page, 'x=7');
     await expect(page.locator(probe.button)).toBeEnabled();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
     await expect(page.locator(probe.badge)).toHaveClass(/status-explore/);
diff --git a/e2e/student/submission-probeable.spec.ts b/e2e/student/submission-probeable.spec.ts
index ce3df4e..039363c 100644
--- a/e2e/student/submission-probeable.spec.ts
+++ b/e2e/student/submission-probeable.spec.ts
@@ -41,6 +41,7 @@ import { apiAs } from '../helpers/api';
 import { apiAsUser, enrollUser, freshStudent, injectUser, navigateAsFreshStudent } from '../helpers/users';
 import { submitCodeAndWait } from '../helpers/submission';
 import { codeFeedback, probe } from '../helpers/selectors';
+import { expectArgError, expectArgsEditable, fillProbeArgs } from '../helpers/probe';
 
 const PROBEABLE_PATH = '/courses/CS101-2024/problem-set/e2e-code?p=1';
 const TYPED_PROBEABLE_PATH = '/courses/CS101-2024/problem-set/e2e-code?p=2';
@@ -160,7 +161,6 @@ test.describe('Probeable Code Submission', () => {
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
     // e2e-probeable-code-1 has signature: mystery(lst: list[int]) -> list[int]
-    const lstInput = page.locator(probe.paramInput('lst'));
     const probeBtn = page.locator(probe.button);
     const probes: Array<[string, number[]]> = [
       ['[3, 1, 2]', [1, 2, 3]],
@@ -168,7 +168,7 @@ test.describe('Probeable Code Submission', () => {
     ];
 
     for (const [value, expected] of probes) {
-      await lstInput.fill(value);
+      await fillProbeArgs(page, value);
       await expect(probeBtn).toBeEnabled();
       const responsePromise = page.waitForResponse(
         (resp) =>
@@ -207,22 +207,22 @@ test.describe('Probe Input Type Validation', () => {
     await waitForProbeableInput(page);
 
     // e2e-probeable-code-typed has signature: double(n: int) -> int
-    const nInput = page.locator(probe.paramInput('n'));
-    await expect(nInput).toBeVisible();
-    await expect(nInput).toBeEnabled();
+    await expect(page.locator(probe.argsLine)).toBeVisible();
+    await expectArgsEditable(page, true);
 
     const fieldErrors = page.locator(probe.fieldErrors);
+    const callShell = page.locator(probe.callShell);
     const probeBtn = page.locator(probe.button);
 
-    await nInput.fill('abc');
+    await fillProbeArgs(page, 'abc');
     await expect(fieldErrors).toBeVisible();
-    await expect(page.locator(probe.fieldError('n'))).toHaveText('n: Must be a whole number (e.g. 5)');
-    await expect(nInput).toHaveClass(/has-error/);
+    await expectArgError(page, 'n', 'n: Must be a whole number (e.g. 5)');
+    await expect(callShell).toHaveClass(/has-error/);
     await expect(probeBtn).toBeDisabled();
 
-    await nInput.fill('5');
+    await fillProbeArgs(page, '5');
     await expect(fieldErrors).toBeHidden();
-    await expect(nInput).not.toHaveClass(/has-error/);
+    await expect(callShell).not.toHaveClass(/has-error/);
     await expect(probeBtn).toBeEnabled();
   });
 });
diff --git a/purplex/problems_app/management/commands/seed_e2e_data.py b/purplex/problems_app/management/commands/seed_e2e_data.py
index 8643061..4638e09 100644
--- a/purplex/problems_app/management/commands/seed_e2e_data.py
+++ b/purplex/problems_app/management/commands/seed_e2e_data.py
@@ -755,6 +755,7 @@ def handle(self, *args, **options):
         #   p=4  e2e-probeable-hidden     code, explore, hidden signature
         #   p=5  e2e-probeable-spec-open  spec, explore, no segmentation
         #   p=6  e2e-probeable-cooldown-2 code, cooldown 1 probe, +1 per 2 submits
+        #   p=7  e2e-probeable-list       code, explore, tag(items: list[str], prefix)
         #
         # These slugs are separate from the older probeable problems so their
         # defaults can be relied on (get_or_create ignores changed defaults).
@@ -1066,6 +1067,26 @@ def _seed_probeable_workflows(self, course, instructor, now):
                 },
                 [([1, 2], 3, True)],
             ),
+            (
+                # list[str] parameter: item types are validated on both sides.
+                ProbeableCodeProblem,
+                "e2e-probeable-list",
+                {
+                    "title": "E2E Probeable: List of Strings",
+                    "description": "Probe the function, then write it.",
+                    "function_signature": (
+                        "def tag(items: list[str], prefix: str) -> list[str]"
+                    ),
+                    "function_name": "tag",
+                    "reference_solution": (
+                        "def tag(items, prefix):\n"
+                        "    return [prefix + item for item in items]"
+                    ),
+                    "show_function_signature": True,
+                    "probe_mode": "explore",
+                },
+                [([["a", "b"], "x"], ["xa", "xb"], True)],
+            ),
         ]
 
         problem_set, created = ProblemSet.objects.get_or_create(