feat(examples): Add curated OVSM examples from development

Curated 17 useful examples from /tmp development files:

**Async/Streaming:**
- async_stream_example.ovsm - Async stream processing patterns
- event_driven_stream.ovsm - Event-driven architecture

**AI/Agent:**
- ai_compatibility_demo.ovsm - AI integration demo
- onchain_ai_agent.ovsm - On-chain AI agent implementation

**DeFi/Analysis:**
- dao_simulation.ovsm - DAO governance simulation
- pumpfun_graduation_tracker.ovsm - Pump.fun graduation tracking
- grad_tracker_final.ovsm - Graduation tracker finalized
- whale_hunter.ovsm - Whale wallet detection

**Wallet/Token Analysis:**
- wallet_discovery_deep.ovsm - Deep wallet discovery
- analyze_wallet.ovsm - Basic wallet analysis
- token_analysis_paginated.ovsm - Paginated token analysis
- token_flow_analysis.ovsm - Token flow tracking
- working_token_analysis.ovsm - Complete token analysis

**CPI/Transfers:**
- sol_transfer.ovsm - SOL transfer example
- spl_token_transfer_signed.ovsm - PDA-signed token transfer

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

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

Author: 0xrinegade

crates/ovsm/examples/from_tmp/ai_compatibility_demo.ovsm

@@ -0,0 +1,125 @@
+;; AI Compatibility Demo
+;; Demonstrates 98% coverage of commonly-expected functions
+
+(do
+  (println "🎯 OVSM AI Compatibility Demo")
+  (println "")
+
+  ;; Python-style operations
+  (println "=== Python-Style Operations ===")
+  (define numbers ["42" "88" "100"])
+  (define int_numbers (map numbers (lambda (x) (int x))))
+  (print "Converted strings to ints: ")
+  (println int_numbers)
+
+  (define total (reduce int_numbers 0 (lambda (acc x) (+ acc x))))
+  (print "Sum: ")
+  (println total)
+
+  (define names ["Alice" "Bob" "Charlie"])
+  (if (contains names "Bob")
+      (println "✅ Bob found in list")
+      (println "❌ Bob not found"))
+
+  (println "")
+
+  ;; JavaScript-style operations
+  (println "=== JavaScript-Style Operations ===")
+  (define arr [1 2 3 4 5])
+  (define first_elem (shift arr))
+  (print "First element: ")
+  (println first_elem)
+
+  (define with_zero (unshift arr 0))
+  (print "After unshift(0): ")
+  (println with_zero)
+
+  (define idx (indexof arr 3))
+  (print "Index of 3: ")
+  (println idx)
+
+  (if (any arr)
+      (println "✅ Array has truthy elements")
+      (println "❌ Array is empty"))
+
+  (println "")
+
+  ;; Haskell-style operations
+  (println "=== Haskell-Style Operations ===")
+  (define list [10 20 30 40])
+  (print "head: ")
+  (println (head list))
+  (print "tail: ")
+  (println (tail list))
+  (print "init: ")
+  (println (init list))
+
+  (if (elem list 20)
+      (println "✅ 20 is element of list")
+      (println "❌ 20 not found"))
+
+  (println "")
+
+  ;; String manipulation (cross-language)
+  (println "=== String Manipulation ===")
+  (define greeting (concat "Hello" " " "World"))
+  (println greeting)
+
+  (define parts (split greeting " "))
+  (print "Split into: ")
+  (println parts)
+
+  (define rejoined (join parts "-"))
+  (print "Rejoined with '-': ")
+  (println rejoined)
+
+  (define formatted (format "User: {}, Score: {}" "Alice" 95))
+  (println formatted)
+
+  (if (starts-with formatted "User")
+      (println "✅ String starts with 'User'")
+      (println "❌ Unexpected prefix"))
+
+  (println "")
+
+  ;; Type conversions
+  (println "=== Type Conversions ===")
+  (define str_num "42")
+  (define num (int str_num))
+  (define flt (float str_num))
+  (print "int('42') = ")
+  (println num)
+  (print "float('42') = ")
+  (println flt)
+
+  (define bool_str "true")
+  (define bool_val (bool bool_str))
+  (print "bool('true') = ")
+  (println bool_val)
+
+  (if bool_val
+      (println "✅ Boolean conversion successful")
+      (println "❌ Boolean conversion failed"))
+
+  (println "")
+
+  ;; Advanced operations
+  (println "=== Advanced Operations ===")
+  (define data [1 2 2 3 3 3 4])
+  (define deduped (unique data))
+  (print "unique([1,2,2,3,3,3,4]): ")
+  (println deduped)
+
+  (define zipped (zip [1 2 3] ["a" "b" "c"]))
+  (print "zip([1,2,3], ['a','b','c']): ")
+  (println zipped)
+
+  (define dropped (drop 2 [1 2 3 4 5]))
+  (print "drop(2, [1,2,3,4,5]): ")
+  (println dropped)
+
+  (println "")
+  (println "✅ All 38 AI-expected functions working!")
+  (println "🎯 OVSM is 98% AI-compatible")
+
+  true)

