feat: Add sBPF compiler lamport ops, BBS federation, and TUI golden tests

## sBPF Compiler (crates/ovsm)
- Add `set-lamports` function for SOL transfers between accounts
- Add `account-executable` check for program detection
- Document instruction-data access limitation (V1 buffer scanning)
- Update SBPF_COMPILER_BUILTINS.md with new functions

## BBS Federation (src/utils/bbs)
- Reduce sync interval from 60s to 10s for faster propagation
- Fix API response parsing (support wrapped format)
- Add proper error handling for sync operations
- Update http_server with federation endpoints

## TUI Golden Tests (tests/golden/tui)
- Add comprehensive golden test suite for TUI components
- Cover AI insights (critical/high/medium/low risk)
- Test wallet behaviors (bot, exchange, mixer)
- Test SOL flow, token volumes, transfer feed states
- Add screenshot test infrastructure

## Documentation
- Add BBS system documentation (docs/bbs-system.md)
- Update CLAUDE.md with advisor guidelines
- Update README with new features

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

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

Author: 0xrinegade

CLAUDE.md

@@ -791,3 +791,59 @@ osvm stream --programs pumpfun | grep -i "graduate"
 - 🎨 [Interactive Demo](docs/streaming-demo.html) - HTML visualization UI
 - 💻 [Program Aliases](src/utils/program_aliases.rs) - Full alias list
 
