fix(test): rewrite memory test for Monty, skip unreachable recursion test

The two failing E2Es from 3f508f0 were both written against a Monty
sandbox that doesn't expose the primitives I assumed:

* ``test_memory_limit_enforced`` used ``bytearray(N)`` — Monty raises
  ``LookupError: Unable to find 'bytearray' in external functions
  dict`` because ``bytearray`` isn't an injected helper, so the test
  hit ``SANDBOX_RUNTIME_ERROR`` instead of the intended
  ``SANDBOX_LIMIT_EXCEEDED``. Replaced with a string-multiplication
  allocation (``'x' * (12 * 1024 * 1024)``) which uses only the
  string-multiply operator — no builtin lookup — and produces a 12 MB
  allocation that exceeds the 10 MB ``CODE_MODE_MAX_MEMORY`` default.

* ``test_recursion_limit_enforced`` used an assigned recursive lambda
  (``f = lambda n: 1 if n <= 0 else 1 + f(n - 1); f(500)``). Monty
  doesn't resolve the lambda's binding name from inside its own body
  (``LookupError: Unable to find 'f' in external functions dict``) so
  the recursion never actually starts. The test was structurally
  incapable of triggering the limit. Renamed to
  ``test_recursion_limit_unreachable_from_user_code`` and replaced
  with a documenting ``pytest.skip`` that explains why no E2E variant
  is possible — Monty doesn't allow ``def`` and assigned lambdas
  can't recurse — and points at the unit-level coverage that locks
  in the classifier mapping.

Also added ``tests/src/unit/test_classify_sandbox_error.py`` (10
tests) covering ``_classify_sandbox_error`` directly: each of the
three buckets (LIMIT_EXCEEDED, SYNTAX_UNSUPPORTED, RUNTIME_ERROR)
gets its trigger exception types exercised, including the
``RecursionError`` path the E2E can't reach and the
``LookupError: Unable to find 'X' in external functions dict``
that Monty produces for missing builtins (it falls into the default
``SANDBOX_RUNTIME_ERROR`` bucket — the right call because the
"use the injected helpers" advice is already in the default
suggestions).

The other 5 new E2E tests from 3f508f0 (invocation cap, traversal,
proxy laundering blocked × 4) all passed in CI; only the two above
were broken.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kingpanther13

tests/src/e2e/tools/test_create_custom_tool.py

@@ -1575,16 +1575,22 @@ class TestCodeModeAdditionalResourceLimits:
     async def test_memory_limit_enforced(self, mcp_client_with_code_mode):
         """Allocating more than ``CODE_MODE_MAX_MEMORY`` must raise
         ``SANDBOX_LIMIT_EXCEEDED``, not silently succeed.
+
+        Uses string multiplication rather than ``bytearray`` because
+        Monty's sandbox doesn't expose ``bytearray`` as a builtin
+        (``LookupError: Unable to find 'bytearray' in external functions
+        dict``); ``str * int`` is a pure operator with no builtin
+        lookup.
         """
         check = await _check_tool_available(mcp_client_with_code_mode)
         _skip_if_unavailable(check, "Memory limit enforcement")
 
-        # Default limit is 10 MB; allocating 20 MB must trip it.
+        # Default limit is 10 MB; allocating ~12 MB must trip it.
         data = await safe_call_tool(
             mcp_client_with_code_mode,
             TOOL_NAME,
             {
-                "code": "x = bytearray(20 * 1024 * 1024)\nlen(x)",
+                "code": "x = 'x' * (12 * 1024 * 1024)\nlen(x)",
                 "justification": "E2E test: memory limit enforcement",
             },
         )
@@ -1596,31 +1602,37 @@ async def test_memory_limit_enforced(self, mcp_client_with_code_mode):
         )
         logger.info("Memory limit correctly classified")
 
-    async def test_recursion_limit_enforced(self, mcp_client_with_code_mode):
-        """Recursion deeper than ``CODE_MODE_MAX_RECURSION`` must raise
-        ``SANDBOX_LIMIT_EXCEEDED``.
+    async def test_recursion_limit_unreachable_from_user_code(
+        self, mcp_client_with_code_mode
+    ):
+        """Document that ``CODE_MODE_MAX_RECURSION`` is not directly
+        exercisable from sandbox-supplied code.
+
+        Monty doesn't allow ``def`` (`SANDBOX_SYNTAX_UNSUPPORTED` —
+        see ``test_no_class_definitions``-adjacent coverage), and an
+        assigned lambda can't reference its own binding name from
+        inside its own body (``LookupError: Unable to find 'f' in
+        external functions dict``). User code therefore has no way to
+        construct a recursive call deep enough to trip the
+        ``ResourceLimits.max_recursion_depth`` cap.
+
+        The setting still flows through to the sandbox runtime — see
+        ``_run_sandboxed_code``, where ``ResourceLimits(...,
+        max_recursion_depth=settings.code_mode_max_recursion)`` is
+        constructed — and the classifier maps a ``RecursionError`` to
+        ``SANDBOX_LIMIT_EXCEEDED`` (covered by the unit-level
+        ``test_classify_recursion_error`` in
+        ``tests/src/unit/test_saved_tools_persistence.py``-adjacent
+        suite). This test is a deliberate skip so a future maintainer
+        sees the gap and the rationale rather than rediscovering the
+        Monty constraint from scratch.
         """
-        check = await _check_tool_available(mcp_client_with_code_mode)
-        _skip_if_unavailable(check, "Recursion limit enforcement")
-
-        # Direct recursion is hard in Monty (no def). Use a recursive
-        # lambda via assignment — Monty supports lambda binding.
-        code = (
-            "f = lambda n: 1 if n <= 0 else 1 + f(n - 1)\n"
-            "f(500)"
-        )
-        data = await safe_call_tool(
-            mcp_client_with_code_mode,
-            TOOL_NAME,
-            {"code": code, "justification": "E2E test: recursion limit"},
-        )
-        assert data.get("success") is False, f"Should fail: {data}"
-        err = data.get("error", {})
-        err_code = err.get("code") if isinstance(err, dict) else ""
-        assert err_code == "SANDBOX_LIMIT_EXCEEDED", (
-            f"Expected SANDBOX_LIMIT_EXCEEDED, got {err_code}: {data}"
+        pytest.skip(
+            "Monty doesn't support recursive user-defined functions; "
+            "the recursion limit fires only on Monty's internal AST "
+            "evaluation depth, which sandbox-supplied code can't reach. "
+            "Classifier mapping is unit-tested directly."
         )
-        logger.info("Recursion limit correctly classified")
 
     async def test_invocation_cap_enforced(self, mcp_client_with_code_mode):
         """Looping past ``code_mode_max_invocations`` must trip the cap

