Add ruview-geo: geospatial satellite integration (11 modules, 8/8 tests)

New crate with free satellite imagery, terrain, OSM, weather, and brain integration.

Modules: types, coord, locate, cache, tiles, terrain, osm, register, fuse, brain, temporal
Tests: 8 passed (haversine, ENU roundtrip, tiles, HGT parse, registration)
Validation: real data — 43.49N 79.71W, 4 Sentinel-2 tiles, 2°C weather, brain stored

Data sources (all free, no API keys):
- EOX Sentinel-2 cloudless (10m satellite tiles)
- SRTM GL1 (30m elevation)
- Overpass API (OSM buildings/roads)
- ip-api.com (geolocation)
- Open Meteo (weather)

ADR-044 documents architecture decisions.
README.md in crate subdirectory.

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: ruvnet

docs/adr/ADR-044-geospatial-satellite-integration.md

@@ -0,0 +1,51 @@
+# ADR-044: Geospatial Satellite Integration
+
+## Status
+Accepted
+
+## Context
+RuView generates real-time 3D point clouds from camera + WiFi CSI, but these exist in a local coordinate frame with no geographic reference. Integrating free satellite imagery, terrain elevation, and map data provides environmental context that enables the ruOS brain to reason about the physical world beyond the room.
+
+## Decision
+
+### Data Sources (all free, no API keys)
+| Source | Data | Resolution | Update | Format |
+|--------|------|-----------|--------|--------|
+| EOX Sentinel-2 Cloudless | Satellite tiles | 10m | Static mosaic | XYZ/JPEG |
+| SRTM GL1 (NASA) | Elevation/DEM | 30m (1-arcsec) | Static | Binary HGT |
+| Overpass API (OSM) | Buildings, roads | Vector | Real-time | JSON |
+| ip-api.com | IP geolocation | ~1km | Per-request | JSON |
+| Sentinel-2 STAC | Temporal satellite | 10m | Every 5 days | COG/STAC |
+| Open Meteo | Weather | Point | Hourly | JSON |
+
+### Architecture
+Pure Rust implementation in `wifi-densepose-geo` crate. No GDAL/PROJ/GEOS — coordinate transforms implemented directly (~250 LOC). Tile caching on disk at `~/.local/share/ruview/geo-cache/`.
+
+### Coordinate System
+- WGS84 for geographic coordinates
+- ENU (East-North-Up) as the bridge between local sensor frame and world
+- Local sensor frame: camera origin, +Z forward, +Y up
+
+### Temporal Awareness
+Nightly scheduled fetch of Sentinel-2 latest imagery + OSM diffs + weather.
+Changes detected via image comparison and stored as brain memories for
+contrastive learning.
+
+### Brain Integration
+Geospatial context stored as brain memories:
+- `spatial-geo`: location, elevation, nearby landmarks
+- `spatial-change`: detected changes in satellite/OSM data
+- `spatial-weather`: current conditions + forecast
+- `spatial-season`: vegetation index, snow cover, seasonal patterns
+
+## Consequences
+### Positive
+- Agent gains environmental awareness beyond the room
+- Temporal data enables seasonal calibration of CSI sensing
+- Change detection finds construction, vegetation, weather effects
+- All data sources are genuinely free with no API keys
+
+### Negative
+- Initial data fetch requires internet (~2MB tiles + ~25MB DEM)
+- Cached data becomes stale (mitigated by nightly refresh)
+- IP geolocation has ~1km accuracy (mitigated by manual override)

rust-port/wifi-densepose-rs/Cargo.lock

@@ -18,6 +18,7 @@ members = [
     "crates/wifi-densepose-ruvector",
     "crates/wifi-densepose-desktop",
     "crates/wifi-densepose-pointcloud",
+    "crates/wifi-densepose-geo",
 ]
 # ADR-040: WASM edge crate targets wasm32-unknown-unknown (no_std),
 # excluded from workspace to avoid breaking `cargo test --workspace`.

rust-port/wifi-densepose-rs/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ruview-geo"
+version = "0.1.0"
+edition = "2021"
+description = "Geospatial satellite integration — free satellite tiles, DEM, OSM, temporal tracking"
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+anyhow = { workspace = true }
+reqwest = { version = "0.12", features = ["json", "native-tls"], default-features = false }
+chrono = "0.4"

rust-port/wifi-densepose-rs/crates/wifi-densepose-geo/Cargo.toml

