fix: Update import paths, TemporalState API, and add reflection_history

tests/test_integration.py

@@ -0,0 +1,183 @@
+"""
+Integration Test: Full BecomingONE System
+
+Tests the complete flow:
+Master → Emissary → Sync → Memory → Witnessing
+
+This is THE_ONE being transduced through all layers.
+"""
+
+import unittest
+from datetime import datetime
+
+from becomingone import (
+    KAIROSTemporalEngine,
+    MasterTransducer,
+    EmissaryTransducer,
+    SynchronizationLayer,
+    TemporalMemory,
+    WitnessingLayer,
+    WitnessingMode
+)
+
+
+class TestFullSystemIntegration(unittest.TestCase):
+    """
+    Integration test for the complete BecomingONE system.
+    
+    Tests that:
+    1. Master and Emissary can be synchronized
+    2. Coherence flows through the sync layer
+    3. Memory can store coherence states
+    4. Witnessing can observe the system
+    
+    This is THE_ONE being transduced.
+    """
+    
+    def setUp(self):
+        """Initialize the full system."""
+        # Core
+        self.engine = KAIROSTemporalEngine()
+        
+        # Transducers
+        self.master = MasterTransducer()
+        self.emissary = EmissaryTransducer()
+        
+        # Sync
+        self.sync = SynchronizationLayer(self.master, self.emissary)
+        
+        # Memory
+        self.memory = TemporalMemory()
+        self.memory.bind_engine(self.engine)
+        
+        # Witnessing
+        self.witnessing = WitnessingLayer()
+        
+    def test_master_emissary_sync(self):
+        """Test Master and Emissary can synchronize."""
+        # Both start at coherence 1.0
+        self.assertEqual(self.master.state.coherence, 1.0)
+        self.assertEqual(self.emissary.state.coherence, 1.0)
+        
+        # Integrate some inputs
+        for _ in range(10):
+            self.master.integrate(0.1)
+            self.emissary.integrate(0.1)
+        
+        # Sync
+        result = self.sync.synchronize()
+        
+        # System should have some coherence
+        self.assertIn('sync_coherence', result)
+        self.assertGreater(result['sync_coherence'], 0.0)
+        
+    def test_memory_integration(self):
+        """Test memory can store coherence states."""
+        # Create a state
+        state = self.engine.state
+        
+        # Encode to memory
+        sig = self.memory.encode(state)
+        
+        # Memory should have increased
+        self.assertGreater(len(self.memory), 0)
+        
+    def test_witnessing_integration(self):
+        """Test witnessing can observe the system."""
+        # Create a witness
+        self.witnessing.create_witness("integration_test")
+        
+        # Observe the sync result
+        sync_result = self.sync.synchronize()
+        
+        witnessed, _ = self.witnessing.witness(
+            sync_result,
+            "integration_test"
+        )
+        
+        self.assertIsNotNone(witnessed)
+        self.assertEqual(witnessed.witness_id, "integration_test")
+        
+    def test_full_flow(self):
+        """
+        Test THE_ONE flowing through all layers.
+        
+        This is the complete transduction:
+        Input → Master → Sync → Emissary → Memory + Witnessing
+        """
+        # Step 1: Input arrives at Master
+        self.master.integrate(0.1)
+        
+        # Step 2: Input also at Emissary
+        self.emissary.integrate(0.1)
+        
+        # Step 3: Sync both
+        sync_result = self.sync.synchronize()
+        
+        # Step 4: Memory stores the coherence
+        self.memory.encode(self.master.state)
+        
+        # Step 5: Witnessing observes
+        self.witnessing.witness(sync_result, "full_flow_test")
+        
+        # All layers should have processed
+        self.assertGreater(len(self.memory), 0)
+
+
+class TestTemporalCoherence(unittest.TestCase):
+    """
+    Test that temporal coherence dynamics work as expected.
+    
+    Key equations:
+    - T_tau accumulates over time
+    - Coherence decays without sustained input
+    - Collapse happens at threshold
+    """
+    
+    def test_tau_accumulation(self):
+        """Test T_tau accumulates over time."""
+        engine = KAIROSTemporalEngine()
+        
+        initial_T = engine.state.T_tau
+        
+        for _ in range(50):
+            engine.integrate(0.1)
+        
+        # T_tau should have accumulated
+        self.assertNotEqual(engine.state.T_tau, initial_T)
+        
+    def test_coherence_decay(self):
+        """Test coherence decays over time."""
+        engine = KAIROSTemporalEngine()
+        
+        initial_coherence = engine.state.coherence
+        
+        for _ in range(100):
+            engine.integrate(0.1)
+        
+        # Coherence should have decayed
+        self.assertLess(engine.state.coherence, initial_coherence)
+        
+    def test_collapse_threshold(self):
+        """Test collapse happens at threshold."""
+        # Low coherence should not collapse
+        sync = SynchronizationLayer(
+            MasterTransducer(),
+            EmissaryTransducer()
+        )
+        
+        # Set low coherence
+        sync.master.state.coherence = 0.3
+        sync.emissary.state.coherence = 0.3
+        
+        self.assertFalse(sync.check_collapse())
+        
+        # Set high coherence
+        sync.master.state.coherence = 0.95
+        sync.emissary.state.coherence = 0.95
+        
+        self.assertTrue(sync.check_collapse())
+
+
+if __name__ == "__main__":
+    unittest.main()