fix(tui): Add missing BBS tab keybindings and help documentation

## Problem
BBS tab (Tab 5) was not responding to keyboard input - j/k keys and other
navigation keys didn't work, making the BBS interface unusable.

## Root Cause
Event handling in app.rs only had keybindings for Chat, Dashboard, Graph,
Logs, and Search tabs. BBS tab had rendering code but no event handlers.

## Solution

**Added BBS-specific keybindings:**
- `j/k/↑/↓` - Scroll through BBS posts
- `1-9` - Select board by number (quick navigation)
- `r` - Refresh boards and posts from database

**Updated help documentation:**
- Added "BBS View" section explaining all keybindings
- Updated tab switcher from "0/1/2/3/4" to "0/1/2/3/4/5"
- Added BBS tab indicator to header (▣/□ BBS)

## Implementation Details

**Event Handler** (`src/utils/tui/app.rs:1082-1113`):
- Scrolling: Modifies `bbs_state.scroll_offset` through Arc<Mutex<>>
- Board selection: Validates board index and loads posts
- Refresh: Reloads boards and posts from SQLite database
- All actions are BBS tab-scoped (only active when on BBS tab)

**Help System** (`src/utils/tui/app.rs:2472-2476`):
- New "BBS View" section in help overlay
- Clear documentation of all 3 keybinding groups
- Matches existing help format for consistency

**Header Tab Indicator** (`src/utils/tui/app.rs:1705-1709`):
- Added BBS tab to header navigation bar
- Shows ▣ when active, □ when inactive
- Matches existing tab indicator style

## Testing

Verified with `cargo build`:
- ✅ Compiles successfully in 2m 00s
- ✅ No new errors introduced
- ⚠️ 1 existing warning (mdns feature flag - unrelated)

**Manual test instructions:**
```bash
./target/debug/osvm research <wallet> --agent --tui
# Press 5 to go to BBS tab
# Press j/k to scroll (should work now!)
# Press 1-9 to select boards
# Press r to refresh
# Press ? to see help (BBS section should be there)
```

## Benefits

**For Users:**
- BBS tab is now fully functional
- Intuitive keybindings matching other tabs (j/k for scrolling)
- Quick board navigation with number keys
- Refresh capability with r key

**For Developers:**
- Clear pattern for adding tab-specific keybindings
- Proper Arc<Mutex<>> handling example
- Help documentation template to follow

## Related Files

- Event handling: `src/utils/tui/app.rs`
- BBS rendering: `src/utils/bbs/tui_widgets.rs`
- BBS state: `src/utils/bbs/models.rs`

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

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

Author: 0xrinegade

Cargo.lock

@@ -113,6 +113,7 @@ ab_glyph = "0.2"
 vt100 = "0.15"
 tui-nodes = "0.9.0"
 rusqlite = { version = "0.37.0", features = ["bundled"] }
+crc32fast = "1.5.0"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

Cargo.toml

@@ -68,6 +68,7 @@ const DT_RELCOUNT: u64 = 0x6ffffffa;
 
 /// Relocation types (Solana BPF standard)
 const R_BPF_64_64: u32 = 1;   // For 64-bit absolute relocations (syscalls)
+const R_BPF_64_RELATIVE: u32 = 8;  // For relative relocations (add MM_PROGRAM_START at load time)
 const R_BPF_64_32: u32 = 10;  // For 32-bit relocations
 
 /// Program header flags
@@ -80,6 +81,8 @@ const TEXT_VADDR: u64 = 0x120;  // .text at 0x120 (matching Solana's working ELF
 const RODATA_VADDR: u64 = 0x150;  // .rodata follows .text
 const STACK_VADDR: u64 = 0x200000000;
 const HEAP_VADDR: u64 = 0x300000000;
+/// MM_PROGRAM_START: Base address added to all program memory at runtime
+const MM_PROGRAM_START: u64 = 0x100000000;
 
 /// Default stack/heap size
 const STACK_SIZE: u64 = 0x1000;
