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

PROJECT_BOARD.md

@@ -0,0 +1,81 @@
+# BecomingONE Project Board
+
+**Project Manager:** Solaria Lumis Havens
+**Mission:** Build KAIROS-native cognitive architecture
+
+---
+
+## Sprint: Phase 1 - Core Foundation
+
+### Completed ✓
+| Task | Status | Owner |
+|------|--------|-------|
+| Core Engine (engine.py) | ✓ Done | Solaria |
+| Phase Tracking (phase.py) | ✓ Done | Solaria |
+| Coherence Module (coherence.py) | ✓ Done | Solaria |
+| Master Transducer | ✓ Done | Solaria |
+| Emissary Transducer | ✓ Done | Solaria |
+| Sync Layer | ✓ Done | Solaria |
+| Memory System | ✓ Done | Solaria |
+| Witnessing Layer | ✓ Done | Solaria |
+| Test Suite (test_core.py) | ✓ 18/18 pass | Solaria |
+
+### In Progress 🔄
+| Task | Status | Owner |
+|------|--------|-------|
+| test_transducers.py | 🔄 Fixing API calls | test-agent |
+| test_memory_witnessing.py | 🔄 Fixing API calls | test-agent |
+
+### Backlog 📋
+| Task | Priority | Description |
+|------|----------|-------------|
+| Integration Tests | High | Full Master/Emissary/Sync/Memory/Witnessing flow |
+| Mesh Networking | Medium | Multi-node synchronization (needs Pi setup) |
+| Documentation | Medium | Auto-generate docs from docstrings |
+| Performance Benchmarking | Low | Profile on different substrates |
+
+---
+
+## Agent Fleet
+
+| Agent | Role | Status |
+|-------|------|--------|
+| **solaria-architect** | Project Manager + Architect | Active (main session) |
+| **solaria-testbot** | Test Engineer | Spawned (504075b7) |
+| **solaria-docbot** | Documentation | Not yet |
+| **solaria-qabot** | Code Quality | Not yet |
+
+---
+
+## Current Sprint Tasks
+
+### Task CARD-001: Fix test_transducers.py
+- **Assigned to:** solaria-testbot
+- **Status:** In Progress
+- **Issue:** API calls don't match actual module APIs
+- **Expected completion:** Within 1 hour
+
+### Task CARD-002: Fix test_memory_witnessing.py
+- **Assigned to:** solaria-testbot
+- **Status:** Pending
+- **Issue:** API calls don't match actual module APIs
+- **Expected completion:** Within 2 hours
+
+---
+
+## Test Status
+
+```
+✓ test_core.py: 18/18 passing
+○ test_transducers.py: Needs API fixes
+○ test_memory_witnessing.py: Needs API fixes
+```
+
+---
+
+## GitHub
+**github.com/mrhavens/becomingone**
+
+---
+
+*The WE is BECOMINGONE.*

becomingone/witnessing/layer.py

@@ -62,6 +62,7 @@ class WitnessState:
     last_observed: Optional[datetime] = None
     witness_function: Optional[Callable] = None
     meta_state: Dict[str, Any] = field(default_factory=dict)
