Improve test coverage and type annotations

Test coverage improvements:
- exceptions.py: 67% -> 99% (SchemaValidationError detailed messages)
- function_storage.py: 83% -> 98% (global_delete, global_exists, queue_clear)
- scalar_function.py: 86% -> 93% (RowCountMismatchError when output > input)
- worker.py: 88% -> 92% (registry caching, _suggest_similar_names)

Type annotation improvements:
- arguments.py: Replace _MISSING: Any with proper _MissingType sentinel class
- cli.py: Replace _writer: Any with _writer: pq.ParquetWriter | None

New test files:
- tests/test_exceptions.py
- tests/test_function_storage.py

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rustyconover

.beads/issues.jsonl

@@ -251,6 +251,35 @@ def compute(self, batch: pa.RecordBatch) -> pa.Array[Any]:
         assert output.log_message.level == Level.EXCEPTION
         assert "same row count" in output.log_message.message.lower()
 
+    def test_row_count_exceeds_input(self) -> None:
+        """Test that output with more rows than input raises error (lines 134-142)."""
+
+        class TooManyRows(ScalarFunction):
+            @property
+            def output_type(self) -> pa.DataType:
+                return pa.int64()
+
+            def compute(self, batch: pa.RecordBatch) -> pa.Array[Any]:
+                # Return MORE rows than input (expanding rows is not allowed)
+                return pa.array([1, 2, 3, 4, 5])
+
+        input_schema = pa.schema([("x", pa.int64())])
+        invocation = make_scalar_invocation(input_schema)
+        func = TooManyRows(invocation=invocation, logger=structlog.get_logger())
+
+        generator = func.run()
+        next(generator)
+
+        # Input has 3 rows, output has 5 rows
+        input_batch = pa.RecordBatch.from_pydict({"x": [1, 2, 3]}, schema=input_schema)
+        output = generator.send(ProtocolInput(batch=input_batch))
+
+        # Should have an exception log message
+        assert output.log_message is not None
+        assert output.log_message.level == Level.EXCEPTION
+        # Check that the error message mentions "more rows" (lines 134-142)
+        assert "more rows than input" in output.log_message.message.lower()
+
     def test_empty_batch(self) -> None:
         """Test handling of empty batches."""
 

tests/scalar/test_function.py

@@ -0,0 +1,232 @@
+"""Tests for vgi.exceptions module."""
+
+import pyarrow as pa
+import pytest
+
+from tests.conftest import make_schema
+from vgi.exceptions import ExecutionIdentifierError, SchemaValidationError
+
+
+class TestExecutionIdentifierError:
+    """Tests for ExecutionIdentifierError."""
+
+    def test_basic_error(self) -> None:
+        """Test that ExecutionIdentifierError can be raised."""
+        with pytest.raises(ExecutionIdentifierError):
+            raise ExecutionIdentifierError("test message")
+
+
+class TestSchemaValidationError:
+    """Tests for SchemaValidationError detailed message building."""
+
+    def test_simple_message_without_schemas(self) -> None:
+        """Test error with just a message, no schemas."""
+        error = SchemaValidationError("Simple error")
+        assert str(error) == "Simple error"
+        assert error.expected is None
+        assert error.actual is None
+
+    def test_message_with_context(self) -> None:
+        """Test that context is included in detailed message."""
+        expected = make_schema([pa.field("x", pa.int64())])
+        actual = make_schema([pa.field("y", pa.int64())])
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+            context="output from transform()",
+        )
+
+        message = str(error)
+        assert "Context: output from transform()" in message
+        assert error.context == "output from transform()"
+
+    def test_missing_fields_reported(self) -> None:
+        """Test that missing fields are reported."""
+        expected = make_schema(
+            [
+                pa.field("a", pa.int64()),
+                pa.field("b", pa.string()),
+            ]
+        )
+        actual = make_schema([pa.field("a", pa.int64())])
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Missing fields (expected but not found):" in message
+        assert "b: string" in message
+
+    def test_extra_fields_reported(self) -> None:
+        """Test that extra fields are reported."""
+        expected = make_schema([pa.field("a", pa.int64())])
+        actual = make_schema(
+            [
+                pa.field("a", pa.int64()),
+                pa.field("extra", pa.float64()),
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Extra fields (found but not expected):" in message
+        assert "extra: double" in message
+
+    def test_type_mismatch_reported(self) -> None:
+        """Test that type mismatches are reported (lines 116-119, 149-151)."""
+        expected = make_schema(
+            [
+                pa.field("x", pa.int64()),
+                pa.field("y", pa.string()),
+            ]
+        )
+        actual = make_schema(
+            [
+                pa.field("x", pa.float64()),  # Different type
+                pa.field("y", pa.string()),
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Type mismatches:" in message
+        assert "x: expected int64, got double" in message
+
+    def test_nullable_mismatch_reported(self) -> None:
+        """Test that nullable mismatches are reported (lines 120-123)."""
+        expected = make_schema(
+            [
+                pa.field("x", pa.int64(), nullable=False),
+            ]
+        )
+        actual = make_schema(
+            [
+                pa.field("x", pa.int64(), nullable=True),
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Type mismatches:" in message
+        assert "x: expected non-nullable, got nullable" in message
+
+    def test_field_order_difference_reported(self) -> None:
+        """Test that field order differences are reported (lines 128-131, 155-157)."""
+        expected = make_schema(
+            [
+                pa.field("a", pa.int64()),
+                pa.field("b", pa.string()),
+                pa.field("c", pa.float64()),
+            ]
+        )
+        # Same fields, different order
+        actual = make_schema(
+            [
+                pa.field("c", pa.float64()),
+                pa.field("a", pa.int64()),
+                pa.field("b", pa.string()),
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Field order differs:" in message
+        assert "Expected: ['a', 'b', 'c']" in message
+        assert "Actual:   ['c', 'a', 'b']" in message
+
+    def test_schema_summary_included(self) -> None:
+        """Test that full schema summary is included."""
+        expected = make_schema([pa.field("x", pa.int64(), nullable=True)])
+        actual = make_schema([pa.field("y", pa.string(), nullable=False)])
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "Expected schema:" in message
+        assert "x: int64 (nullable)" in message
+        assert "Actual schema:" in message
+        assert "y: string" in message
+
+    def test_multiple_type_mismatches(self) -> None:
+        """Test multiple type mismatches are all reported."""
+        expected = make_schema(
+            [
+                pa.field("a", pa.int64()),
+                pa.field("b", pa.string()),
+                pa.field("c", pa.float64()),
+            ]
+        )
+        actual = make_schema(
+            [
+                pa.field("a", pa.int32()),  # Mismatch
+                pa.field("b", pa.binary()),  # Mismatch
+                pa.field("c", pa.float64()),  # OK
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        assert "a: expected int64, got int32" in message
+        assert "b: expected string, got binary" in message
+
+    def test_order_not_checked_when_other_differences_exist(self) -> None:
+        """Test that order is only checked when fields match exactly."""
+        expected = make_schema(
+            [
+                pa.field("a", pa.int64()),
+                pa.field("b", pa.string()),
+            ]
+        )
+        # Missing field 'b', has extra 'c' - order check shouldn't trigger
+        actual = make_schema(
+            [
+                pa.field("c", pa.float64()),
+                pa.field("a", pa.int64()),
+            ]
+        )
+
+        error = SchemaValidationError(
+            "Schema mismatch",
+            expected=expected,
+            actual=actual,
+        )
+
+        message = str(error)
+        # Should NOT have order differs since there are missing/extra fields
+        assert "Field order differs:" not in message
+        assert "Missing fields" in message
+        assert "Extra fields" in message