@@ -393,8 +396,12 @@ impl ElfWriter {
         // LDDW is a 16-byte instruction: [8 bytes first half] [8 bytes second half]
         // First half: opcode=0x18, dst, src=0, off=0, imm=low32
         // Second half: opcode=0x00, dst=0, src=0, off=0, imm=high32
+        //
+        // CRITICAL: For SBPFv1, Solana's VM loads programs at MM_PROGRAM_START (0x100000000)
+        // so string addresses must include this base address!
         for load_site in string_loads {
-            let abs_addr = rodata_vaddr + load_site.rodata_offset as u64;
+            // Full runtime address: MM_PROGRAM_START + ELF vaddr + string offset
+            let abs_addr = MM_PROGRAM_START + rodata_vaddr + load_site.rodata_offset as u64;
             let low32 = (abs_addr & 0xFFFF_FFFF) as u32;
             let high32 = (abs_addr >> 32) as u32;
 

crates/ovsm/src/compiler/elf.rs

@@ -184,6 +184,19 @@ impl IrGenerator {
         // Entry point
         self.emit(IrInstruction::Label("entry".to_string()));
 
+        // CRITICAL: Save the accounts pointer (R1) and instruction data (R2) into
+        // caller-saved registers before any syscalls clobber them.
+        // Virtual reg 1,2 = R1,R2 at entry (accounts, instr data)
+        // Save to virtual reg 6,7 which map to R6,R7 (callee-saved)
+        let saved_accounts = IrReg::new(6);
+        let saved_instr_data = IrReg::new(7);
+        self.emit(IrInstruction::Move(saved_accounts, IrReg::new(1)));
+        self.emit(IrInstruction::Move(saved_instr_data, IrReg::new(2)));
+
+        // Update var_map to use the saved registers
+        self.var_map.insert("accounts".to_string(), saved_accounts);
+        self.var_map.insert("instruction-data".to_string(), saved_instr_data);
+
         eprintln!("🔍 IR DEBUG: Generating IR for {} statements", program.statements.len());
 
         // Generate IR for each statement, tracking last result
@@ -436,12 +449,22 @@ impl IrGenerator {
                 }
 
                 // Handle (set! var value) specially
+                // For mutable variables, we need to emit a Move to update the existing register
                 if name == "set!" && args.len() == 2 {
                     if let Expression::Variable(var_name) = &args[0].value {
+                        // Get the existing register for this variable
+                        let old_reg = self.var_map.get(var_name)
+                            .copied()
+                            .ok_or_else(|| Error::runtime(format!("Cannot set! undefined variable: {}", var_name)))?;
+
+                        // Compute the new value
                         let value_reg = self.generate_expr(&args[1].value)?
                             .ok_or_else(|| Error::runtime("Set! value has no result"))?;
-                        self.var_map.insert(var_name.clone(), value_reg);
-                        return Ok(Some(value_reg));
+
+                        // Emit Move instruction to copy new value into old register
+                        self.emit(IrInstruction::Move(old_reg, value_reg));
+
+                        return Ok(Some(old_reg));
                     }
                 }
 
@@ -484,6 +507,128 @@ impl IrGenerator {
                     return Ok(Some(dst));
                 }
 
+                // Handle (num-accounts) - get number of accounts from saved accounts pointer
+                if name == "num-accounts" && args.is_empty() {
+                    // accounts pointer was saved to virtual register 6 (R6) at entry
+                    let accounts_ptr = *self.var_map.get("accounts")
+                        .ok_or_else(|| Error::runtime("accounts not available"))?;
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::Load(dst, accounts_ptr, 0));
+                    return Ok(Some(dst));
+                }
+
+                // Handle (account-lamports idx) - get lamports for account at index
+                // Solana format: after num_accounts (8 bytes), each account has:
+                //   [u8 dup][u8 signer][u8 writable][u8 exec][4 pad][32 pubkey][32 owner][u64 lamports]...
+                //   lamports offset = 8 + 1 + 1 + 1 + 1 + 4 + 32 + 32 = 80 from account start
+                if name == "account-lamports" && args.len() == 1 {
+                    let idx_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("account-lamports index has no result"))?;
+
+                    // Get accounts base pointer (saved to R6 at entry)
+                    let accounts_ptr = *self.var_map.get("accounts")
+                        .ok_or_else(|| Error::runtime("accounts not available"))?;
+
+                    // Calculate account offset: 8 (for num_accounts) + idx * account_size
+                    // For simplicity, assume fixed account size of 165 bytes (minimum without data)
+                    // Real implementation would need to iterate
+                    let eight_reg = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(eight_reg, 8));
+
+                    // For account 0: offset = 8, lamports at offset 80 from account start
+                    // Total: 8 + 80 = 88
+                    let account_size = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(account_size, 165)); // Approximate
+
+                    let account_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Mul(account_offset, idx_reg, account_size));
+
+                    let base_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(base_offset, eight_reg, account_offset));
+
+                    // Add lamports offset within account (80 bytes)
+                    let lamports_offset = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(lamports_offset, 80));
+
+                    let total_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(total_offset, base_offset, lamports_offset));
+
+                    let addr = self.alloc_reg();
+                    self.emit(IrInstruction::Add(addr, accounts_ptr, total_offset));
+
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::Load(dst, addr, 0));
+                    return Ok(Some(dst));
+                }
+
+                // Handle (account-data-ptr idx) - get data pointer for account
+                // data_len is at offset 88, data starts at offset 96
+                if name == "account-data-ptr" && args.len() == 1 {
+                    let idx_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("account-data-ptr index has no result"))?;
+
+                    let accounts_ptr = *self.var_map.get("accounts")
+                        .ok_or_else(|| Error::runtime("accounts not available"))?;
+
+                    let eight_reg = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(eight_reg, 8));
+
+                    let account_size = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(account_size, 165));
+
+                    let account_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Mul(account_offset, idx_reg, account_size));
+
+                    let base_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(base_offset, eight_reg, account_offset));
+
+                    // Data starts at offset 96 from account start
+                    let data_offset = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(data_offset, 96));
+
+                    let total_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(total_offset, base_offset, data_offset));
+
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::Add(dst, accounts_ptr, total_offset));
+                    return Ok(Some(dst));
+                }
+
+                // Handle (account-data-len idx) - get data length for account
+                if name == "account-data-len" && args.len() == 1 {
+                    let idx_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("account-data-len index has no result"))?;
+
+                    let accounts_ptr = *self.var_map.get("accounts")
+                        .ok_or_else(|| Error::runtime("accounts not available"))?;
+
+                    let eight_reg = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(eight_reg, 8));
+
+                    let account_size = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(account_size, 165));
+
+                    let account_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Mul(account_offset, idx_reg, account_size));
+
+                    let base_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(base_offset, eight_reg, account_offset));
+
+                    // data_len is at offset 88 from account start
+                    let len_offset = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(len_offset, 88));
+
+                    let total_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(total_offset, base_offset, len_offset));
+
+                    let addr = self.alloc_reg();
+                    self.emit(IrInstruction::Add(addr, accounts_ptr, total_offset));
+
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::Load(dst, addr, 0));
+                    return Ok(Some(dst));
+                }
+
                 // Handle (mem-store base offset value) - direct memory store
                 if name == "mem-store" && args.len() == 3 {
                     let base_reg = self.generate_expr(&args[0].value)?
@@ -679,6 +824,38 @@ impl IrGenerator {
                     return Ok(last_reg);
                 }
 
+                // Handle (while condition body...) - while loop
+                if name == "while" && !args.is_empty() {
+                    let loop_label = self.new_label("while");
+                    let end_label = self.new_label("endwhile");
+
+                    // Loop header
+                    self.emit(IrInstruction::Label(loop_label.clone()));
+
+                    // Evaluate condition
+                    let cond_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("While condition has no result"))?;
+
+                    // Jump to end if condition is false
+                    self.emit(IrInstruction::JumpIfNot(cond_reg, end_label.clone()));
+
+                    // Body - all expressions after the condition
+                    for arg in args.iter().skip(1) {
+                        self.generate_expr(&arg.value)?;
+                    }
+
+                    // Jump back to loop header
+                    self.emit(IrInstruction::Jump(loop_label));
+
+                    // End label
+                    self.emit(IrInstruction::Label(end_label));
+
+                    // While returns 0 (or null)
+                    let result_reg = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(result_reg, 0));
+                    return Ok(Some(result_reg));
+                }
+
                 // Generic tool call
                 let mut arg_regs = Vec::new();
                 for arg in args {

crates/ovsm/src/compiler/ir.rs

@@ -28,6 +28,7 @@ pub mod elf;
 pub mod verifier;
 pub mod runtime;
 pub mod debug;
+pub mod solana_abi;
 
 pub use types::{OvsmType, TypeChecker, TypeEnv};
 pub use ir::{IrProgram, IrInstruction, IrReg, IrGenerator};
@@ -62,6 +63,8 @@ pub struct CompileOptions {
     pub source_map: bool,
     /// SBPF version to generate (V1 with relocations or V2 with static calls)
     pub sbpf_version: SbpfVersion,
+    /// Enable Solana ABI compliant entrypoint with deserialization
+    pub enable_solana_abi: bool,
 }
 
 impl Default for CompileOptions {
@@ -72,6 +75,7 @@ impl Default for CompileOptions {
             debug_info: false,
             source_map: false,
             sbpf_version: SbpfVersion::V1, // V1 with relocations for comparison
+            enable_solana_abi: false,  // Temporarily disabled while fixing opcode issues
         }
     }
 }