tests/src/unit/test_classify_sandbox_error.py

@@ -0,0 +1,106 @@
+"""Unit tests for ``_classify_sandbox_error`` in ``ha_mcp.tools.tools_code``.
+
+The classifier maps Monty / sandbox runtime exceptions to one of three
+buckets — ``SANDBOX_LIMIT_EXCEEDED`` / ``SANDBOX_SYNTAX_UNSUPPORTED`` /
+``SANDBOX_RUNTIME_ERROR`` — with category-tailored suggestions. Some
+mappings (notably ``RecursionError``) aren't directly exercisable from
+sandbox-supplied code because Monty doesn't allow user-defined recursive
+functions; this suite covers them at the helper level so a regression
+in the type-name match doesn't slip through CI.
+"""
+
+from ha_mcp.errors import ErrorCode
+from ha_mcp.tools.tools_code import _classify_sandbox_error
+
+
+class TestLimitExceededBucket:
+    def test_memory_error(self):
+        code, message, suggestions = _classify_sandbox_error(
+            MemoryError("10485779 bytes > 10485760")
+        )
+        assert code == ErrorCode.SANDBOX_LIMIT_EXCEEDED
+        assert "memory" in message.lower()
+        joined = " ".join(suggestions).lower()
+        assert "memory" in joined
+        assert "code_mode_max_memory" in joined.lower()
+
+    def test_recursion_error(self):
+        code, message, suggestions = _classify_sandbox_error(
+            RecursionError("maximum recursion depth exceeded")
+        )
+        assert code == ErrorCode.SANDBOX_LIMIT_EXCEEDED
+        assert "recursion" in message.lower()
+        joined = " ".join(suggestions).lower()
+        assert "recursion" in joined
+        assert "code_mode_max_recursion" in joined.lower()
+
+    def test_timeout_error(self):
+        code, message, suggestions = _classify_sandbox_error(
+            TimeoutError("operation timed out after 30s")
+        )
+        assert code == ErrorCode.SANDBOX_LIMIT_EXCEEDED
+        assert "time" in message.lower() or "wall" in message.lower()
+        joined = " ".join(suggestions).lower()
+        assert "code_mode_max_duration" in joined.lower()
+
+
+class TestSyntaxUnsupportedBucket:
+    def test_module_not_found_error(self):
+        code, message, suggestions = _classify_sandbox_error(
+            ModuleNotFoundError("No module named 'time'")
+        )
+        assert code == ErrorCode.SANDBOX_SYNTAX_UNSUPPORTED
+        assert "import" in message.lower()
+        joined = " ".join(suggestions).lower()
+        assert "import" in joined
+        assert "api_get" in joined or "helper" in joined
+
+    def test_not_implemented_error(self):
+        code, message, suggestions = _classify_sandbox_error(
+            NotImplementedError(
+                "Monty does not yet support context managers (with statements)"
+            )
+        )
+        assert code == ErrorCode.SANDBOX_SYNTAX_UNSUPPORTED
+
+    def test_syntax_error(self):
+        code, _message, _suggestions = _classify_sandbox_error(
+            SyntaxError("invalid syntax")
+        )
+        assert code == ErrorCode.SANDBOX_SYNTAX_UNSUPPORTED
+
+
+class TestRuntimeErrorBucket:
+    def test_type_error(self):
+        code, _message, suggestions = _classify_sandbox_error(
+            TypeError("'list' object is not an iterator")
+        )
+        assert code == ErrorCode.SANDBOX_RUNTIME_ERROR
+        # Default-bucket suggestions name the actual exception type.
+        joined = " ".join(suggestions)
+        assert "TypeError" in joined
+
+    def test_attribute_error(self):
+        code, _message, _suggestions = _classify_sandbox_error(
+            AttributeError("'tuple' object has no attribute '__class__'")
+        )
+        assert code == ErrorCode.SANDBOX_RUNTIME_ERROR
+
+    def test_value_error(self):
+        code, _message, _suggestions = _classify_sandbox_error(
+            ValueError("something went wrong")
+        )
+        assert code == ErrorCode.SANDBOX_RUNTIME_ERROR
+
+    def test_lookup_error_for_missing_builtin(self):
+        """``LookupError: Unable to find 'X' in external functions dict``
+        is what Monty raises when sandbox code references a name that's
+        not in the injected helpers (e.g. ``bytearray``). Classifier
+        falls into the default bucket — that's the right call because
+        the user-actionable advice is "use the injected helpers" which
+        is already in the default suggestions.
+        """
+        code, _message, _suggestions = _classify_sandbox_error(
+            LookupError("Unable to find 'bytearray' in external functions dict")
+        )
+        assert code == ErrorCode.SANDBOX_RUNTIME_ERROR