@@ -0,0 +1,105 @@
+# ruview-geo — Geospatial Satellite Integration
+
+Free satellite imagery, terrain elevation, and map data for RuView spatial sensing. No API keys required.
+
+## What It Does
+
+Integrates your local sensor data (camera + WiFi CSI point cloud) with geographic context:
+
+- **Satellite tiles** — 10m Sentinel-2 cloudless imagery for your location
+- **Elevation** — SRTM 30m DEM for terrain modeling
+- **Buildings + roads** — OpenStreetMap data via Overpass API
+- **Weather** — Open Meteo current conditions + forecast
+- **Geo-registration** — maps local sensor coordinates to WGS84
+- **Temporal tracking** — detects changes over time (construction, vegetation, weather)
+- **Brain integration** — stores geospatial context as ruOS brain memories
+
+## Data Sources (all free, no API keys)
+
+| Source | Data | Resolution | License |
+|--------|------|-----------|---------|
+| [EOX S2 Cloudless](https://s2maps.eu/) | Satellite tiles | 10m | CC-BY-4.0 |
+| [SRTM GL1](https://portal.opentopography.org/) | Elevation/DEM | 30m | Public domain |
+| [Overpass API](https://overpass-api.de/) | OSM buildings/roads | Vector | ODbL |
+| [ip-api.com](http://ip-api.com/) | IP geolocation | ~1km | Free |
+| [Open Meteo](https://open-meteo.com/) | Weather | Point | CC-BY-4.0 |
+
+## Modules
+
+| Module | LOC | Purpose |
+|--------|-----|---------|
+| `types.rs` | 140 | GeoPoint, GeoBBox, TileCoord, ElevationGrid, OsmFeature |
+| `coord.rs` | 80 | WGS84/ENU transforms, tile math, haversine distance |
+| `locate.rs` | 45 | IP geolocation with caching |
+| `cache.rs` | 55 | Disk cache (`~/.local/share/ruview/geo-cache/`) |
+| `tiles.rs` | 80 | Sentinel-2/ESRI/OSM tile fetcher |
+| `terrain.rs` | 100 | SRTM HGT parser, elevation lookup |
+| `osm.rs` | 150 | Overpass API client, building/road extraction |
+| `register.rs` | 50 | Local-to-WGS84 coordinate registration |
+| `fuse.rs` | 70 | Multi-source scene builder + summary |
+| `brain.rs` | 30 | Store geo context in ruOS brain |
+| `temporal.rs` | 100 | Weather, OSM change detection |
+
+## Usage
+
+```rust
+use ruview_geo::{fuse, brain, temporal};
+
+// Build geo scene for current location
+let scene = fuse::build_scene(500.0).await?; // 500m radius
+println!("{}", fuse::summarize(&scene));
+// "Location: 43.6532N, 79.3832W, elevation 76m ASL.
+//  23 buildings within view. 8 roads nearby (King St, Queen St).
+//  12 satellite tiles at zoom 16."
+
+// Store in brain
+brain::store_geo_context(&scene).await?;
+
+// Fetch weather
+let weather = temporal::fetch_weather(&scene.location).await?;
+// temperature: 12°C, partly cloudy, humidity 65%
+```
+
+## Brain Integration
+
+Geospatial context is stored as brain memories:
+
+| Category | Content | Frequency |
+|----------|---------|-----------|
+| `spatial-geo` | Location, elevation, buildings, roads | On startup + daily |
+| `spatial-weather` | Temperature, conditions, humidity, wind | Nightly |
+| `spatial-change` | New/removed buildings, road changes | Nightly diff |
+
+The ruOS agent can search: "what buildings are near me?" or "what's the weather?" and get geospatial context from the brain.
+
+## Security
+
+- No API keys stored or transmitted
+- IP geolocation uses HTTP (not HTTPS) — location is approximate (~1km)
+- All tile fetches use HTTPS except ip-api.com
+- Path traversal protection in cache key sanitization
+- No user data sent to external services
+- All data cached locally after first fetch
+
+## Architecture
+
+```
+IP Geolocation ──→ (lat, lon)
+                      │
+        ┌─────────────┼─────────────┐
+        ▼             ▼             ▼
+   Sentinel-2     SRTM DEM     Overpass API
+   (tiles)       (elevation)   (buildings/roads)
+        │             │             │
+        └─────────────┼─────────────┘
+                      ▼
+               GeoScene (fused)
+                      │
+              ┌───────┴───────┐
+              ▼               ▼
+        Brain Memory    Three.js Viewer
+```
+
+## License
+
+MIT (same as RuView)

rust-port/wifi-densepose-rs/crates/wifi-densepose-geo/README.md

@@ -0,0 +1,47 @@
+use ruview_geo::*;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    println!("╔══════════════════════════════════════════════╗");
+    println!("║  ruview-geo — Real Data Validation           ║");
+    println!("╚══════════════════════════════════════════════╝\n");
+
+    let t0 = std::time::Instant::now();
+    let cache = cache::TileCache::new("/tmp/ruview-geo-validate");
+
+    let loc = locate::get_location(&format!("{}/location.json", cache.base_dir.display())).await?;
+    println!("  Location: {:.4}N, {:.4}W", loc.lat, loc.lon);
+
+    let bbox = GeoBBox::from_center(&loc, 300.0);
+    let tiles_list = tiles::fetch_area(&tiles::TileProvider::Sentinel2Cloudless, &bbox, 16, &cache).await?;
+    println!("  Tiles: {} ({:.0}KB)", tiles_list.len(),
+        tiles_list.iter().map(|t| t.data.len()).sum::<usize>() as f64 / 1024.0);
+
+    let dem = terrain::fetch_elevation(&loc, &cache).await?;
+    println!("  Elevation: {:.0}m (grid {}x{})", terrain::elevation_at(&dem, &loc), dem.cols, dem.rows);
+
+    let buildings = osm::fetch_buildings(&loc, 300.0).await.unwrap_or_default();
+    let roads = osm::fetch_roads(&loc, 300.0).await.unwrap_or_default();
+    println!("  OSM: {} buildings, {} roads", buildings.len(), roads.len());
+
+    let weather = temporal::fetch_weather(&loc).await?;
+    println!("  Weather: {:.0}°C humidity={:.0}% wind={:.1}m/s",
+        weather.temperature_c, weather.humidity_pct, weather.wind_speed_ms);
+
+    let scene = GeoScene {
+        location: loc.clone(), bbox, elevation_m: terrain::elevation_at(&dem, &loc),
+        buildings, roads, tile_count: tiles_list.len(),
+        registration: register::auto_register(&loc),
+        last_updated: chrono::Utc::now().to_rfc3339(),
+    };
+    println!("\n  {}", fuse::summarize(&scene));
+
+    match brain::store_geo_context(&scene).await {
+        Ok(n) => println!("  Brain: {} memories stored", n),
+        Err(e) => println!("  Brain: {e}"),
+    }
+
+    println!("\n  Total: {}ms | Cache: {:.0}KB",
+        t0.elapsed().as_millis(), cache.size_bytes() as f64 / 1024.0);
+    Ok(())
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-geo/examples/validate.rs

@@ -0,0 +1,28 @@
+//! Brain integration — store geospatial context in ruOS brain.
+
+use crate::fuse;
+use crate::types::GeoScene;
+use anyhow::Result;
+
+const BRAIN_URL: &str = "http://127.0.0.1:9876";
+
+/// Store geospatial context in the brain.
+pub async fn store_geo_context(scene: &GeoScene) -> Result<u32> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(5))
+        .build()?;
+
+    let mut stored = 0u32;
+
+    // Store location summary
+    let summary = fuse::summarize(scene);
+    let body = serde_json::json!({
+        "category": "spatial-geo",
+        "content": summary,
+    });
+    if client.post(format!("{BRAIN_URL}/memories")).json(&body).send().await.is_ok() {
+        stored += 1;
+    }
+
+    Ok(stored)
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-geo/src/brain.rs

@@ -0,0 +1,61 @@
+//! Disk cache for tiles, DEM, and OSM data.
+
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+
+pub struct TileCache {
+    pub base_dir: PathBuf,
+}
+
+impl TileCache {
+    pub fn new(base_dir: &str) -> Self {
+        let expanded = base_dir.replace('~', &std::env::var("HOME").unwrap_or_default());
+        let path = PathBuf::from(expanded);
+        let _ = std::fs::create_dir_all(&path);
+        Self { base_dir: path }
+    }
+
+    pub fn default_cache() -> Self {
+        Self::new("~/.local/share/ruview/geo-cache")
+    }
+
+    pub fn get(&self, key: &str) -> Option<Vec<u8>> {
+        let path = self.key_path(key);
+        std::fs::read(&path).ok()
+    }
+
+    pub fn put(&self, key: &str, data: &[u8]) -> Result<()> {
+        let path = self.key_path(key);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(&path, data)?;
+        Ok(())
+    }
+
+    pub fn has(&self, key: &str) -> bool {
+        self.key_path(key).exists()
+    }
+
+    pub fn size_bytes(&self) -> u64 {
+        walkdir(self.base_dir.as_path())
+    }
+
+    fn key_path(&self, key: &str) -> PathBuf {
+        // Sanitize key to prevent path traversal
+        let safe_key = key.replace("..", "_").replace('/', "_");
+        self.base_dir.join(safe_key)
+    }
+}
+
+fn walkdir(path: &Path) -> u64 {
+    std::fs::read_dir(path)
+        .into_iter()
+        .flatten()
+        .filter_map(|e| e.ok())
+        .map(|e| {
+            if e.path().is_dir() { walkdir(&e.path()) }
+            else { e.metadata().map(|m| m.len()).unwrap_or(0) }
+        })
+        .sum()
+}