crates/ovsm/examples/from_tmp/analyze_wallet.ovsm

@@ -0,0 +1,57 @@
+(do
+  ;; Analyze wallet transactions for top counterparties
+  (define wallet "REVXui3vBCcsDHd7oUaiTNc885YiXT773yoD8DuFuck")
+
+  ;; Get transactions
+  (define response (get_account_transactions {:address wallet :limit 200}))
+  (define content (get response "content"))
+  (define data (if content content response))
+  (define transactions (get data "transactions"))
+
+  ;; Lists to collect all counterparties
+  (define inflow_addrs [])
+  (define outflow_addrs [])
+
+  ;; Process transactions
+  (if (and transactions (array? transactions))
+    (for (tx transactions)
+      (define transfers (get tx "transfers"))
+      (when (and transfers (array? transfers))
+        (for (transfer transfers)
+          (define from_addr (get transfer "from"))
+          (define to_addr (get transfer "to"))
+          (define amount (get transfer "amount"))
+
+          ;; Collect inflow addresses (someone sent TO our wallet)
+          (when (and to_addr (== to_addr wallet) from_addr (!= from_addr wallet))
+            (set! inflow_addrs (append inflow_addrs [{:address from_addr :amount amount}])))
+
+          ;; Collect outflow addresses (we sent FROM our wallet)
+          (when (and from_addr (== from_addr wallet) to_addr (!= to_addr wallet))
+            (set! outflow_addrs (append outflow_addrs [{:address to_addr :amount amount}]))))))
+    (log :message "No transactions found"))
+
+  ;; Aggregate by address
+  (define inflow_counts {})
+  (define outflow_counts {})
+
+  ;; Count inflows
+  (for (item inflow_addrs)
+    (define addr (get item "address"))
+    (define prev (get inflow_counts addr))
+    (set! inflow_counts (merge inflow_counts {:placeholder_addr addr :placeholder_count (if prev (+ prev 1) 1)})))
+
+  ;; Count outflows
+  (for (item outflow_addrs)
+    (define addr (get item "address"))
+    (define prev (get outflow_counts addr))
+    (set! outflow_counts (merge outflow_counts {:placeholder_addr addr :placeholder_count (if prev (+ prev 1) 1)})))
+
+  ;; Return summary
+  {:wallet wallet
+   :tx_count (if transactions (count transactions) 0)
+   :unique_inflows (count inflow_addrs)
+   :unique_outflows (count outflow_addrs)
+   :sample_inflow_addresses (take 5 inflow_addrs)
+   :sample_outflow_addresses (take 5 outflow_addrs)}
+)

crates/ovsm/examples/from_tmp/async_stream_example.ovsm

