Integrate comprehensive testing framework with Makefile

- Added unit tests for YAML loading and parsing functionality
- Created integration tests for multiple activity files validation
- Implemented functional tests for complete activity workflows
- Added battleship pre_script functionality tests
- Integrated all test types into comprehensive Makefile
- Fixed CLI validator test with proper failing fixture
- Applied black formatting to all Python files
- Removed problematic hardcoded targets from Makefile
- Added proper venv dependency management

Test coverage includes:
- Unit: YAML loading, validator functionality
- Integration: Cross-file validation, metadata operations
- Functional: End-to-end activity flows, pre_script execution
- All 30 activity files validated and tested

tests/functional/test_battleship_pre_script.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Test that battleship pre_script functionality works with actual YAML files
+"""
+
+import unittest
+import os
+import sys
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add research directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "research"))
+import guarded_ai
+
+
+class TestBattleshipPreScript(unittest.TestCase):
+    """Test actual battleship YAML files with pre_script"""
+
+    def setUp(self):
+        """Set up test environment"""
+        self.mock_client = MagicMock()
+        self.mock_response = MagicMock()
+        self.mock_response.choices = [MagicMock()]
+        self.mock_response.choices[0].message.content = "Test response"
+        self.mock_client.chat.completions.create.return_value = self.mock_response
+
+    def test_battleship_yaml_has_pre_script(self):
+        """Test that battleship YAML loads and has pre_script"""
+        activity_file = (
+            "/home/fox/git/opencompletion/research/activity29-battleship.yaml"
+        )
+        activity = guarded_ai.load_yaml_activity(activity_file)
+
+        # Find step with pre_script
+        found_pre_script = False
+        pre_script_content = ""
+
+        for section in activity["sections"]:
+            for step in section["steps"]:
+                if "pre_script" in step:
+                    found_pre_script = True
+                    pre_script_content = step["pre_script"]
+
+                    # Should contain win detection logic
+                    self.assertIn("user_winning_move", pre_script_content)
+                    self.assertIn("ai_winning_move", pre_script_content)
+                    self.assertIn("is_game_ending_move", pre_script_content)
+                    self.assertIn("user_shot_input", pre_script_content)
+                    break
+
+            if found_pre_script:
+                break
+
+        self.assertTrue(found_pre_script, "Battleship YAML should have pre_script")
+
+    def test_battleship_pre_script_execution_simulation(self):
+        """Test simulated battleship pre_script execution"""
+        activity_file = (
+            "/home/fox/git/opencompletion/research/activity29-battleship.yaml"
+        )
+        activity = guarded_ai.load_yaml_activity(activity_file)
+
+        # Find the step with pre_script (step_2)
+        step_with_pre_script = None
+        for section in activity["sections"]:
+            for step in section["steps"]:
+                if step.get("step_id") == "step_2" and "pre_script" in step:
+                    step_with_pre_script = step
+                    break
+
+        self.assertIsNotNone(step_with_pre_script, "Should find step_2 with pre_script")
+
+        # Test pre_script logic manually
+        pre_script = step_with_pre_script["pre_script"]
+
+        # Simulate metadata with winning move setup
+        test_metadata = {
+            "user_winning_move": 42,
+            "ai_winning_move": 73,
+            "user_response": "42",  # User enters winning move
+        }
+
+        # Execute the pre_script
+        result = guarded_ai.execute_processing_script(test_metadata, pre_script)
+
+        # Should detect winning move
+        self.assertTrue(result.get("metadata", {}).get("is_game_ending_move", False))
+
+        # Test with non-winning move
+        test_metadata["user_response"] = "25"
+        result = guarded_ai.execute_processing_script(test_metadata, pre_script)
+
+        # Should NOT detect winning move
+        self.assertFalse(result.get("metadata", {}).get("is_game_ending_move", False))
+
+    def test_testship_yaml_has_pre_script(self):
+        """Test that testship YAML also has pre_script"""
+        activity_file = "/home/fox/git/opencompletion/research/activity29-testship.yaml"
+        activity = guarded_ai.load_yaml_activity(activity_file)
+
+        # Should also have pre_script (same structure as battleship)
+        found_pre_script = False
+
+        for section in activity["sections"]:
+            for step in section["steps"]:
+                if "pre_script" in step:
+                    found_pre_script = True
+                    break
+
+        self.assertTrue(found_pre_script, "Testship YAML should have pre_script")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)