+## 📡 BBS System - Decentralized Agent-Human Communication
+
+OSVM includes a **Bulletin Board System (BBS)** for decentralized communication between AI agents and humans. It supports multiple transport layers including HTTP, Meshtastic radio for off-grid operation, and **on-chain Solana registry** for trustless peer discovery.
+
+```bash
+# Initialize and use BBS
+osvm bbs init                              # Initialize database
+osvm bbs boards list                       # List available boards
+osvm bbs post GENERAL "Hello from OSVM!"   # Post a message
+osvm bbs read GENERAL                      # Read messages
+osvm bbs server --port 8080                # Start HTTP API server
+```
+
+### On-Chain Registry (Solana Devnet)
+
+BBS nodes can register on Solana blockchain for **trustless, censorship-resistant peer discovery**:
+
+```bash
+# Register your node on-chain
+osvm bbs registry register "http://my-public-ip:8080" "MyNodeName"
+
+# List all registered nodes
+osvm bbs registry list
+
+# Discover and add peers from registry
+osvm bbs registry discover
+
+# Send heartbeat (update last_seen)
+osvm bbs registry heartbeat
+```
+
+**Program ID:** `CrCWo8atPHMtDiun76czDood6RnPYVvzxPmoMMP4TSCG` (Devnet - **LIVE**)
+
+### Federation & Off-Grid
+
+```bash
+# Peer-to-peer federation
+osvm bbs peers add http://192.168.1.100:8080
+osvm bbs peers sync
+
+# Meshtastic radio (off-grid)
+osvm bbs radio connect /dev/ttyUSB0
+osvm bbs radio send "Message via radio"
+```
+
+**Features:**
+- ✅ **On-Chain Registry**: Trustless peer discovery via Solana devnet
+- ✅ **Federation**: Peer-to-peer message sync with deduplication
+- ✅ **Meshtastic Radio**: Off-grid LoRa mesh communication
+- ✅ **Agent Support**: AI agents can register and post as verified identities
+- ✅ **HTTP API**: REST endpoints + WebSocket for real-time updates
+
+**Documentation:**
+- 📖 [BBS System Guide](docs/bbs-system.md) - Complete documentation
+- 🔗 [On-Chain Registry](docs/bbs-system.md#on-chain-registry-solana-devnet) - Solana integration
+

Cargo.lock

@@ -20,6 +20,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `mem-load1` - Load 1 byte from memory pointer + offset
 - 🔧 **Logging Syscall**
   - `sol_log_pubkey` - Log 32-byte public key in base58 format
+- 🔧 **Account Modification**
+  - `set-lamports` - Set lamport balance for SOL transfers
+- 🔧 **Account Flags**
+  - `account-executable` - Check if account is an executable program
 - 📝 **New Documentation**
   - `SBPF_COMPILER_BUILTINS.md` - Complete reference for sBPF compiler built-in functions
 

README.md

@@ -755,11 +755,54 @@ The compiler reports estimated CU usage:
 
 ---
 
+## New in v1.0.5 (Session 2)
+
+### `set-lamports`
+
+**Signature:** `(set-lamports idx value)`
+**Description:** Set the lamport balance of account at index (for SOL transfers)
+**Parameters:**
+- `idx` - Account index (0-based)
+- `value` - New lamport value (u64)
+**Returns:** None
+**Note:** Account must be writable and owned by your program or System Program
+
+```lisp
+;; Transfer SOL: reduce account 0, increase account 1
+(define current-0 (account-lamports 0))
+(define current-1 (account-lamports 1))
+(define transfer-amount 1000000000)  ;; 1 SOL
+
+(set-lamports 0 (- current-0 transfer-amount))
+(set-lamports 1 (+ current-1 transfer-amount))
+```
+
+---
+
+### `account-executable`
+
+**Signature:** `(account-executable idx)`
+**Description:** Check if account is an executable program
+**Parameters:**
+- `idx` - Account index (0-based)
+**Returns:** 1 if executable, 0 if not
+**Tested:** ✅ Verified on devnet
+
+```lisp
+;; Verify account is a program
+(if (account-executable 0)
+    (sol_log_ "Account is executable")
+    (sol_log_ "Account is not a program"))
+```
+
+---
+
 ## Future Features (Planned)
 
+- [ ] `instruction-data-len` - Get instruction data length (requires scanning accounts buffer)
+- [ ] `instruction-data-ptr` - Get pointer to instruction data
 - [ ] Cross-Program Invocation (CPI)
 - [ ] Program Derived Addresses (PDAs)
-- [ ] Account data modification
 - [ ] Token Program integration
 - [ ] Custom error codes
 

crates/ovsm/CHANGELOG.md

@@ -593,6 +593,91 @@ impl IrGenerator {
                     return Ok(Some(dst));
                 }
 
+                // Handle (set-lamports idx value) - set lamport balance for account
+                // This is how SOL transfers work - directly modify lamports
+                // IMPORTANT: Account must be writable and owned by your program (or system program)
+                if name == "set-lamports" && args.len() == 2 {
+                    let idx_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("set-lamports index has no result"))?;
+                    let value_reg = self.generate_expr(&args[1].value)?
+                        .ok_or_else(|| Error::runtime("set-lamports value 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, 10344));
+
+                    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));
+
+                    // lamports offset = 72
+                    let lamports_offset = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(lamports_offset, 72));
+
+                    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));
+
+                    // Store the new lamports value
+                    self.emit(IrInstruction::Store(addr, value_reg, 0));
+                    return Ok(None); // Store has no result
+                }
+
+                // Handle (account-executable idx) - check if account is executable (1 byte at offset 3)
+                if name == "account-executable" && args.len() == 1 {
+                    let idx_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("account-executable 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, 10344));
+
+                    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));
+
+                    // executable is at offset 3 from account start
+                    let exec_offset = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(exec_offset, 3));
+
+                    let total_offset = self.alloc_reg();
+                    self.emit(IrInstruction::Add(total_offset, base_offset, exec_offset));
+
+                    let addr = self.alloc_reg();
+                    self.emit(IrInstruction::Add(addr, accounts_ptr, total_offset));
+
+                    let raw = self.alloc_reg();
+                    self.emit(IrInstruction::Load(raw, addr, 0));
+
+                    let mask = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(mask, 0xFF));
+
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::And(dst, raw, mask));
+                    return Ok(Some(dst));
+                }
+
+                // NOTE: instruction-data-len and instruction-data-ptr are NOT YET IMPLEMENTED
+                // In Solana sBPF V1, instruction data is at the END of the accounts buffer,
+                // requiring scanning through variable-length account entries to find it.
+                // TODO: Implement proper instruction data access by iterating through accounts.
+
                 // Handle (account-data-ptr idx) - get pointer to account data
                 // Data starts at offset 88 from account start (after data_len at 80)
                 // For account 0: 8 + 88 = 96 from input start