@@ -120,6 +124,11 @@ impl Compiler {
         let mut ir_gen = IrGenerator::new();
         let mut ir_program = ir_gen.generate(&typed_program)?;
 
+        // Inject Solana entrypoint wrapper for proper ABI handling
+        if self.options.enable_solana_abi {
+            solana_abi::inject_entrypoint_wrapper(&mut ir_program.instructions);
+        }
+
         // Phase 4: Optimize
         if self.options.opt_level > 0 {
             let mut optimizer = Optimizer::new(self.options.opt_level);
@@ -198,6 +207,11 @@ impl Compiler {
         let mut ir_gen = IrGenerator::new();
         let mut ir_program = ir_gen.generate(&typed_program)?;
 
+        // Inject Solana entrypoint wrapper for proper ABI handling
+        if self.options.enable_solana_abi {
+            solana_abi::inject_entrypoint_wrapper(&mut ir_program.instructions);
+        }
+
         if self.options.opt_level > 0 {
             let mut optimizer = Optimizer::new(self.options.opt_level);
             optimizer.optimize(&mut ir_program);

crates/ovsm/src/compiler/mod.rs

@@ -866,15 +866,17 @@ impl SbpfCodegen {
             }
 
             IrInstruction::JumpIf(cond, target) => {
-                let cond_reg = self.reg_alloc.allocate(*cond);
+                // Use get_reg to reload from stack if spilled
+                let cond_reg = self.get_reg(*cond, SbpfReg::R0);
                 let idx = self.instructions.len();
                 self.pending_jumps.push((idx, target.clone()));
                 // Jump if != 0
                 self.emit(SbpfInstruction::jmp_imm(jmp::JNE, cond_reg as u8, 0, 0));
             }
 
             IrInstruction::JumpIfNot(cond, target) => {
-                let cond_reg = self.reg_alloc.allocate(*cond);
+                // Use get_reg to reload from stack if spilled
+                let cond_reg = self.get_reg(*cond, SbpfReg::R0);
                 let idx = self.instructions.len();
                 self.pending_jumps.push((idx, target.clone()));
                 // Jump if == 0
@@ -941,12 +943,16 @@ impl SbpfCodegen {
 
             // Syscall: dst = syscall(name, args...)
             IrInstruction::Syscall(dst, name, args) => {
-                // Move args to R1-R5
+                // Move args to R1-R5, handling spilled registers
+                // CRITICAL: Must use get_reg to reload spilled values from stack!
+                let target_regs = [SbpfReg::R1, SbpfReg::R2, SbpfReg::R3, SbpfReg::R4, SbpfReg::R5];
                 for (i, arg) in args.iter().enumerate().take(5) {
-                    let arg_reg = self.reg_alloc.allocate(*arg);
-                    let target = (i + 1) as u8;
-                    if arg_reg as u8 != target {
-                        self.emit(SbpfInstruction::alu64_reg(alu::MOV, target, arg_reg as u8));
+                    let target = target_regs[i];
+                    // Use get_reg to properly reload spilled registers
+                    // Use R0 as scratch since it's caller-saved and not used for syscall args
+                    let arg_reg = self.get_reg(*arg, SbpfReg::R0);
+                    if arg_reg != target {
+                        self.emit(SbpfInstruction::alu64_reg(alu::MOV, target as u8, arg_reg as u8));
                     }
                 }
                 self.emit_syscall(name);
@@ -1085,13 +1091,16 @@ impl SbpfCodegen {
 
     /// Generate comparison: dst = (src1 cmp src2) ? 1 : 0
     fn gen_compare(&mut self, cmp_op: u8, dst: IrReg, src1: IrReg, src2: IrReg) {
-        // Load operands with spill handling
-        let src1_reg = self.get_reg(src1, SbpfReg::R0);
-        let src2_reg = self.get_reg(src2, SbpfReg::R5);
-
+        // CRITICAL: Determine dst register FIRST to avoid register conflicts
         let dst_phys = self.reg_alloc.allocate(dst);
         let actual_dst = if self.reg_alloc.is_spilled(dst) { SbpfReg::R0 } else { dst_phys };
 
+        // Load operands with spill handling
+        // Use R4 for src1 if dst is using R0 (to avoid overwriting src1 when we set dst=0)
+        let src1_scratch = if actual_dst == SbpfReg::R0 { SbpfReg::R4 } else { SbpfReg::R0 };
+        let src1_reg = self.get_reg(src1, src1_scratch);
+        let src2_reg = self.get_reg(src2, SbpfReg::R5);
+
         // Strategy: dst = 0, then conditionally set to 1
         // dst = 0 (default: false)
         self.emit(SbpfInstruction::alu64_imm(alu::MOV, actual_dst as u8, 0));