fix: resolve formatting inconsistencies between make format and pre-commit

- Update ruff version in pre-commit-config.yaml to v0.11.13 to match local ruff
- Fix version mismatch that caused disagreement between make format and pre-commit
- Standardize assert formatting throughout test_architectural_constraints.py
- Both commands now run without making any formatting changes

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

Co-Authored-By: Claude <[email protected]>

Author: thompsonson

.pre-commit-config.yaml

@@ -10,7 +10,7 @@ repos:
       - id: debug-statements
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.9
+    rev: v0.11.13
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

tests/test_architectural_constraints.py

@@ -25,29 +25,31 @@ def test_belief_update_dataclass_structure(self):
         fields = BeliefUpdate.__dataclass_fields__
 
         # Should only contain comparison_result
-        assert (
-            len(fields) == 1
-        ), f"BeliefUpdate should have exactly 1 field, got {len(fields)}: {list(fields.keys())}"
-        assert (
-            "comparison_result" in fields
-        ), "BeliefUpdate must contain comparison_result field"
-        assert (
-            "dice_roll" not in fields
-        ), "BeliefUpdate MUST NOT contain dice_roll field"
+        assert len(fields) == 1, (
+            f"BeliefUpdate should have exactly 1 field, got {len(fields)}: "
+            f"{list(fields.keys())}"
+        )
+        assert "comparison_result" in fields, (
+            "BeliefUpdate must contain comparison_result field"
+        )
+        assert "dice_roll" not in fields, (
+            "BeliefUpdate MUST NOT contain dice_roll field"
+        )
 
     def test_environment_evidence_dataclass_structure(self):
         """Test that EnvironmentEvidence contains both dice_roll and comparison_result."""
         # Get all fields of EnvironmentEvidence
         fields = EnvironmentEvidence.__dataclass_fields__
 
         # Should contain both fields
-        assert (
-            len(fields) == 2
-        ), f"EnvironmentEvidence should have exactly 2 fields, got {len(fields)}: {list(fields.keys())}"
+        assert len(fields) == 2, (
+            f"EnvironmentEvidence should have exactly 2 fields, got {len(fields)}: "
+            f"{list(fields.keys())}"
+        )
         assert "dice_roll" in fields, "EnvironmentEvidence must contain dice_roll field"
-        assert (
-            "comparison_result" in fields
-        ), "EnvironmentEvidence must contain comparison_result field"
+        assert "comparison_result" in fields, (
+            "EnvironmentEvidence must contain comparison_result field"
+        )
 
     def test_belief_state_methods_no_dice_roll_parameters(self):
         """Test that BayesianBeliefState methods don't accept dice_roll parameters."""
@@ -61,9 +63,9 @@ def test_belief_state_methods_no_dice_roll_parameters(self):
             signature = inspect.signature(method)
             param_names = list(signature.parameters.keys())
 
-            assert (
-                "dice_roll" not in param_names
-            ), f"Method {method_name} MUST NOT have dice_roll parameter"
+            assert "dice_roll" not in param_names, (
+                f"Method {method_name} MUST NOT have dice_roll parameter"
+            )
 
     def test_belief_update_creation_without_dice_roll(self):
         """Test that BeliefUpdate can be created without dice_roll."""
@@ -98,12 +100,12 @@ def test_information_filtering_in_coordination(self):
 
         # Verify that evidence history in belief domain contains only comparison results
         for evidence in game.belief_state.evidence_history:
-            assert hasattr(
-                evidence, "comparison_result"
-            ), "Belief evidence must have comparison_result"
-            assert not hasattr(
-                evidence, "dice_roll"
-            ), "Belief evidence MUST NOT have dice_roll"
+            assert hasattr(evidence, "comparison_result"), (
+                "Belief evidence must have comparison_result"
+            )
+            assert not hasattr(evidence, "dice_roll"), (
+                "Belief evidence MUST NOT have dice_roll"
+            )
 
     def test_domain_import_isolation(self):
         """Test that belief domain doesn't import environment domain."""
@@ -113,12 +115,12 @@ def test_domain_import_isolation(self):
         belief_source = inspect.getsource(belief_module)
 
         # Should not import environment domain
-        assert (
-            "from domains.environment" not in belief_source
-        ), "Belief domain MUST NOT import environment domain"
-        assert (
-            "import domains.environment" not in belief_source
-        ), "Belief domain MUST NOT import environment domain"
+        assert "from domains.environment" not in belief_source, (
+            "Belief domain MUST NOT import environment domain"
+        )
+        assert "import domains.environment" not in belief_source, (
+            "Belief domain MUST NOT import environment domain"
+        )
 
     def test_proper_bayesian_calculation_structure(self):
         """Test that belief updates use probabilistic calculations."""
@@ -135,9 +137,9 @@ def test_proper_bayesian_calculation_structure(self):
         prob_6 = belief_state.get_belief_for_target(6)
 
         assert prob_1 > prob_6, "Higher evidence should favor lower targets"
-        assert (
-            abs(prob_6 - 0.0) < 1e-10
-        ), "Target 6 should have zero probability after 'higher' evidence"
+        assert abs(prob_6 - 0.0) < 1e-10, (
+            "Target 6 should have zero probability after 'higher' evidence"
+        )
 
     def test_coordination_layer_responsibility(self):
         """Test that coordination layer properly orchestrates without leaking information."""
@@ -148,21 +150,21 @@ def test_coordination_layer_responsibility(self):
         state = game.play_round()
 
         # Game state should have full information (for display)
-        assert hasattr(
-            state.evidence_history[0], "dice_roll"
-        ), "Game state should maintain full evidence for display"
-        assert hasattr(
-            state.evidence_history[0], "comparison_result"
-        ), "Game state should maintain comparison results"
+        assert hasattr(state.evidence_history[0], "dice_roll"), (
+            "Game state should maintain full evidence for display"
+        )
+        assert hasattr(state.evidence_history[0], "comparison_result"), (
+            "Game state should maintain comparison results"
+        )
 
         # But belief state should only have comparison results
         belief_evidence = game.belief_state.evidence_history[0]
-        assert hasattr(
-            belief_evidence, "comparison_result"
-        ), "Belief evidence must have comparison_result"
-        assert not hasattr(
-            belief_evidence, "dice_roll"
-        ), "Belief evidence MUST NOT have dice_roll"
+        assert hasattr(belief_evidence, "comparison_result"), (
+            "Belief evidence must have comparison_result"
+        )
+        assert not hasattr(belief_evidence, "dice_roll"), (
+            "Belief evidence MUST NOT have dice_roll"
+        )
 
     def test_no_hard_coded_probabilities(self):
         """Test that belief calculations are dynamic, not hard-coded."""
@@ -181,10 +183,10 @@ def test_no_hard_coded_probabilities(self):
 
             # Target 1 should have highest probability for "higher" evidence
 
-            assert (
-                prob_1 > prob_last
-            ), f"Target 1 should be more likely than target {dice_sides}"
-            assert (
-                abs(prob_last - 0.0) < 1e-10
-            ), f"Target {dice_sides} should have zero probability"
+            assert prob_1 > prob_last, (
+                f"Target 1 should be more likely than target {dice_sides}"
+            )
+            assert abs(prob_last - 0.0) < 1e-10, (
+                f"Target {dice_sides} should have zero probability"
+            )
             assert prob_1 > 0, "Target 1 should have non-zero probability"