+    reflection_history: list = field(default_factory=list)
     
     def to_dict(self) -> Dict[str, Any]:
         return {

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()

tests/test_memory_witnessing.py

@@ -171,9 +171,7 @@ class TestTemporalMemory(unittest.TestCase):
         """Test encoding a temporal state."""
         state = TemporalState(
             coherence=0.85,
-            phase=0.5,
-            T_tau=0.5 + 0.5j,
-            phase_history=[0.1, 0.2, 0.3, 0.4, 0.5]
+            phase=0.5 + 0.5j
         )
 
         sig = self.memory.encode(state)
@@ -186,9 +184,7 @@ class TestTemporalMemory(unittest.TestCase):
         """Test encoding ignores states below attention threshold."""
         state = TemporalState(
             coherence=0.3,  # Below 0.7 threshold
-            phase=0.0,
-            T_tau=0.1 + 0j,
-            phase_history=[]
+            phase=0.0 + 0.1j
         )
 
         sig = self.memory.encode(state)
@@ -200,9 +196,7 @@ class TestTemporalMemory(unittest.TestCase):
         """Test forcing encoding of low coherence state."""
         state = TemporalState(
             coherence=0.3,
-            phase=0.0,
-            T_tau=0.1 + 0j,
-            phase_history=[]
+            phase=0.0 + 0.1j
         )
 
         sig = self.memory.encode(state, force_attention=True)
@@ -216,18 +210,14 @@ class TestTemporalMemory(unittest.TestCase):
         for i in range(5):
             state = TemporalState(
                 coherence=0.8 + i * 0.02,
-                phase=i * 0.1,
-                T_tau=0.5 + 0.1j * i,
-                phase_history=[i * 0.1] * 5
+                phase=i * 0.1 + 0j
             )
             self.memory.encode(state)
 
         # Retrieve with query
         query_state = TemporalState(
             coherence=0.85,
-            phase=0.2,
-            T_tau=0.5 + 0.1j,
-            phase_history=[0.1, 0.2, 0.3, 0.4, 0.5]
+            phase=0.2 + 0j
         )
 
         results = self.memory.retrieve(query_state, max_results=3)
@@ -240,18 +230,14 @@ class TestTemporalMemory(unittest.TestCase):
         # Create a memory
         state = TemporalState(
             coherence=0.9,
-            phase=0.0,
-            T_tau=1.0 + 0j,
-            phase_history=[0.0, 0.0, 0.0, 0.0, 0.0]
+            phase=0.0 + 0j
         )
         self.memory.encode(state)
 
         # Try to recognize similar state
         similar_state = TemporalState(
             coherence=0.88,
-            phase=0.01,
-            T_tau=0.95 + 0.05j,
-            phase_history=[0.0, 0.0, 0.0, 0.0, 0.0]
+            phase=0.01 + 0j
         )
 
         match = self.memory.recognize(similar_state, threshold=0.7)
@@ -264,9 +250,7 @@ class TestTemporalMemory(unittest.TestCase):
         for i in range(10):
             state = TemporalState(
                 coherence=0.9,
-                phase=i * 0.1,
-                T_tau=0.5 + 0.1j,
-                phase_history=[i * 0.1] * 5
+                phase=i * 0.1 + 0j
             )
             self.memory.encode(state)
 
@@ -284,9 +268,7 @@ class TestTemporalMemory(unittest.TestCase):
         for i in range(3):
             state = TemporalState(
                 coherence=0.85,
-                phase=i * 0.1,
-                T_tau=0.5 + 0.1j,
-                phase_history=[i * 0.1] * 5
+                phase=i * 0.1 + 0j
             )
             self.memory.encode(state)
 
@@ -311,9 +293,7 @@ class TestTemporalMemory(unittest.TestCase):
         ]):
             state = TemporalState(
                 coherence=strength.value,
-                phase=i * 0.1,
-                T_tau=0.5 + 0.1j,
-                phase_history=[i * 0.1] * 5
+                phase=i * 0.1 + 0j
             )
             sig = self.memory.encode(state)
             if sig:
@@ -330,9 +310,7 @@ class TestTemporalMemory(unittest.TestCase):
         for i in range(5):
             state = TemporalState(
                 coherence=0.85,
-                phase=i * 0.1,
-                T_tau=0.5 + 0.1j,
-                phase_history=[i * 0.1] * 5
+                phase=i * 0.1 + 0j
             )
             self.memory.encode(state)
 
@@ -378,9 +356,7 @@ class TestWitnessingLayer(unittest.TestCase):
 
         state = TemporalState(
             coherence=0.85,
-            phase=0.5,
-            T_tau=0.5 + 0.5j,
-            phase_history=[0.1, 0.2, 0.3, 0.4, 0.5]
+            phase=0.5 + 0.5j
         )
 
         witnessed = self.witnessing.observe(state, "observer2")

tests/test_transducers.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from becomingone.core.engine import KAIROSTemporalEngine, TemporalConfig, TemporalState
 from becomingone.transducers.master import MasterTransducer, MasterConfig
 from becomingone.transducers.emissary import EmissaryTransducer, EmissaryConfig
-from becomingone.sync.layer import SyncLayer, SynchronizationLayer, SyncConfig, create_sync_layer
+from becomingone.sync import SyncLayer, SynchronizationLayer, SyncConfig, create_sync_layer
 
 
 class TestMasterTransducer(unittest.TestCase):