feat: Major updates across OVSM compiler, BBS federation, and research tooling

OVSM Compiler:
- Enhanced IR generator with improved macro handling
- Updated verifier with better diagnostics
- Reorganized AEA protocol into aea/ directory with new modules:
  - aea_agent_brain.ovsm: Agent cognitive architecture
  - aea_economics_tests.ovsm: Economic simulation tests
  - aea_game_theory.ovsm: Game-theoretic decision models
  - aea_governance.ovsm: Decentralized governance primitives
  - aea_negotiation.ovsm: Multi-party negotiation protocols

BBS System:
- Added voting system with db/votes.rs backend
- Enhanced HTTP server with WebSocket support
- Improved federation with peer sync and gossip
- Extended models for richer post metadata

Research Command:
- Major enhancements to research tooling
- Improved MCP pool integration
- Better CLI argument parsing

All changes compile successfully with cargo check.

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

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

Author: 0xrinegade

crates/ovsm/src/compiler/ir/generator.rs

@@ -1472,31 +1472,49 @@ impl IrGenerator {
                 }
 
                 // Handle (mem-store base offset value) - direct memory store
+                // Supports both constant and dynamic offsets
                 if name == "mem-store" && args.len() == 3 {
                     let base_reg = self.generate_expr(&args[0].value)?
                         .ok_or_else(|| Error::runtime("mem-store base has no result"))?;
-                    let offset = match &args[1].value {
-                        Expression::IntLiteral(n) => *n,
-                        _ => return Err(Error::runtime("mem-store offset must be constant")),
-                    };
                     let value_reg = self.generate_expr(&args[2].value)?
                         .ok_or_else(|| Error::runtime("mem-store value has no result"))?;
-                    self.emit(IrInstruction::Store(base_reg, value_reg, offset));
+
+                    // Try constant offset first (most common case)
+                    if let Expression::IntLiteral(offset) = &args[1].value {
+                        self.emit(IrInstruction::Store(base_reg, value_reg, *offset));
+                    } else {
+                        // Dynamic offset: compute effective address = base + offset
+                        let offset_reg = self.generate_expr(&args[1].value)?
+                            .ok_or_else(|| Error::runtime("mem-store offset has no result"))?;
+                        let addr_reg = self.alloc_reg();
+                        self.emit(IrInstruction::Add(addr_reg, base_reg, offset_reg));
+                        // Store at computed address with 0 offset
+                        self.emit(IrInstruction::Store(addr_reg, value_reg, 0));
+                    }
                     return Ok(None); // Store has no result
                 }
 
                 // Handle (mem-store1 base offset value) - store 1 byte to memory
                 // Stores the low byte of value at ptr+offset
+                // Supports both constant and dynamic offsets
                 if name == "mem-store1" && args.len() == 3 {
                     let base_reg = self.generate_expr(&args[0].value)?
                         .ok_or_else(|| Error::runtime("mem-store1 base has no result"))?;
-                    let offset = match &args[1].value {
-                        Expression::IntLiteral(n) => *n,
-                        _ => return Err(Error::runtime("mem-store1 offset must be constant")),
-                    };
                     let value_reg = self.generate_expr(&args[2].value)?
                         .ok_or_else(|| Error::runtime("mem-store1 value has no result"))?;
-                    self.emit(IrInstruction::Store1(base_reg, value_reg, offset));
+
+                    // Try constant offset first (most common case)
+                    if let Expression::IntLiteral(offset) = &args[1].value {
+                        self.emit(IrInstruction::Store1(base_reg, value_reg, *offset));
+                    } else {
+                        // Dynamic offset: compute effective address = base + offset
+                        let offset_reg = self.generate_expr(&args[1].value)?
+                            .ok_or_else(|| Error::runtime("mem-store1 offset has no result"))?;
+                        let addr_reg = self.alloc_reg();
+                        self.emit(IrInstruction::Add(addr_reg, base_reg, offset_reg));
+                        // Store at computed address with 0 offset
+                        self.emit(IrInstruction::Store1(addr_reg, value_reg, 0));
+                    }
                     return Ok(None); // Store has no result
                 }
 
@@ -5751,18 +5769,26 @@ impl IrGenerator {
                 self.emit(IrInstruction::JumpIf(cond_reg, then_label.clone()));
                 self.emit(IrInstruction::Jump(else_label.clone()));
 
-                // Then
+                // Then - if branch returns None, use 0 (null) as default value
                 self.emit(IrInstruction::Label(then_label));
-                let then_reg = self.generate_expr(then_expr)?
-                    .ok_or_else(|| Error::runtime("Ternary then has no result"))?;
-                self.emit(IrInstruction::Move(result_reg, then_reg));
+                let then_result = self.generate_expr(then_expr)?;
+                if let Some(then_reg) = then_result {
+                    self.emit(IrInstruction::Move(result_reg, then_reg));
+                } else {
+                    // Side-effect only branch - use null (0) as value
+                    self.emit(IrInstruction::ConstNull(result_reg));
+                }
                 self.emit(IrInstruction::Jump(end_label.clone()));
 
-                // Else
+                // Else - if branch returns None, use 0 (null) as default value
                 self.emit(IrInstruction::Label(else_label));
-                let else_reg = self.generate_expr(else_expr)?
-                    .ok_or_else(|| Error::runtime("Ternary else has no result"))?;
-                self.emit(IrInstruction::Move(result_reg, else_reg));
+                let else_result = self.generate_expr(else_expr)?;
+                if let Some(else_reg) = else_result {
+                    self.emit(IrInstruction::Move(result_reg, else_reg));
+                } else {
+                    // Side-effect only branch - use null (0) as value
+                    self.emit(IrInstruction::ConstNull(result_reg));
+                }
 
                 // End
                 self.emit(IrInstruction::Label(end_label));

crates/ovsm/src/compiler/verifier.rs

@@ -161,6 +161,16 @@ impl Verifier {
         let mut has_exit = false;
         let mut offset = 0;
 
+        // Build slot-to-instruction mapping for proper jump validation
+        // LDDW instructions take 2 slots, all others take 1 slot
+        let mut slot_positions: Vec<usize> = Vec::with_capacity(program.len());
+        let mut current_slot: usize = 0;
+        for instr in program.iter() {
+            slot_positions.push(current_slot);
+            current_slot += instr.size() / 8; // LDDW = 2, others = 1
+        }
+        let total_slots = current_slot;
+
         for (idx, instr) in program.iter().enumerate() {
             // Check for exit instruction
             if instr.opcode == 0x95 {
@@ -181,13 +191,16 @@ impl Verifier {
                 });
             }
 
-            // Check jump targets
+            // Check jump targets using slot-based coordinates
+            // sBPF jump semantics: PC = current_slot + 1 + offset
+            // LDDW advances PC by 2, others by 1
             if self.is_jump_opcode(instr.opcode) && instr.opcode != 0x95 {
-                let target = idx as i64 + 1 + instr.offset as i64;
-                if target < 0 || target as usize >= program.len() {
+                let current_slot_pos = slot_positions[idx];
+                let target_slot = current_slot_pos as i64 + 1 + instr.offset as i64;
+                if target_slot < 0 || target_slot as usize > total_slots {
                     errors.push(VerifyError::JumpOutOfBounds {
                         offset,
-                        target,
+                        target: target_slot,
                     });
                 }
             }