feat(tui): Add AI Chat interface as default tab and Meshtastic BBS integration

## AI Chat Interface (Tenere-inspired)

**Primary Feature: Chat Tab (Tab 0)**
- New default view when launching research dashboard
- Full conversation history with user/assistant message styling
- Vim-inspired input system (i to activate, Enter to send, Esc to cancel)
- Smart scrolling with j/k navigation and auto-scroll to new messages
- Visual status indicators (⏳ Sending, ✓ Delivered, ⋯ Streaming, ✗ Error)
- Welcome message with example blockchain investigation queries

**Data Structures:**
- `ChatMessage` struct with role, content, timestamp, and MessageStatus
- `MessageStatus` enum for state management
- Thread-safe `Arc<Mutex<Vec<ChatMessage>>>` for message storage

**UI Components:**
- `render_chat()` - Main chat layout with header, messages, input, and status bar
- `render_chat_messages()` - Scrollable message display with proper styling
- `render_chat_input()` - Input box with active/inactive states and cursor

**Keybindings:**
- `0` - Switch to Chat tab (new)
- `i` - Activate chat input mode
- `Enter` - Send message (when in input mode)
- `Esc` - Cancel input
- `j/k` - Scroll chat history (when not typing)
- `Backspace` - Delete characters

**Tab Navigation Updates:**
- Chat is Tab 0 (default), Dashboard is Tab 1, Graph is Tab 2, Logs is Tab 3, Search is Tab 4, BBS is Tab 5
- Updated `next_tab()` and `previous_tab()` to include Chat in cycle
- Updated header tab indicators with Chat tab icon
- Updated help documentation with new tab numbers and Chat keybindings

## Meshtastic BBS Integration (Tab 5)

**New BBS Tab for Agent-Human Communication:**
- Meshtastic-based bulletin board system for off-grid communication
- `BBSTuiState` for managing BBS UI state
- Integration with existing BBS infrastructure (boards, posts, moderators)

**New Files:**
- `src/clparse/bbs.rs` - BBS command-line parsing
- `src/commands/bbs_handler.rs` - BBS command handling
- `src/utils/bbs/db/moderators.rs` - Moderator database operations
- `src/utils/bbs/meshtastic.rs` - Meshtastic protocol integration

**Modified Files:**
- `src/utils/tui/app.rs` - Main TUI updates for both Chat and BBS
- `src/utils/bbs/*` - BBS module enhancements
- `src/clparse.rs` - Command parsing for BBS
- `src/commands/mod.rs` - BBS command routing
- `src/main.rs` - BBS initialization
- `crates/ovsm/src/compiler/ir.rs` - Compiler improvements

**Architecture:**
- Modular BBS system with separate database, models, schema, and TUI widgets
- Ready for research agent integration via `send_chat_message()` method
- Clean separation between Chat (AI research) and BBS (human messaging)

**Build Status:** ✅ Compiled successfully with no errors or warnings

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

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

Author: 0xrinegade

crates/ovsm/src/compiler/ir.rs