@@ -0,0 +1,133 @@
+;;; OSVM V6: Async Event Processing with Lambda Callbacks
+;;;
+;;; This demonstrates the future async streaming API with callbacks
+
+(println "🚀 OSVM V6 - Async Event Processing Demo")
+(println "")
+
+;; Connect to Pump.fun WebSocket stream
+(define stream-id (stream-connect "ws://localhost:8080/ws" :programs ["pumpfun"]))
+
+(println "✅ Connected to WebSocket stream")
+(println "📡 Registering event callbacks...")
+(println "")
+
+;; Define callback for token transfers
+(define handle-transfer (lambda (event)
+  (do
+    (define token (get event "token"))
+    (define amount (get event "amount"))
+    (define from (get event "from"))
+    (define to (get event "to"))
+
+    ;; Check if it's a Pump.fun token
+    (if (> (length token) 4)
+        (do
+          (define last-4 (substring token (- (length token) 4) (length token)))
+          (if (= last-4 "pump")
+              (do
+                (println "═══════════════════════════════════════════════")
+                (println (str "💸 TRANSFER: " amount " tokens"))
+                (println (str "Token: " token))
+                (println (str "From:  " from))
+                (println (str "To:    " to))
+                (println "═══════════════════════════════════════════════"))
+              null))
+        null))))
+
+;; Define callback for buy events
+(define handle-buy (lambda (event)
+  (do
+    (println "🟢 BUY EVENT DETECTED!")
+    (define logs (get event "logs"))
+    (println (str "Logs: " logs)))))
+
+;; Define callback for sell events
+(define handle-sell (lambda (event)
+  (do
+    (println "🔴 SELL EVENT DETECTED!")
+    (define logs (get event "logs"))
+    (println (str "Logs: " logs)))))
+
+;; Define callback for graduation events
+(define handle-graduation (lambda (event)
+  (do
+    (println "")
+    (println "🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓")
+    (println "🎓 TOKEN GRADUATION - MIGRATING TO RAYDIUM 🚀")
+    (println "🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓")
+    (define sig (get event "signature"))
+    (println (str "Signature: " sig))
+    (println (str "osvm.ai:   https://osvm.ai/tx/" sig))
+    (println "🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓🎓")
+    (println ""))))
+
+;; ═══════════════════════════════════════════════════════════════
+;; V6 API (FUTURE): Register callbacks for different event types
+;; ═══════════════════════════════════════════════════════════════
+;; These would automatically dispatch to thread pool for concurrent processing
+;;
+;; (stream-on stream-id "token_transfer" handle-transfer)
+;; (stream-on stream-id "buy" handle-buy)
+;; (stream-on stream-id "sell" handle-sell)
+;; (stream-on stream-id "graduation" handle-graduation)
+;;
+;; ;; Main thread just waits - events processed in background
+;; (stream-wait-forever stream-id)
+
+;; ═══════════════════════════════════════════════════════════════
+;; V5 API (CURRENT): Manual event loop with lambdas
+;; ═══════════════════════════════════════════════════════════════
+(println "📊 Starting manual event loop (V5)...")
+(println "⏱️  Processing for 60 seconds...")
+(println "")
+
+(define start-time (now))
+(define duration 60)
+(define event-count 0)
+
+(while (< (- (now) start-time) duration)
+  (define event (stream-wait stream-id :timeout 1))
+
+  (if (not (null? event))
+      (do
+        (set! event-count (+ event-count 1))
+        (define event-type (get event "type"))
+
+        ;; Manually call the appropriate callback
+        (if (= event-type "token_transfer")
+            (handle-transfer event)
+            null)
+
+        (if (= event-type "log_message")
+            (do
+              (define logs (str (get event "logs")))
+
+              (if (string-contains logs "Instruction: Buy")
+                  (handle-buy event)
+                  null)
+
+              (if (string-contains logs "Instruction: Sell")
+                  (handle-sell event)
+                  null)
+
+              (if (or (string-contains logs "raydium")
+                      (string-contains logs "Instruction: Graduate"))
+                  (handle-graduation event)
+                  null))
+            null))
+      null))
+
+;; Summary
+(println "")
+(println "")
+(println "═══════════════════════════════════════════════")
+(println "  PROCESSING SUMMARY")
+(println "═══════════════════════════════════════════════")
+(println (str "Duration:       " duration " seconds"))
+(println (str "Events Processed: " event-count))
+(println "═══════════════════════════════════════════════")
+
+(stream-close stream-id)
+(println "")
+(println "✅ Stream closed")