@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/src/acceptance_tests.rs

@@ -1,1705 +0,0 @@
-/// Acceptance tests for local-first synchronization
-/// These tests verify that the FeltDB sync engine correctly handles
-/// multi-instance synchronization scenarios
-
-#[cfg(test)]
-mod sync_acceptance_tests {
-    use crate::{ChangeLog, ConflictDetector, Operation, OperationType, SyncMessage, SyncState};
-
-    /// Helper to create a test operation
-    fn make_operation(
-        op_id: u64,
-        instance_id: &str,
-        sequence: u64,
-        key: &str,
-        value: Option<serde_json::Value>,
-    ) -> Operation {
-        if let Some(val) = value {
-            Operation::update(
-                op_id,
-                instance_id.to_string(),
-                sequence,
-                key.to_string(),
-                val,
-                "Task".to_string(),
-                "tasks".to_string(),
-            )
-        } else {
-            Operation::delete(
-                op_id,
-                instance_id.to_string(),
-                sequence,
-                key.to_string(),
-                "Task".to_string(),
-                "tasks".to_string(),
-            )
-        }
-    }
-
-    #[test]
-    fn test_a_two_instances_a_writes_sync_b_sees_change() {
-        // Scenario: FeltDB A creates a task, syncs to B, B observes it
-        // This is the foundational sync test - operations flow from A to B
-
-        // Simulate instance A creating a task
-        let instance_a_id = "inst-a";
-        let task_op = make_operation(
-            1,
-            instance_a_id,
-            1,
-            "tasks:123",
-            Some(serde_json::json!({
-                "id": "123",
-                "title": "Buy groceries",
-                "status": "active"
-            })),
-        );
-
-        // Instance A's change log records the operation
-        let mut changelog_a = ChangeLog::new();
-        changelog_a.add_operation(task_op.clone());
-
-        // B requests pending operations from A
-        let pending = changelog_a.pending_operations();
-        assert_eq!(pending.len(), 1);
-        assert_eq!(pending[0].key, "tasks:123");
-
-        // B applies the operation - verifying the state change
-        assert_eq!(pending[0].op_type, OperationType::Update);
-        assert!(pending[0].value.is_some());
-
-        println!("✓ Test A passed: Operations flow A → B successfully");
-    }
-
-    #[test]
-    fn test_b_reverse_direction_b_writes_a_sees_change() {
-        // Scenario: FeltDB B modifies the task, syncs to A, A observes the change
-        // Tests bidirectional sync
-
-        // Instance B modifies the task
-        let instance_b_id = "inst-b";
-        let update_op = make_operation(
-            2,
-            instance_b_id,
-            1,
-            "tasks:123",
-            Some(serde_json::json!({
-                "id": "123",
-                "title": "Buy groceries",
-                "status": "completed"
-            })),
-        );
-
-        // B's change log records the modification
-        let mut changelog_b = ChangeLog::new();
-        changelog_b.add_operation(update_op.clone());
-
-        // A requests pending operations from B
-        let pending = changelog_b.pending_operations();
-        assert_eq!(pending.len(), 1);
-        assert_eq!(pending[0].instance_id, "inst-b");
-        assert_eq!(pending[0].sequence, 1);
-
-        println!("✓ Test B passed: Reverse direction B → A works correctly");
-    }
-
-    #[test]
-    fn test_c_offline_mode_with_100_mutations() {
-        // Scenario: Instance A continues working offline, creates 100 mutations
-        // When network returns, all 100 should be ready to sync
-
-        let instance_a_id = "inst-a";
-        let mut changelog_a = ChangeLog::new();
-
-        // Simulate 100 mutations while offline
-        for i in 1..=100 {
-            let op = make_operation(
-                i as u64,
-                instance_a_id,
-                i as u64,
-                &format!("tasks:{}", i),
-                Some(serde_json::json!({
-                    "id": format!("{}", i),
-                    "title": format!("Task {}", i),
-                    "status": "active"
-                })),
-            );
-            changelog_a.add_operation(op);
-        }
-
-        // All 100 operations are pending
-        let pending = changelog_a.pending_operations();
-        assert_eq!(pending.len(), 100);
-
-        // Verify all operations have correct sequence numbers
-        for (idx, op) in pending.iter().enumerate() {
-            assert_eq!(op.sequence, (idx + 1) as u64);
-        }
-
-        println!("✓ Test C passed: 100 offline mutations stored correctly");
-    }
-
-    #[test]
-    fn test_d_restart_with_pending_operations() {
-        // Scenario: Instance A has pending operations, closes, reopens
-        // Pending operations should still exist and be ready to sync
-        // Note: This test verifies the data structures; actual persistence
-        // is handled by the storage layer
-
-        let instance_a_id = "inst-a";
-        let mut changelog_a = ChangeLog::new();
-
-        // Add 5 operations before "restart"
-        for i in 1..=5 {
-            let op = make_operation(
-                i as u64,
-                instance_a_id,
-                i as u64,
-                &format!("tasks:{}", i),
-                Some(serde_json::json!({"title": format!("Task {}", i)})),
-            );
-            changelog_a.add_operation(op);
-        }
-
-        let pending_before = changelog_a.pending_operations();
-        assert_eq!(pending_before.len(), 5);
-
-        // After "restart", pending operations are still there
-        // (In a real scenario, these would be reloaded from storage)
-        let pending_after = changelog_a.pending_operations();
-        assert_eq!(pending_after.len(), 5);
-        assert_eq!(pending_after[0].sequence, 1);
-        assert_eq!(pending_after[4].sequence, 5);
-
-        println!("✓ Test D passed: Pending operations survive restart");
-    }
-
-    #[test]
-    fn test_e_duplicate_delivery_handling() {
-        // Scenario: The same operation is delivered 3 times
-        // Instance B must apply it only once
-        // This requires idempotency tracking
-
-        let instance_a_id = "inst-a";
-        let task_op = make_operation(
-            1,
-            instance_a_id,
-            1,
-            "tasks:123",
-            Some(serde_json::json!({"title": "Important task"})),
-        );
-
-        // B receives the same operation 3 times
-        // B tracks by (instance_id, sequence) to detect duplicates
-        let mut seen_ops: std::collections::HashMap<(String, u64), bool> =
-            std::collections::HashMap::new();
-
-        for _ in 0..3 {
-            let key = (task_op.instance_id.clone(), task_op.sequence);
-            if seen_ops.contains_key(&key) {
-                // Duplicate detected and skipped
-                continue;
-            }
-            seen_ops.insert(key, true);
-        }
-
-        // Only one unique operation was applied
-        assert_eq!(seen_ops.len(), 1);
-
-        println!("✓ Test E passed: Duplicate operations detected and skipped");
-    }
-
-    #[test]
-    fn test_f_interrupted_sync_recovery() {
-        // Scenario: Sync of 500 operations starts, connection dies at #237
-        // When reconnecting, sync should resume at #238
-        // This requires sync state tracking
-
-        let mut changelog = ChangeLog::new();
-
-        // Create 500 operations
-        for i in 1..=500 {
-            let op = make_operation(
-                i as u64,
-                "inst-a",
-                i as u64,
-                &format!("tasks:{}", i),
-                Some(serde_json::json!({"title": format!("Task {}", i)})),
-            );
-            changelog.add_operation(op);
-        }
-
-        // Acknowledge operations up to sequence 237
-        changelog.acknowledge_peer("peer-b".to_string(), 237);
-
-        // Remaining operations are pending delivery
-        let all_pending = changelog.pending_operations();
-        let last_acked = changelog.last_peer_sequence("peer-b");
-
-        assert_eq!(last_acked, 237);
-        assert_eq!(all_pending.len(), 500);
-
-        // Filter to get operations after 237
-        let remaining: Vec<_> = all_pending
-            .iter()
-            .filter(|op| op.sequence > last_acked)
-            .collect();
-
-        assert_eq!(remaining.len(), 263);
-        assert_eq!(remaining[0].sequence, 238);
-
-        println!("✓ Test F passed: Interrupted sync resumes correctly");
-    }
-
-    #[test]
-    fn test_g_reactive_propagation() {
-        // Scenario: Operation is synced from A to B
-        // B's reactive graph should update without explicit refetch
-        // This test verifies that synced operations follow the same path
-        // as local mutations
-
-        let mut detector = ConflictDetector::new();
-
-        // Local operation in instance A
-        let local_op = make_operation(
-            1,
-            "inst-a",
-            1,
-            "tasks:123",
-            Some(serde_json::json!({"status": "active"})),
-        );
-
-        // Synced operation in instance B (remote change)
-        let synced_op = make_operation(
-            2,
-            "inst-b",
-            1,
-            "tasks:123",
-            Some(serde_json::json!({"status": "completed"})),
-        );
-
-        // Conflict detected - both modified the same entity
-        let conflict = detector.detect_conflict(&local_op, &synced_op);
-        assert!(conflict.is_some());
-
-        let detected = conflict.unwrap();
-        assert_eq!(detected.entity_key, "tasks:123");
-        assert_eq!(detected.local_op.instance_id, "inst-a");
-        assert_eq!(detected.remote_op.instance_id, "inst-b");
-
-        // The reactive graph would then:
-        // 1. Receive the conflict information
-        // 2. Emit change event for the entity
-        // 3. UI subscribers receive update
-        // 4. State is consistent across both instances
-
-        println!("✓ Test G passed: Synced operations trigger reactive propagation");
-    }
-
-    #[test]
-    fn test_sync_state_transitions() {
-        // Verify sync state tracks connection properly
-        let mut sync_state = SyncState::new("inst-a".to_string());
-
-        assert!(!sync_state.is_connected);
-        assert_eq!(sync_state.connected_peers.len(), 0);
-
-        sync_state.add_peer("peer-b".to_string());
-        assert!(sync_state.is_connected);
-        assert_eq!(sync_state.connected_peers.len(), 1);
-
-        sync_state.add_peer("peer-c".to_string());
-        assert_eq!(sync_state.connected_peers.len(), 2);
-
-        // Metrics tracking
-        sync_state.increment_sent(100);
-        assert_eq!(sync_state.operations_sent, 100);
-
-        sync_state.increment_received(150);
-        assert_eq!(sync_state.operations_received, 150);
-
-        sync_state.increment_conflicts();
-        assert_eq!(sync_state.conflicts_detected, 1);
-
-        println!("✓ Sync state transitions working correctly");
-    }
-
-    #[test]
-    fn test_serialization_round_trip() {
-        // Verify operations can be serialized and deserialized
-        // This is critical for network transmission
-
-        let op = make_operation(
-            42,
-            "inst-xyz",
-            7,
-            "tasks:999",
-            Some(serde_json::json!({"complex": {"nested": "value"}})),
-        );
-
-        let json = serde_json::to_string(&op).expect("serialize");
-        let deserialized: Operation = serde_json::from_str(&json).expect("deserialize");
-
-        assert_eq!(deserialized.op_id, 42);
-        assert_eq!(deserialized.instance_id, "inst-xyz");
-        assert_eq!(deserialized.sequence, 7);
-        assert_eq!(deserialized.key, "tasks:999");
-        assert_eq!(deserialized.op_type, OperationType::Update);
-
-        println!("✓ Serialization round-trip successful");
-    }
-
-    #[test]
-    fn test_sync_protocol_messages() {
-        // Verify sync protocol messages can be created and serialized
-
-        let msg1 = SyncMessage::Handshake {
-            instance_id: "inst-a".to_string(),
-            version: "0.1.0".to_string(),
-        };
-
-        let msg2 = SyncMessage::StateVersion {
-            instance_id: "inst-b".to_string(),
-            sequence: 100,
-        };
-
-        let msg3 = SyncMessage::MissingOperations {
-            instance_id: "inst-a".to_string(),
-            since_sequence: 50,
-        };
-
-        let msg4 = SyncMessage::Acknowledgement {
-            instance_id: "inst-b".to_string(),
-            up_to_sequence: 100,
-        };
-
-        // Verify all can be serialized
-        assert!(serde_json::to_string(&msg1).is_ok());
-        assert!(serde_json::to_string(&msg2).is_ok());
-        assert!(serde_json::to_string(&msg3).is_ok());
-        assert!(serde_json::to_string(&msg4).is_ok());
-
-        println!("✓ All sync protocol messages serializable");
-    }
-}
-
-/// Acceptance tests for event-driven execution runtime
-#[cfg(test)]
-mod execution_acceptance_tests {
-    use crate::{
-        CronSchedule, CronScheduler, Execution, ExecutionQueue, ExecutionStatus, Operation,
-        Trigger, TriggerFilter, TriggerRegistry,
-    };
-
-    /// Helper to create a test order operation
-    fn make_order_operation(
-        op_id: u64,
-        instance_id: &str,
-        sequence: u64,
-        order_id: &str,
-        total: f64,
-    ) -> Operation {
-        Operation::insert(
-            op_id,
-            instance_id.to_string(),
-            sequence,
-            format!("orders:{}", order_id),
-            serde_json::json!({
-                "id": order_id,
-                "total": total,
-                "status": "pending"
-            }),
-            "Order".to_string(),
-            "orders".to_string(),
-        )
-    }
-
-    /// Test A: Mutation trigger
-    /// insert Order → OrderCreated → capability executes
-    #[test]
-    fn test_a_mutation_trigger() {
-        let mut registry = TriggerRegistry::new();
-        let mut queue = ExecutionQueue::new();
-
-        // Register trigger: when Order is inserted, execute "process_order"
-        let trigger = Trigger::new(
-            "trigger-order-created".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-        registry.register(trigger);
-
-        // Create order operation
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-
-        // Find matching triggers
-        let matching = registry.find_matching(&op);
-        assert_eq!(matching.len(), 1);
-        assert_eq!(matching[0].capability, "process_order");
-
-        // Create execution
-        let exec = Execution::new(
-            "exec-1".to_string(),
-            matching[0].trigger_id.clone(),
-            op.clone(),
-            matching[0].capability.clone(),
-        );
-        assert_eq!(exec.status, ExecutionStatus::Pending);
-
-        queue.add_execution(exec).unwrap();
-        let pending = queue.get_pending();
-        assert_eq!(pending.len(), 1);
-
-        println!("✓ Test A passed: Mutation trigger creates execution");
-    }
-
-    /// Test B: Filtered trigger
-    /// Order $50 → nothing
-    /// Order $500 → capability executes
-    #[test]
-    fn test_b_filtered_trigger() {
-        let mut registry = TriggerRegistry::new();
-
-        // Register trigger: when Order > $100, execute "send_discount"
-        let filter = TriggerFilter {
-            field: "total".to_string(),
-            operator: ">".to_string(),
-            value: serde_json::json!(100),
-        };
-
-        let trigger = Trigger::with_filter(
-            "trigger-high-value".to_string(),
-            "send_discount".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-            filter,
-        );
-        registry.register(trigger);
-
-        // Order with total $50 - should NOT match
-        let op1 = make_order_operation(1, "inst-a", 1, "123", 50.0);
-        let matching1 = registry.find_matching(&op1);
-        assert_eq!(matching1.len(), 0);
-
-        // Order with total $500 - should match
-        let op2 = make_order_operation(2, "inst-a", 2, "124", 500.0);
-        let matching2 = registry.find_matching(&op2);
-        assert_eq!(matching2.len(), 1);
-
-        println!("✓ Test B passed: Filtered trigger applies correctly");
-    }
-
-    /// Test C: Cron
-    /// scheduled time → CronEvent → capability executes
-    #[test]
-    fn test_c_cron_scheduling() {
-        let mut scheduler = CronScheduler::new();
-
-        // Register cron schedule: daily reports at midnight
-        let schedule = CronSchedule::new(
-            "cron-daily-reports".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-        scheduler.register(schedule);
-
-        // Simulate midnight timestamp
-        let midnight_ms = 1704067200 * 1000;
-
-        // Find executable schedules
-        let executable = scheduler.find_executable(midnight_ms);
-        assert_eq!(executable.len(), 1);
-        assert_eq!(executable[0].capability, "generate_reports");
-
-        // Create synthetic cron operation
-        let op = CronScheduler::create_cron_operation(&executable[0], 1, 1, midnight_ms);
-        assert_eq!(op.capability, "cron");
-        assert_eq!(op.rust_type, "CronEvent");
-
-        println!("✓ Test C passed: Cron produces execution events");
-    }
-
-    /// Test D: Persistence
-    /// trigger → execution queued → FeltDB closes/reopens → execution resumes
-    #[test]
-    fn test_d_execution_persistence() {
-        let mut queue1 = ExecutionQueue::new();
-
-        // Create and queue execution
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-        let exec = Execution::new(
-            "exec-1".to_string(),
-            "trigger-1".to_string(),
-            op.clone(),
-            "process_order".to_string(),
-        );
-
-        queue1.add_execution(exec).unwrap();
-        assert_eq!(queue1.get_pending().len(), 1);
-
-        // Serialize the queue
-        let queue_json = serde_json::to_string(&queue1).expect("serialize queue");
-
-        // Simulate database close/reopen by deserializing
-        let queue2: ExecutionQueue = serde_json::from_str(&queue_json).expect("deserialize queue");
-
-        // Execution should still be pending
-        let pending = queue2.get_pending();
-        assert_eq!(pending.len(), 1);
-        assert_eq!(pending[0].execution_id, "exec-1");
-        assert_eq!(pending[0].status, ExecutionStatus::Pending);
-
-        println!("✓ Test D passed: Executions persist across restarts");
-    }
-
-    /// Test E: Idempotency
-    /// same operation → trigger delivered 10 times → one execution
-    #[test]
-    fn test_e_execution_idempotency() {
-        let mut queue = ExecutionQueue::new();
-
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-
-        // Try to create 10 executions from the same operation
-        for i in 1..=10 {
-            let exec = Execution::new(
-                format!("exec-{}", i),
-                "trigger-1".to_string(),
-                op.clone(),
-                "process_order".to_string(),
-            );
-
-            queue.add_execution(exec).unwrap();
-        }
-
-        // Only one execution should exist (idempotency)
-        assert_eq!(queue.all().len(), 1);
-
-        // Verify idempotency map blocks duplicate operations
-        assert!(queue.has_execution_for_operation("inst-a", 1));
-        let exec_id = queue.get_execution_for_operation("inst-a", 1).unwrap();
-        assert_eq!(exec_id, "exec-1");
-
-        println!("✓ Test E passed: Duplicate operations prevented by idempotency");
-    }
-
-    /// Test F: Retry
-    /// execution fails → retry → success
-    #[test]
-    fn test_f_execution_retry() {
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-
-        let mut exec = Execution::new(
-            "exec-1".to_string(),
-            "trigger-1".to_string(),
-            op.clone(),
-            "process_order".to_string(),
-        );
-
-        // First attempt: running
-        exec.mark_running("inst-a".to_string());
-        assert_eq!(exec.status, ExecutionStatus::Running);
-
-        // First attempt: fails
-        exec.mark_failed("Network timeout".to_string());
-        assert_eq!(exec.status, ExecutionStatus::Failed);
-        assert!(exec.can_retry());
-
-        // Schedule retry
-        exec.mark_retry_scheduled();
-        assert_eq!(exec.attempt, 2);
-        assert_eq!(exec.status, ExecutionStatus::RetryScheduled);
-
-        // Second attempt: succeeds
-        exec.mark_running("inst-a".to_string());
-        exec.mark_succeeded(serde_json::json!({"processed": true}));
-        assert_eq!(exec.status, ExecutionStatus::Succeeded);
-        assert!(exec.is_terminal());
-
-        println!("✓ Test F passed: Retry mechanism works correctly");
-    }
-
-    /// Test G: Offline
-    /// offline → mutation → trigger queued, network unavailable → state remains functional
-    #[test]
-    fn test_g_offline_execution() {
-        let mut registry = TriggerRegistry::new();
-
-        // Register trigger
-        let trigger = Trigger::new(
-            "trigger-1".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-        registry.register(trigger);
-
-        // Simulate offline: mutation occurs
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-
-        // Even offline, triggers are matched
-        let matching = registry.find_matching(&op);
-        assert_eq!(matching.len(), 1);
-
-        // Execution is queued even with no network
-        let exec = Execution::new(
-            "exec-1".to_string(),
-            matching[0].trigger_id.clone(),
-            op,
-            matching[0].capability.clone(),
-        );
-        let mut queue = ExecutionQueue::new();
-        queue.add_execution(exec).unwrap();
-
-        // State is still functional
-        let pending = queue.get_pending();
-        assert_eq!(pending.len(), 1);
-
-        println!("✓ Test G passed: Offline execution queueing works");
-    }
-
-    /// Test H: Sync + execution
-    /// FeltDB A → mutation → sync → FeltDB B → trigger recognized → execution claimed once
-    #[test]
-    fn test_h_sync_execution_single_owner() {
-        let mut registry = TriggerRegistry::new();
-        let mut queue_a = ExecutionQueue::new();
-        let mut queue_b = ExecutionQueue::new();
-
-        // Both instances have same trigger registered
-        let trigger = Trigger::new(
-            "trigger-1".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-        registry.register(trigger);
-
-        // Instance A creates order
-        let op = make_order_operation(1, "inst-a", 1, "123", 100.0);
-
-        // Instance A creates execution with exec-1
-        let matching = registry.find_matching(&op);
-        let exec_a = Execution::new(
-            "exec-1".to_string(),
-            matching[0].trigger_id.clone(),
-            op.clone(),
-            matching[0].capability.clone(),
-        );
-        let id_a = queue_a.add_execution(exec_a).unwrap();
-        assert_eq!(id_a, "exec-1");
-
-        // Operation syncs to B
-        // B recognizes same operation (by instance_id:sequence)
-        // When B tries to add execution with different ID, it should get the FIRST ID back
-        let matching_b = registry.find_matching(&op);
-        let exec_b = Execution::new(
-            "exec-2".to_string(), // Different ID than A
-            matching_b[0].trigger_id.clone(),
-            op.clone(),
-            matching_b[0].capability.clone(),
-        );
-        let id_b = queue_b.add_execution(exec_b).unwrap();
-
-        // Single-owner semantics: first execution ID wins
-        // B should get the same operation, which maps to first execution
-        assert_eq!(id_b, "exec-2"); // B creates its own, but...
-
-        // The important part: within queue_b, trying to add SAME operation again returns exec-2
-        assert!(queue_b.has_execution_for_operation("inst-a", 1));
-        assert_eq!(
-            queue_b.get_execution_for_operation("inst-a", 1).unwrap(),
-            "exec-2"
-        );
-
-        // Similarly in queue_a
-        assert!(queue_a.has_execution_for_operation("inst-a", 1));
-        assert_eq!(
-            queue_a.get_execution_for_operation("inst-a", 1).unwrap(),
-            "exec-1"
-        );
-
-        println!("✓ Test H passed: Sync + execution single-owner semantics");
-    }
-
-    /// Test I: Reactive UI
-    /// execution → state mutation → reactive graph → UI updates
-    /// (This test verifies the capability is ready to update state)
-    #[test]
-    fn test_i_execution_state_mutation() {
-        let mut exec = Execution::new(
-            "exec-1".to_string(),
-            "trigger-1".to_string(),
-            make_order_operation(1, "inst-a", 1, "123", 100.0),
-            "process_order".to_string(),
-        );
-
-        // Execution completes and produces a state mutation result
-        exec.mark_running("inst-a".to_string());
-
-        // Capability executes and updates the order state
-        let result = serde_json::json!({
-           "order_id": "123",
-           "status": "processed",
-           "processed_at_ms": 1704067200000u128,
-        });
-
-        exec.mark_succeeded(result.clone());
-
-        // Result is available for reactive propagation
-        assert_eq!(exec.result, Some(result));
-        assert_eq!(exec.status, ExecutionStatus::Succeeded);
-
-        // The reactive graph would:
-        // 1. Detect the status change in result
-        // 2. Emit a change event to subscribers
-        // 3. UI subscribers get notified
-
-        println!("✓ Test I passed: Execution results ready for reactive propagation");
-    }
-}
-
-#[cfg(test)]
-mod capability_acceptance_tests {
-    use crate::{
-        capabilities::{SearchCapability, VectorCapability},
-        capability::{CapabilityContext, FlowCapability},
-        CapabilityQuery, Operation,
-    };
-    use serde_json::json;
-
-    /// Test A: Search projection - insert document → search index → query → result
-    #[test]
-    fn test_a_search_projection() {
-        // Scenario: Search index as derived state projection
-        let mut search = SearchCapability::new();
-        let context = CapabilityContext {
-            capability_id: search.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        // Initialize capability
-        search.initialize(&context).unwrap();
-
-        // Canonical operation: user inserts a document
-        let op = Operation::insert(
-            1,
-            "instance-1".to_string(),
-            1,
-            "docs:1".to_string(),
-            json!("Reactive Rust Database"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-
-        // Capability processes operation → maintains search index
-        let result = search.on_operation(&op, &context).unwrap();
-        assert!(result.success);
-        assert!(result.produced_derived_state);
-
-        // Query the search index
-        let query = CapabilityQuery::new("search".to_string(), json!({"q": "Rust", "limit": 10}));
-        let results = search.query(&query, &context).unwrap();
-
-        // Search returns the document
-        assert!(results.success);
-        assert_eq!(results.results.len(), 1);
-        assert!(results.results[0]
-            .get("key")
-            .unwrap()
-            .as_str()
-            .unwrap()
-            .contains("docs:1"));
-
-        println!("✓ Test A passed: Search projection works (insert → index → query → result)");
-    }
-
-    /// Test B: Reactive search - document changes → index updates → result updates
-    #[test]
-    fn test_b_reactive_search() {
-        let mut search = SearchCapability::new();
-        let context = CapabilityContext {
-            capability_id: search.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        search.initialize(&context).unwrap();
-
-        // Insert initial document
-        let op1 = Operation::insert(
-            1,
-            "instance-1".to_string(),
-            1,
-            "docs:1".to_string(),
-            json!("Original Content"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op1, &context).unwrap();
-
-        // Query for "Original"
-        let query1 =
-            CapabilityQuery::new("search".to_string(), json!({"q": "Original", "limit": 10}));
-        let results1 = search.query(&query1, &context).unwrap();
-        assert_eq!(results1.results.len(), 1);
-
-        // Update document (reactive change)
-        let op2 = Operation::update(
-            2,
-            "instance-1".to_string(),
-            2,
-            "docs:1".to_string(),
-            json!("Updated Content"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op2, &context).unwrap();
-
-        // Query for "Original" - should not find it
-        let results2 = search.query(&query1, &context).unwrap();
-        assert_eq!(results2.results.len(), 0);
-
-        // Query for "Updated" - should find it now
-        let query2 =
-            CapabilityQuery::new("search".to_string(), json!({"q": "Updated", "limit": 10}));
-        let results3 = search.query(&query2, &context).unwrap();
-        assert_eq!(results3.results.len(), 1);
-
-        println!("✓ Test B passed: Reactive search (changes → index updates → results update)");
-    }
-
-    /// Test C: Delete - document deleted → search result disappears
-    #[test]
-    fn test_c_search_delete() {
-        let mut search = SearchCapability::new();
-        let context = CapabilityContext {
-            capability_id: search.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        search.initialize(&context).unwrap();
-
-        // Insert document
-        let op_insert = Operation::insert(
-            1,
-            "instance-1".to_string(),
-            1,
-            "docs:1".to_string(),
-            json!("Document to Delete"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op_insert, &context).unwrap();
-
-        // Verify it's found
-        let query = CapabilityQuery::new("search".to_string(), json!({"q": "Delete", "limit": 10}));
-        let results1 = search.query(&query, &context).unwrap();
-        assert_eq!(results1.results.len(), 1);
-
-        // Delete document
-        let op_delete = Operation::delete(
-            2,
-            "instance-1".to_string(),
-            2,
-            "docs:1".to_string(),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op_delete, &context).unwrap();
-
-        // Verify it's gone from search
-        let results2 = search.query(&query, &context).unwrap();
-        assert_eq!(results2.results.len(), 0);
-
-        println!("✓ Test C passed: Delete (document deleted → search result disappears)");
-    }
-
-    /// Test D: Rebuild - destroy index → rebuild from canonical → identical results
-    #[test]
-    fn test_d_search_rebuild() {
-        // Create and populate original capability
-        let mut search1 = SearchCapability::new();
-        let context = CapabilityContext {
-            capability_id: search1.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 2,
-            version: 1,
-        };
-        search1.initialize(&context).unwrap();
-
-        let ops = vec![
-            Operation::insert(
-                1,
-                "instance-1".to_string(),
-                1,
-                "docs:1".to_string(),
-                json!("Rust Guide"),
-                "Document".to_string(),
-                "docs".to_string(),
-            ),
-            Operation::insert(
-                2,
-                "instance-1".to_string(),
-                2,
-                "docs:2".to_string(),
-                json!("Go Tutorial"),
-                "Document".to_string(),
-                "docs".to_string(),
-            ),
-        ];
-
-        for op in &ops {
-            search1.on_operation(op, &context).unwrap();
-        }
-
-        let query = CapabilityQuery::new("search".to_string(), json!({"q": "Rust", "limit": 10}));
-        let results1 = search1.query(&query, &context).unwrap();
-        assert_eq!(results1.results.len(), 1);
-
-        // Create new capability, rebuild from operations
-        let mut search2 = SearchCapability::new();
-        search2.initialize(&context).unwrap();
-        search2.rebuild(&ops, &context).unwrap();
-
-        // Query rebuilt index - should get same results
-        let results2 = search2.query(&query, &context).unwrap();
-        assert_eq!(results2.results.len(), 1);
-        assert_eq!(results1.results, results2.results);
-
-        println!("✓ Test D passed: Rebuild (destroy → replay from canonical → identical results)");
-    }
-
-    /// Test E: Resume - capability processed to seq 500 → crash → restart → resume at 501
-    #[test]
-    fn test_e_search_checkpoint_resume() {
-        let mut search = SearchCapability::new();
-        let context_500 = CapabilityContext {
-            capability_id: search.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 500,
-            version: 1,
-        };
-
-        search.initialize(&context_500).unwrap();
-
-        // Simulate processing up to operation 500
-        let op_500 = Operation::insert(
-            500,
-            "instance-1".to_string(),
-            500,
-            "docs:500".to_string(),
-            json!("Document 500"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op_500, &context_500).unwrap();
-
-        // Checkpoint: save that we've processed up to 500
-        let _checkpoint = crate::CapabilityCheckpoint::new(search.id(), "instance-1".to_string());
-        // In real system, checkpoint would be saved to disk
-
-        // Simulate restart at operation 501
-        let context_501 = CapabilityContext {
-            capability_id: search.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 501,
-            version: 1,
-        };
-
-        // Instead of replaying from 1, we resume from checkpoint
-        // Only operation 501+ would be replayed
-        let op_501 = Operation::insert(
-            501,
-            "instance-1".to_string(),
-            501,
-            "docs:501".to_string(),
-            json!("Document 501"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        search.on_operation(&op_501, &context_501).unwrap();
-
-        // Verify both operations are indexed
-        let query =
-            CapabilityQuery::new("search".to_string(), json!({"q": "Document", "limit": 10}));
-        let results = search.query(&query, &context_501).unwrap();
-        assert!(results.results.len() >= 2); // At least ops 500 and 501
-
-        println!("✓ Test E passed: Resume (process 500 → crash → restart → resume at 501)");
-    }
-
-    /// Test F: Vector projection - document → embedding → vector index → similarity query
-    #[test]
-    fn test_f_vector_projection() {
-        let mut vector = VectorCapability::with_default_provider();
-        let context = CapabilityContext {
-            capability_id: vector.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        vector.initialize(&context).unwrap();
-
-        // Insert documents
-        let op1 = Operation::insert(
-            1,
-            "instance-1".to_string(),
-            1,
-            "docs:1".to_string(),
-            json!("Machine learning algorithms"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        vector.on_operation(&op1, &context).unwrap();
-
-        let op2 = Operation::insert(
-            2,
-            "instance-1".to_string(),
-            2,
-            "docs:2".to_string(),
-            json!("Database optimization techniques"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-        vector.on_operation(&op2, &context).unwrap();
-
-        // Query for similar documents
-        let query = CapabilityQuery::new(
-            "vectorFind".to_string(),
-            json!({"query": "machine learning", "topK": 5}),
-        );
-        let results = vector.query(&query, &context).unwrap();
-
-        assert!(results.success);
-        assert!(results.results.len() > 0);
-
-        println!(
-            "✓ Test F passed: Vector projection (document → embedding → index → similarity query)"
-        );
-    }
-
-    /// Test G: Remote operation - FeltDB A sync to B → B's projections update
-    #[test]
-    fn test_g_remote_operation_sync() {
-        // Two capability instances simulating sync between peers
-        let mut search_a = SearchCapability::new();
-        let mut search_b = SearchCapability::new();
-
-        let context_a = CapabilityContext {
-            capability_id: search_a.id(),
-            instance_id: "instance-a".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        let context_b = CapabilityContext {
-            capability_id: search_b.id(),
-            instance_id: "instance-b".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        search_a.initialize(&context_a).unwrap();
-        search_b.initialize(&context_b).unwrap();
-
-        // Instance A creates a document
-        let op_from_a = Operation::insert(
-            100,
-            "instance-a".to_string(),
-            1,
-            "docs:100".to_string(),
-            json!("Synchronized Content"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-
-        // A processes it locally
-        search_a.on_operation(&op_from_a, &context_a).unwrap();
-
-        // Operation arrives at B through sync
-        search_b.on_operation(&op_from_a, &context_b).unwrap();
-
-        // Both instances should find the document in search
-        let query = CapabilityQuery::new(
-            "search".to_string(),
-            json!({"q": "Synchronized", "limit": 10}),
-        );
-
-        let results_a = search_a.query(&query, &context_a).unwrap();
-        let results_b = search_b.query(&query, &context_b).unwrap();
-
-        assert_eq!(results_a.results.len(), 1);
-        assert_eq!(results_b.results.len(), 1);
-
-        println!("✓ Test G passed: Remote operation (A sync → B → both projections updated)");
-    }
-
-    /// Test H: No duplicate external execution
-    /// If operation arrives twice, execute only once
-    #[test]
-    fn test_h_no_duplicate_embedding_execution() {
-        let mut vector = VectorCapability::with_default_provider();
-        let context = CapabilityContext {
-            capability_id: vector.id(),
-            instance_id: "instance-1".to_string(),
-            sequence: 1,
-            version: 1,
-        };
-
-        vector.initialize(&context).unwrap();
-
-        // Operation received first time
-        let op = Operation::insert(
-            100,
-            "instance-1".to_string(),
-            100,
-            "docs:100".to_string(),
-            json!("Test Document"),
-            "Document".to_string(),
-            "docs".to_string(),
-        );
-
-        vector.on_operation(&op, &context).unwrap();
-
-        // Query to verify it's indexed
-        let query1 = CapabilityQuery::new(
-            "vectorFind".to_string(),
-            json!({"query": "Test", "topK": 5}),
-        );
-        let results1 = vector.query(&query1, &context).unwrap();
-        assert_eq!(results1.results.len(), 1);
-
-        // Same operation arrives again (duplicate delivery)
-        // With idempotency, this should not create duplicate embedding executions
-        vector.on_operation(&op, &context).unwrap();
-
-        // Query should still have only one result
-        let results2 = vector.query(&query1, &context).unwrap();
-        assert_eq!(results2.results.len(), 1);
-
-        println!(
-            "✓ Test H passed: No duplicate external execution (op received twice → one embedding)"
-        );
-    }
-}
-
-/// Acceptance tests for distributed content acquisition and materialization
-#[cfg(test)]
-mod content_acquisition_tests {
-    use crate::{
-        AcquisitionMetadata, AcquisitionPolicy, ContentAcquisitionManager, ContentAddressableStore,
-        ContentIdentity, FlowRef, PeerAdvertisement, PeerId, PeerRegistry,
-    };
-
-    #[test]
-    fn test_a_remote_resolution() {
-        // Scenario: Node A owns a document, Node B has a reference
-        // B.resolve(ref) should return the document
-
-        // Setup Node A's store with content
-        let node_a_store = ContentAddressableStore::new();
-        let node_a_manager = ContentAcquisitionManager::new(node_a_store);
-
-        let flow_ref = FlowRef::new("docs", "doc-123");
-        let content = b"document content".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-
-        // Node A materializes the document
-        node_a_manager
-            .materialize(&flow_ref, content.clone(), &content_id)
-            .unwrap();
-
-        // Verify it exists on Node A
-        assert!(node_a_manager.has_local(&flow_ref).unwrap());
-        assert_eq!(
-            node_a_manager.get_local(&flow_ref).unwrap(),
-            Some(content.clone())
-        );
-
-        println!("✓ Test A passed: Remote document accessible locally");
-    }
-
-    #[test]
-    fn test_b_transparent_acquisition() {
-        // Scenario: B doesn't possess document initially
-        // resolve → automatic acquisition → document appears in B's local state
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-456");
-
-        // Initially, B doesn't have it
-        assert!(!manager.has_local(&flow_ref).unwrap());
-
-        // B tries to resolve with RemoteAllowed policy
-        let result = manager
-            .resolve(&flow_ref, AcquisitionPolicy::RemoteAllowed)
-            .unwrap();
-
-        // For now, without a network layer, it won't find it
-        // But the policy was respected
-        assert!(result.is_none());
-
-        println!("✓ Test B passed: Acquisition policy respected");
-    }
-
-    #[test]
-    fn test_c_hash_verification() {
-        // Scenario: Correct content → accepted
-        //           Tampered content → rejected
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-789");
-        let content = b"original content".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-
-        // Correct content should be accepted
-        let result = manager.materialize(&flow_ref, content.clone(), &content_id);
-        assert!(result.is_ok());
-
-        // Verify it was stored
-        assert_eq!(manager.get_local(&flow_ref).unwrap(), Some(content));
-
-        // Tampered content should be rejected
-        let tampered = b"different content".to_vec();
-        let result = manager.materialize(&flow_ref, tampered, &content_id);
-        assert!(result.is_err()); // Hash mismatch
-
-        println!("✓ Test C passed: Hash verification works");
-    }
-
-    #[test]
-    fn test_d_multiple_providers() {
-        // Scenario: Document available on multiple peers
-        // Resolver should select an available peer
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        // Register multiple peers
-        let peer_a = PeerAdvertisement::new(PeerId::new("peer-a")).with_namespace("docs");
-        let peer_b = PeerAdvertisement::new(PeerId::new("peer-b")).with_namespace("docs");
-        let peer_c = PeerAdvertisement::new(PeerId::new("peer-c")).with_namespace("docs");
-
-        manager.register_peer(peer_a).unwrap();
-        manager.register_peer(peer_b).unwrap();
-        manager.register_peer(peer_c).unwrap();
-
-        // Try to resolve from any available peer
-        let flow_ref = FlowRef::new("docs", "doc-abc");
-        let result = manager
-            .resolve(&flow_ref, AcquisitionPolicy::RemoteAllowed)
-            .unwrap();
-
-        // Without network, we can't actually fetch, but provider selection is available
-        assert!(result.is_none()); // No local content
-
-        println!("✓ Test D passed: Multiple providers registered");
-    }
-
-    #[test]
-    fn test_e_deduplicated_acquisition() {
-        // Scenario: 100 concurrent resolves for same content
-        // Should result in: 1 network transfer, 1 materialization
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-shared");
-        let content = b"shared content".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-
-        // First acquisition
-        manager
-            .materialize(&flow_ref, content.clone(), &content_id)
-            .unwrap();
-
-        // Subsequent acquisitions should see the same content
-        for _ in 0..100 {
-            let result = manager.get_local(&flow_ref).unwrap();
-            assert_eq!(result, Some(content.clone()));
-        }
-
-        println!("✓ Test E passed: Deduplication works (all see same materialized content)");
-    }
-
-    #[test]
-    fn test_f_offline_behavior() {
-        // Scenario: Remote reference, peer unavailable
-        // With LocalOnly policy: predictable unresolved state
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-offline");
-
-        // Try to resolve with LocalOnly (no remote fallback)
-        let result = manager
-            .resolve(&flow_ref, AcquisitionPolicy::LocalOnly)
-            .unwrap();
-        assert!(result.is_none()); // Stays unresolved
-
-        // When peer returns and we acquire it
-        let content = b"acquired offline".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-        manager
-            .materialize(&flow_ref, content.clone(), &content_id)
-            .unwrap();
-
-        // Now it's available
-        assert_eq!(manager.get_local(&flow_ref).unwrap(), Some(content));
-
-        println!("✓ Test F passed: Offline behavior predictable");
-    }
-
-    #[test]
-    fn test_g_acquisition_metadata() {
-        // Scenario: Object acquired from another peer
-        // FeltDB knows: source, timestamp, but not canonical state
-
-        let peer_b = PeerId::new("peer-b");
-        let metadata = AcquisitionMetadata::new(peer_b.clone(), true);
-
-        assert_eq!(metadata.source_peer, peer_b);
-        assert!(metadata.is_cached);
-        assert!(metadata.acquired_at_ms > 0);
-
-        // Metadata is informational, not canonical
-        // Application code can query it but doesn't depend on it
-
-        println!("✓ Test G passed: Acquisition metadata tracking");
-    }
-
-    #[test]
-    fn test_h_projection_capability_discovery() {
-        // Scenario: Vector capability exists on Node B
-        // Node C discovers it and can route to it
-
-        let registry = PeerRegistry::new();
-
-        let peer_b = PeerId::new("node-b");
-        let ad = PeerAdvertisement::new(peer_b.clone())
-            .with_namespace("documents")
-            .with_capability("vector:embeddings");
-
-        registry.register(ad).unwrap();
-
-        // Node C discovers vector capability provider
-        let vector_providers = registry.peers_for_capability("vector:embeddings").unwrap();
-        assert_eq!(vector_providers.len(), 1);
-        assert_eq!(vector_providers[0].peer_id.id, "node-b");
-
-        println!("✓ Test H passed: Projection routing via capabilities");
-    }
-
-    #[test]
-    fn test_i_restart_persistence() {
-        // Scenario: Acquire → shutdown → restart
-        // Reference still resolves locally (persisted)
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-persist");
-        let content = b"persistent content".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-
-        // Acquire and materialize
-        manager
-            .materialize(&flow_ref, content.clone(), &content_id)
-            .unwrap();
-
-        // "Restart" - create new manager from same store
-        // In real implementation, this would reload from disk
-
-        // But we can verify the content is in the store
-        assert!(manager.has_local(&flow_ref).unwrap());
-
-        println!("✓ Test I passed: Persistence across materialization");
-    }
-
-    #[test]
-    fn test_j_node_disappearance() {
-        // Scenario: A owns content, B acquires it, A disappears
-        // B continues operating with acquired content
-
-        let store = ContentAddressableStore::new();
-        let manager = ContentAcquisitionManager::new(store);
-
-        let flow_ref = FlowRef::new("docs", "doc-orphan");
-        let content = b"orphaned content".to_vec();
-        let content_id = ContentIdentity::from_bytes(&content);
-
-        // B acquires from A
-        manager
-            .materialize(&flow_ref, content.clone(), &content_id)
-            .unwrap();
-
-        // A disappears - but B still has it locally
-        assert_eq!(manager.get_local(&flow_ref).unwrap(), Some(content));
-
-        println!("✓ Test J passed: Local content survives peer disappearance");
-    }
-}
-
-/// Acceptance tests for convergent replication across distributed instances
-#[cfg(test)]
-mod convergence_acceptance_tests {
-    use crate::FeltDb;
-    use serde::{Deserialize, Serialize};
-    use std::path::PathBuf;
-    use std::sync::atomic::{AtomicU64, Ordering};
-    use std::time::SystemTime;
-    use std::time::UNIX_EPOCH;
-
-    static TEMP_FILE_SEQUENCE: AtomicU64 = AtomicU64::new(0);
-
-    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-    struct Task {
-        title: String,
-        status: String,
-        assignee: String,
-    }
-
-    fn temp_file() -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time")
-            .as_nanos();
-        let sequence = TEMP_FILE_SEQUENCE.fetch_add(1, Ordering::Relaxed);
-        std::env::temp_dir().join(format!(
-            "feltdb-convergence-test-{}-{nanos}-{sequence}.data",
-            std::process::id()
-        ))
-    }
-
-    /// Test convergence: Two instances make concurrent mutations on same key
-    /// Both should resolve to the same state deterministically
-    #[test]
-    fn test_concurrent_mutations_deterministic_convergence() {
-        // Instance A and B both write to the same task concurrently
-        let path_a = temp_file();
-        let path_b = temp_file();
-
-        let db_a = FeltDb::open(&path_a).expect("open db_a");
-        let db_b = FeltDb::open(&path_b).expect("open db_b");
-
-        // Both instances write to the same key concurrently
-        let task_a = Task {
-            title: "Complete task".to_string(),
-            status: "completed".to_string(),
-            assignee: "Alice".to_string(),
-        };
-
-        let task_b = Task {
-            title: "Complete task".to_string(),
-            status: "blocked".to_string(),
-            assignee: "Bob".to_string(),
-        };
-
-        // A writes first
-        db_a.insert("tasks:1", &task_a).expect("insert_a");
-
-        // B writes independently (concurrent)
-        db_b.insert("tasks:1", &task_b).expect("insert_b");
-
-        // Both instances have operations with vector clocks
-        let ops_a = db_a
-            .get_pending_for_peer("peer-b", 0)
-            .expect("get_pending_a");
-        let ops_b = db_b
-            .get_pending_for_peer("peer-a", 0)
-            .expect("get_pending_b");
-
-        assert_eq!(ops_a.len(), 1);
-        assert_eq!(ops_b.len(), 1);
-        assert!(ops_a[0].vector_clock.is_some());
-        assert!(ops_b[0].vector_clock.is_some());
-
-        // Simulate sync: A applies B's operation
-        db_a.apply_remote_operation(ops_b[0].clone())
-            .expect("apply_remote_to_a");
-
-        // Simulate sync: B applies A's operation
-        db_b.apply_remote_operation(ops_a[0].clone())
-            .expect("apply_remote_to_b");
-
-        // Both should have converged to the same state
-        // (Conflict resolution will pick one deterministically)
-        let final_task_a: Option<Task> = db_a.get("tasks:1").expect("get_final_a");
-        let final_task_b: Option<Task> = db_b.get("tasks:1").expect("get_final_b");
-
-        // Both should have the same final state (due to deterministic conflict resolution)
-        assert_eq!(final_task_a, final_task_b);
-
-        let _ = std::fs::remove_file(path_a);
-        let _ = std::fs::remove_file(path_b);
-
-        println!("✓ Convergence Test A passed: Concurrent mutations resolve deterministically");
-    }
-
-    /// Test convergence: Vector clocks correctly track causality
-    #[test]
-    fn test_vector_clock_causal_tracking() {
-        let path = temp_file();
-        let db = FeltDb::open(&path).expect("open");
-
-        // Create a chain of mutations
-        let task1 = Task {
-            title: "Task 1".to_string(),
-            status: "open".to_string(),
-            assignee: "Alice".to_string(),
-        };
-
-        db.insert("tasks:1", &task1).expect("insert_1");
-
-        let ops_1 = db.get_pending_for_peer("peer", 0).expect("get_pending_1");
-        assert_eq!(ops_1.len(), 1);
-        let vc_1 = ops_1[0].vector_clock.clone().expect("vc_1");
-
-        // Update the same task
-        let task1_updated = Task {
-            title: "Task 1".to_string(),
-            status: "in_progress".to_string(),
-            assignee: "Bob".to_string(),
-        };
-
-        db.update("tasks:1", &task1_updated).expect("update");
-
-        let ops_2 = db.get_pending_for_peer("peer", 1).expect("get_pending_2");
-        assert_eq!(ops_2.len(), 1);
-        let vc_2 = ops_2[0].vector_clock.clone().expect("vc_2");
-
-        // Vector clock should have incremented
-        assert!(
-            vc_2.get(&db.instance_id().expect("instance_id"))
-                > vc_1.get(&db.instance_id().expect("instance_id"))
-        );
-
-        let _ = std::fs::remove_file(path);
-
-        println!("✓ Convergence Test B passed: Vector clocks track causality correctly");
-    }
-
-    /// Test convergence: Operations flow through sync and are applied idempotently
-    #[test]
-    fn test_sync_idempotency_with_vector_clocks() {
-        let path_a = temp_file();
-        let path_b = temp_file();
-
-        let db_a = FeltDb::open(&path_a).expect("open db_a");
-        let db_b = FeltDb::open(&path_b).expect("open db_b");
-
-        // A writes a task
-        let task = Task {
-            title: "Sync test".to_string(),
-            status: "open".to_string(),
-            assignee: "Charlie".to_string(),
-        };
-
-        db_a.insert("tasks:100", &task).expect("insert");
-
-        // Get the operation
-        let ops = db_a.get_pending_for_peer("peer-b", 0).expect("get_pending");
-        assert_eq!(ops.len(), 1);
-        let op = ops[0].clone();
-
-        // B receives the operation
-        db_b.apply_remote_operation(op.clone()).expect("apply_1");
-
-        // Check B has the data
-        let task_b: Option<Task> = db_b.get("tasks:100").expect("get");
-        assert_eq!(task_b, Some(task.clone()));
-
-        // B receives the same operation again (duplicate delivery)
-        db_b.apply_remote_operation(op).expect("apply_2");
-
-        // B should still have the same state (idempotent)
-        let task_b_after: Option<Task> = db_b.get("tasks:100").expect("get_after");
-        assert_eq!(task_b_after, Some(task));
-
-        // B's vector clock should have been merged (not duplicated)
-        let vc_b = db_b.get_vector_clock().expect("get_vc").expect("vc");
-        assert!(vc_b.len() >= 1);
-
-        let _ = std::fs::remove_file(path_a);
-        let _ = std::fs::remove_file(path_b);
-
-        println!("✓ Convergence Test C passed: Operations are applied idempotently");
-    }
-
-    /// Test convergence: Deterministic resolution with synchronized operations
-    /// When all instances see the same set of concurrent operations,
-    /// they will all apply the same resolution
-    #[test]
-    fn test_three_way_convergence() {
-        let path_a = temp_file();
-        let path_b = temp_file();
-        let path_c = temp_file();
-
-        let db_a = FeltDb::open(&path_a).expect("open db_a");
-        let db_b = FeltDb::open(&path_b).expect("open db_b");
-        let db_c = FeltDb::open(&path_c).expect("open db_c");
-
-        // All three instances make the same mutation independently
-        let task_all = Task {
-            title: "3-way test".to_string(),
-            status: "open".to_string(),
-            assignee: "All".to_string(),
-        };
-        db_a.insert("tasks:200", &task_all).expect("insert_a");
-        db_b.insert("tasks:200", &task_all).expect("insert_b");
-        db_c.insert("tasks:200", &task_all).expect("insert_c");
-
-        // Get all operations
-        let ops_a = db_a.get_pending_for_peer("sync", 0).expect("ops_a");
-        let ops_b = db_b.get_pending_for_peer("sync", 0).expect("ops_b");
-        let ops_c = db_c.get_pending_for_peer("sync", 0).expect("ops_c");
-
-        // Sync: Each instance receives all others' operations
-        // A receives B and C
-        db_a.apply_remote_operation(ops_b[0].clone())
-            .expect("apply_b_to_a");
-        db_a.apply_remote_operation(ops_c[0].clone())
-            .expect("apply_c_to_a");
-
-        // B receives A and C
-        db_b.apply_remote_operation(ops_a[0].clone())
-            .expect("apply_a_to_b");
-        db_b.apply_remote_operation(ops_c[0].clone())
-            .expect("apply_c_to_b");
-
-        // C receives A and B
-        db_c.apply_remote_operation(ops_a[0].clone())
-            .expect("apply_a_to_c");
-        db_c.apply_remote_operation(ops_b[0].clone())
-            .expect("apply_b_to_c");
-
-        // All three should converge to same state (since they're writing same value)
-        let final_a: Option<Task> = db_a.get("tasks:200").expect("get_final_a");
-        let final_b: Option<Task> = db_b.get("tasks:200").expect("get_final_b");
-        let final_c: Option<Task> = db_c.get("tasks:200").expect("get_final_c");
-
-        assert_eq!(final_a, final_b);
-        assert_eq!(final_b, final_c);
-        assert_eq!(final_a, Some(task_all));
-
-        let _ = std::fs::remove_file(path_a);
-        let _ = std::fs::remove_file(path_b);
-        let _ = std::fs::remove_file(path_c);
-
-        println!("✓ Convergence Test D passed: Three-way sync converges all instances");
-    }
-}