@@ -184,9 +184,12 @@ impl IrGenerator {
         // Entry point
         self.emit(IrInstruction::Label("entry".to_string()));
 
+        eprintln!("🔍 IR DEBUG: Generating IR for {} statements", program.statements.len());
+
         // Generate IR for each statement, tracking last result
         let mut _last_result: Option<IrReg> = None;
-        for typed_stmt in &program.statements {
+        for (i, typed_stmt) in program.statements.iter().enumerate() {
+            eprintln!("  Statement {}: {:?}", i, typed_stmt.statement);
             _last_result = self.generate_statement(&typed_stmt.statement)?;
         }
 
@@ -562,6 +565,111 @@ impl IrGenerator {
                     return Ok(Some(dst));
                 }
 
+                // Handle (log :message msg :value val) - keyword-arg logging with sol_log_ syscall
+                if name == "log" {
+                    eprintln!("🔍 IR DEBUG: log handler called with {} args", args.len());
+                    for (i, arg) in args.iter().enumerate() {
+                        eprintln!("  arg[{}]: name={:?}, value type={:?}", i, arg.name, arg.value);
+                    }
+                    // Parse keyword arguments
+                    let mut message_expr: Option<&Expression> = None;
+                    let mut value_expr: Option<&Expression> = None;
+
+                    for arg in args {
+                        if let Some(ref kw) = arg.name {
+                            match kw.as_str() {
+                                "message" => message_expr = Some(&arg.value),
+                                "value" => value_expr = Some(&arg.value),
+                                _ => {} // Ignore unknown keywords
+                            }
+                        }
+                    }
+
+                    // Build the log message
+                    let mut log_parts = Vec::new();
+
+                    // Add message part if present
+                    if let Some(msg_expr) = message_expr {
+                        match msg_expr {
+                            Expression::StringLiteral(s) => {
+                                log_parts.push(s.clone());
+                            }
+                            _ => {
+                                // For non-literals, evaluate and try to convert
+                                // For now, we'll just skip non-string literals
+                                // TODO: Add runtime string formatting
+                                return Err(Error::runtime(
+                                    "log :message must be a string literal for compilation"
+                                ));
+                            }
+                        }
+                    }
+
+                    // Add value part if present
+                    if let Some(val_expr) = value_expr {
+                        match val_expr {
+                            Expression::IntLiteral(n) => {
+                                log_parts.push(n.to_string());
+                            }
+                            Expression::FloatLiteral(f) => {
+                                log_parts.push(f.to_string());
+                            }
+                            Expression::BoolLiteral(b) => {
+                                log_parts.push(b.to_string());
+                            }
+                            Expression::StringLiteral(s) => {
+                                log_parts.push(s.clone());
+                            }
+                            _ => {
+                                // For dynamic values, use sol_log_64_ syscall instead
+                                // Evaluate the value expression
+                                let val_reg = self.generate_expr(val_expr)?
+                                    .ok_or_else(|| Error::runtime("log value has no result"))?;
+
+                                // If we have a message, log it first with sol_log_
+                                if !log_parts.is_empty() {
+                                    let msg = log_parts.join(" ");
+                                    let idx = self.strings.len();
+                                    self.strings.push(msg.clone());
+                                    let msg_reg = self.alloc_reg();
+                                    self.emit(IrInstruction::ConstString(msg_reg, idx));
+                                    self.emit(IrInstruction::Log(msg_reg, msg.len()));
+                                }
+
+                                // Then log the dynamic value with sol_log_64_
+                                let dst = self.alloc_reg();
+                                self.emit(IrInstruction::Syscall(
+                                    Some(dst),
+                                    "sol_log_64_".to_string(),
+                                    vec![val_reg],
+                                ));
+                                return Ok(Some(dst));
+                            }
+                        }
+                    }
+
+                    // If we have any log parts, emit a single Log instruction
+                    if !log_parts.is_empty() {
+                        let full_message = log_parts.join(" ");
+                        let idx = self.strings.len();
+                        self.strings.push(full_message.clone());
+
+                        let msg_reg = self.alloc_reg();
+                        self.emit(IrInstruction::ConstString(msg_reg, idx));
+                        self.emit(IrInstruction::Log(msg_reg, full_message.len()));
+
+                        // Return success register
+                        let dst = self.alloc_reg();
+                        self.emit(IrInstruction::ConstI64(dst, 0));
+                        return Ok(Some(dst));
+                    } else {
+                        // No arguments - just return success
+                        let dst = self.alloc_reg();
+                        self.emit(IrInstruction::ConstI64(dst, 0));
+                        return Ok(Some(dst));
+                    }
+                }
+
                 // Handle (do expr1 expr2 ... exprN) - sequence of expressions, return last
                 if name == "do" {
                     let mut last_reg = None;

src/clparse.rs

@@ -7,6 +7,7 @@ use {
 mod agent;
 mod audit;
 mod balance;
+mod bbs;
 mod chat;
 mod database;
 mod deploy;
@@ -263,6 +264,7 @@ Issues & feedback: https://github.com/opensvm/osvm-cli/issues",
         )
         // Core commands - using modular builders
         .subcommand(balance::build_balance_command())
+        .subcommand(bbs::build_bbs_command())
         .subcommand(rpc::build_rpc_command())
         .subcommand(examples::build_examples_command())
         .subcommand(chat::build_chat_command())