Add RICOCHET-001: Bouncy Ball Bola deployment physics

- ricochet_deployment.py: impact-triggered sail unfurling primitive
(RicochetMarionette, DeploymentState, BounceDynamics, ImpactTrigger,
ShellSeparator, SailPayout)
- blueprint RICOCHET-001 doc
- physics package re-exports new symbols

blueprints/RICOCHET-001_bouncy_ball_deployment.md

@@ -0,0 +1,676 @@
+# RICOCHET-001: Bouncy Ball Bola Deployment System
+
+**Classification:** Impact-Triggered Sail Unfurling  
+**Status:** DRAFT v0.1  
+**Date:** 2026-01-24  
+**Codename:** "SUPERBALL MARIONETTE"
+
+---
+
+## 1. CONCEPT OVERVIEW
+
+**Throw a big rubber ball at the ground. It bounces. It ERUPTS into a sailing marionette.**
+
+The bounce isn't wasted energy - it's the LAUNCH MECHANISM.
+
+```
+    PHASE 1: THROW                    PHASE 2: IMPACT                   PHASE 3: ERUPTION
+    ════════════════                  ═══════════════                   ═════════════════
+    
+         ○                                 ○                                 ⛵   ⛵
+        /|\  ← Human throws              ╱│╲  ← Ball compresses              \   /
+         │       downward               ▄███▄   stores elastic                \_/
+        / \                            ═══════   energy                    ┌──┴──┐
+                                                                           │CORE │
+         ◉ ←─ Compressed               ◉▄▄▄▄◉ ← Deformation              ═══╧═══
+         │    marionette               ═══════   triggers latch              │
+         │                                │                               ⛵─┼─⛵
+         ▼                                │                                  │
+    ─────────────────             ─────────────────                   ─────────────────
+         GROUND                        GROUND                              GROUND
+                                                                             ↑
+                                                                        BOUNCE lifts
+                                                                        entire system!
+
+
+    PHASE 4: FLIGHT                   PHASE 5: MARIONETTE MODE
+    ═══════════════                   ════════════════════════
+    
+         ⛵     ⛵                              ⛵       ⛵
+          \   /                                 \     /
+           \ /   ← Sails catch air               \   /
+        ┌──┴──┐                                   \ /
+        │BRAIN│ ← Champion awakens            ┌───┴───┐
+        └──┬──┘                               │CONTROL│
+           │                                  └───┬───┘
+          ⛵ ⛵                                    │
+                                              ⛵──┼──⛵
+        ~~~~ WIND ~~~~                           
+                                         AUTONOMOUS FLIGHT
+```
+
+---
+
+## 2. THE SUPERBALL SHELL
+
+### 2.1 Material: High-Restitution Rubber
+
+The outer shell is made of **polybutadiene rubber** (same as actual Super Balls):
+- Coefficient of Restitution: **0.85 - 0.92** (bounces to ~80% of drop height!)
+- Stores massive elastic energy on impact
+- Survives repeated ground strikes
+
+```
+    SUPERBALL CROSS-SECTION
+    ═══════════════════════
+    
+              ┌─────────────────────────────────────┐
+              │         OUTER RUBBER SHELL          │
+              │    (polybutadiene, 8mm thick)       │
+              │  ┌─────────────────────────────┐    │
+              │  │    COMPRESSION CHAMBER      │    │
+              │  │  ┌───────────────────────┐  │    │
+              │  │  │                       │  │    │
+              │  │  │   ╔═══════════════╗   │  │    │
+              │  │  │   ║  SPOOL CORE   ║   │  │    │
+              │  │  │   ║  ┌─────────┐  ║   │  │    │
+              │  │  │   ║  │ SAILS   │  ║   │  │    │
+              │  │  │   ║  │ (wound) │  ║   │  │    │
+              │  │  │   ║  │ ◎◎◎◎◎◎◎ │  ║   │  │    │
+              │  │  │   ║  └─────────┘  ║   │  │    │
+              │  │  │   ║   CHAMPION    ║   │  │    │
+              │  │  │   ║    BRAIN      ║   │  │    │
+              │  │  │   ╚═══════════════╝   │  │    │
+              │  │  │                       │  │    │
+              │  │  └───────────────────────┘  │    ��
+              │  │      LATCH RING ●────●      │    │
+              │  └─────────────────────────────┘    │
+              │                                     │
+              └─────────────────────────────────────┘
+              
+                         ◉ = 15-25 cm diameter
+```
+
+### 2.2 Ball Specifications
+
+| Property | Value | Notes |
+|----------|-------|-------|
+| Diameter | 15-25 cm | Softball to volleyball size |
+| Shell Thickness | 6-10 mm | Balances bounce vs payload |
+| Total Mass | 0.8-2.0 kg | Throwable by human |
+| Restitution Coefficient | 0.85+ | HIGH bounce required |
+| Impact Survival | 50+ m/s | Handles hard throws |
+
+---
+
+## 3. THE ERUPTION MECHANISM
+
+### 3.1 G-Force Triggered Latch
+
+The shell contains a **compression-activated latch** that releases at a specific G-force threshold.
+
+```
+    LATCH MECHANISM (Cross-section view)
+    ═════════════════════════════════════
+    
+    ARMED STATE                           TRIGGERED STATE
+    ════════════                          ═══════════════
+    
+    ┌────────────────┐                    ┌────────────────┐
+    │   SHELL WALL   │                    │   SHELL WALL   │
+    │ ┌────────────┐ │                    │ ┌────────────┐ │
+    │ │  ┌──────┐  │ │                    │ │            │ │
+    │ │  │LATCH │  │ │  ══► IMPACT ══►    │ │   LATCH    │ │
+    │ │  │ PIN  │  │ │                    │ │   SHEARED  │ │
+    │ │  └──┬───┘  │ │                    │ │      ↓     │ │
+    │ │     │      │ │                    │ │   ═════    │ │
+    │ │  ▼▼▼▼▼▼▼   │ │                    │ │   ▲▲▲▲▲    │ │
+    │ │  SPRING    │ │                    │ │  RELEASED! │ │
+    │ │  LOADED    │ │                    │ │            │ │
+    │ └────────────┘ │                    │ └────────────┘ │
+    └────────────────┘                    └────────────────┘
+    
+    
+    G-FORCE THRESHOLD:
+    ══════════════════
+    
+         G-force
+            ↑
+       150G │         ████ ← TRIGGER ZONE
+       100G │    █████████   (100-200G)
+        50G │    │        
+         0G ├────┼────────────► time
+            │    │
+                 IMPACT
+                 MOMENT
+```
+
+### 3.2 Shell Separation
+
+On trigger, the shell **splits along pre-scored seams** like a blooming flower:
+
+```
+    SHELL BLOOM SEQUENCE
+    ════════════════════
+    
+    T = 0ms              T = 5ms              T = 20ms             T = 50ms
+    (Impact)             (Latch releases)     (Petals open)        (Full bloom)
+    
+       ◉                    ◉                   ╱│╲                  \   /
+       │                   /│\                 / │ \                  \_/
+       │                  / │ \               /  │  \                  │
+    ═══════           ═══════════         ════════════            ═══════════
+    
+                                              ↑
+                                         SAILS BEGIN
+                                         TO DEPLOY
+    
+    
+    TOP VIEW OF PETAL SEPARATION:
+    ═════════════════════════════
+    
+         ┌───┐                    ╱   ╲                     ╲     ╱
+        ╱     ╲                  │     │                     ╲   ╱
+       │   ◉   │    ═══►        │  ◉  │     ═══►              ╲ ╱
+        ╲     ╱                  │     │                       ◉
+         └───┘                    ╲   ╱                       ╱ ╲
+                                                             ╱   ╲
+       CLOSED                   CRACKING                  DETACHED
+                                                          (petals fly off)
+```
+
+---
+
+## 4. BOUNCE ENERGY HARVESTING
+
+### 4.1 The Bounce = Free Launch Velocity
+
+When the ball hits the ground, it compresses and rebounds. We HARVEST this:
+
+```
+    ENERGY FLOW DIAGRAM
+    ═══════════════════
+    
+    THROW ENERGY ──────────────────────────────────────────────►
+         │                                                      │
+         │  ┌──────────────────────────────────────────────┐   │
+         │  │                                              │   │
+         ▼  ▼                                              ▼   │
+    ╔═══════════╗     ╔═══════════════╗     ╔═══════════════╗  │
+    ║  KINETIC  ║ ──► ║   ELASTIC     ║ ──► ║   KINETIC     ║  │
+    ║  (down)   ║     ║  (compressed) ║     ║   (UP!)       ║  │
+    ╚═══════════╝     ╚═══════════════╝     ╚═══════════════╝  │
+         │                   │                     │           │
+         │                   │                     │           │
+         │                   ▼                     ▼           ▼
+         │            ┌─────────────┐        ┌──────────────────┐
+         │            │ LATCH TRIPS │        │ SAILS DEPLOY     │
+         │            │ (uses tiny  │        │ (catch upward    │
+         │            │  fraction)  │        │  momentum!)      │
+         │            └─────────────┘        └──────────────────┘
+         │
+         └──────► ~15% lost to ground/heat
+    
+    
+    VELOCITY DIAGRAM:
+    ═════════════════
+    
+         V (m/s)
+            ↑
+       +15  │                    ●●●●●●●●●●●● ← SAILS DEPLOYED
+            │                   ●            ↖ (catching wind)
+       +10  │                  ●
+            │                 ●  ← UPWARD BOUNCE
+        +5  │                ●
+            │               ●
+         0  ├───────────────●─────────────────► time
+            │              ●│
+        -5  │             ● │
+            │            ●  │
+       -10  │           ●   │
+            │          ●    │
+       -15  │         ●     │ ← DOWNWARD (thrown)
+            │        ●      │
+       -20  │       ●       │
+                    ▲
+                 IMPACT
+                 (latch triggers)
+```
+
+### 4.2 Timing is Everything
+
+The shell must separate DURING the bounce, not before or after:
+
+```
+    CRITICAL TIMING WINDOW
+    ══════════════════════
+    
+    ─────────────────────────────────────────────────────────────►
+                                                               time
+    
+    │◄──── APPROACH ────►│◄─ CONTACT ─►│◄──── REBOUND ────►│
+    │                    │             │                    │
+    │    Ball falling    │ Compression │   Ball rising      │
+    │    Shell intact    │ Latch trips │   Shell blooming   │
+    │                    │             │   Sails unfurling  │
+    │                    │             │                    │
+    │         ◉          │    ▄◉▄      │       ⛵ ⛵        │
+    │         │          │   ═════     │        \│/         │
+    │         ▼          │             │         ◉          │
+    │                    │             │         ↑          │
+    │                    │             │                    │
+    ────────────────────────────────────────────────────────────
+    
+    
+    FAILURE MODES:
+    ══════════════
+    
+    TOO EARLY (pre-impact):        TOO LATE (post-apex):
+    
+         ⛵ ⛵                              ⛵ ⛵
+          \│/                               \│/
+           ◉  ← Sails deploy                 ◉  ← Sails deployed
+           │     while falling!              │     but falling again!
+           ▼     (no upward momentum)        ▼     (missed the bounce)
+        ═══════                           ═══════
+        
+           BAD!                              BAD!
+```
+
+---
+
+## 5. SAIL DEPLOYMENT SEQUENCE
+
+### 5.1 Coiled Configuration (Pre-Deploy)
+
+Inside the ball, sails are wound tightly around the spool core:
+
+```
+    INTERNAL COIL STRUCTURE
+    ═══════════════════════
+    
+    TOP VIEW (looking down into ball):
+    
+              ╔═══════════════════════════╗
+              ║                           ║
+              ║    ┌─────────────────┐    ║
+              ║    │  ◎◎◎◎◎◎◎◎◎◎◎◎   │    ║
+              ║    │  ◎ ┌───────┐ ◎   │    ║
+              ║    │  ◎ │ SPOOL │ ◎   │    ║
+              ║    │  ◎ │ CORE  │ ◎   │    ║
+              ║    │  ◎ │       │ ◎   │    ║  ← 4 sails wound
+              ║    │  ◎ │ BRAIN │ ◎   │    ║     as tight spirals
+              ║    │  ◎ └───────┘ ◎   │    ║
+              ║    │  ◎◎◎◎◎◎◎◎◎◎◎◎   │    ║
+              ║    └─────────────────┘    ║
+              ║                           ║
+              ╚═══════════════════════════╝
+                     RUBBER SHELL
+    
+    
+    SIDE VIEW (cross-section):
+    
+              ┌─────────────────────────────┐
+              │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ ← Rubber
+              │░┌───────────────────────┐░░░│
+              │░│ ════════════════════  │░░░│ ← Sail 0 (coiled)
+              │░│ ════════════════════  │░░░│ ← Sail 1 (coiled)
+              │░│   ╔═══════════════╗   │░░░│
+              │░│   ║  SPOOL DRUMS  ║   │░░░│
+              │░│   ║  ┌──┐┌──┐     ║   │░░░│
+              │░│   ║  │◎ ││◎ │     ║   │░░░│ ← Individual drums
+              │░│   ║  └──┘└──┘     ║   │░░░│    per sail cable
+              │░│   ╚═══════════════╝   │░░░│
+              │░│ ════════════════════  │░░░│ ← Sail 2 (coiled)
+              │░│ ════════════════════  │░░░│ ← Sail 3 (coiled)
+              │░└───────────────────────┘░░░│
+              │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
+              └─────────────────────────────┘
+```
+
+### 5.2 Centrifugal Unfurling
+
+As the shell petals separate, they carry sail tips outward. Then **spin + upward motion** unfurls:
+
+```
+    UNFURL SEQUENCE (Top view, time series)
+    ════════════════════════════════════════
+    
+    T=0ms                T=30ms               T=100ms              T=200ms
+    Shell splits         Petals eject         Cables pay out       Full extension
+    
+        ╱ ╲                 \   /                 ⛵     ⛵             ⛵       ⛵
+       │ ◎ │                 \ /                   \   /                \     /
+        ╲ ╱                   ◎                     \ /                  \   /
+                              │                   ┌──┴──┐                 \ /
+                             ╱ ╲                  │CORE │             ┌───┴───┐
+                                                  └──┬──┘             │ SPOOL │
+                                                     │                └───┬───┘
+                                                    ⛵ ⛵                  │
+                                                                      ⛵──┼──⛵
+    
+    
+    CABLE PAYOUT MECHANISM:
+    ═══════════════════════
+    
+    Each sail is on a DRUM that pays out cable as centrifugal force pulls:
+    
+         ┌────────────────────────────────────────────┐
+         │                                            │
+         │   DRUM (wound)          DRUM (paying out)  │
+         │                                            │
+         │     ┌──────┐              ┌──────┐         │
+         │     │◎◎◎◎◎◎│              │◎◎◎   │───────► │  ← Cable
+         │     │◎◎◎◎◎◎│   ═══►       │◎◎    │         │     unreeling
+         │     │◎◎◎◎◎◎│              │◎     │         │
+         │     └──────┘              └──────┘         │
+         │                                            │
+         │    INITIAL                 MID-DEPLOY      │
+         │    (all cable wound)      (cable out)      │
+         │                                            │
+         └────────────────────────────────────────────┘
+    
+    
+    Centrifugal force at R = 1m, ω = 3 rad/s:
+    
+        F_cent = m * ω² * R
+               = 0.2 kg * (3)² * 1
+               = 1.8 N per sail
+               
+    This pulls cables out smoothly!
+```
+
+---
+
+## 6. PHYSICS MODEL
+
+### 6.1 Impact Dynamics
+
+```python
+# Ground impact model
+def compute_bounce(v_impact, restitution=0.87, mass=1.5):
+    """
+    Calculate bounce velocity from impact.
+    
+    Args:
+        v_impact: Impact velocity (m/s, positive = downward)
+        restitution: Coefficient of restitution (0.87 for superball rubber)
+        mass: Ball mass (kg)
+        
+    Returns:
+        v_rebound: Rebound velocity (m/s, positive = upward)
+        g_force: Peak G-force during impact
+        contact_time: Ground contact duration (s)
+    """
+    # Rebound velocity (energy preserved * restitution)
+    v_rebound = v_impact * restitution
+    
+    # Contact time (Hertzian contact approximation)
+    # For rubber ball ~10-20ms
+    contact_time = 0.015  # 15ms typical
+    
+    # Peak deceleration
+    delta_v = v_impact + v_rebound  # Total velocity change
+    a_peak = delta_v / contact_time
+    g_force = a_peak / 9.81
+    
+    return v_rebound, g_force, contact_time
+
+
+# Example: 20 m/s throw (hard overhand)
+v_rebound, g_force, t_contact = compute_bounce(20.0)
+# v_rebound ≈ 17.4 m/s (upward!)
+# g_force ≈ 255 G (definitely triggers latch!)
+# t_contact ≈ 15 ms
+```
+
+### 6.2 Trigger Threshold
+
+```python
+# G-force latch parameters
+TRIGGER_G_MIN = 80    # Minimum G to trigger (prevents accidental)
+TRIGGER_G_MAX = 500   # Max survivable G for electronics
+
+# For various throw speeds:
+# 10 m/s (gentle toss):  ~127 G  ← TRIGGERS
+# 15 m/s (medium throw): ~191 G  ← TRIGGERS  
+# 20 m/s (hard throw):   ~255 G  ← TRIGGERS
+# 25 m/s (very hard):    ~319 G  ← TRIGGERS
+#  5 m/s (drop):          ~64 G  ← NO TRIGGER (too soft)
+```
+
+### 6.3 Sail Deployment Dynamics
+
+```python
+def sail_unfurl_physics(
+    bounce_velocity: float,     # m/s upward
+    spin_rate: float,           # rad/s (imparted by throw)
+    num_sails: int = 4,
+    sail_mass: float = 0.15,    # kg per sail
+    cable_length: float = 2.0,  # m max extension
+):
+    """
+    Model sail deployment during upward bounce.
+    """
+    # Centrifugal acceleration pulls sails outward
+    # a_cent = ω² * r
+    
+    # Time to full extension (approximate)
+    # Using F = ma, where F = centrifugal
+    # Simplified: t ≈ sqrt(2 * cable_length / a_cent)
+    
+    # At spin_rate = 3 rad/s, r = 1m:
+    # a_cent = 9 m/s²
+    # t_deploy ≈ sqrt(2 * 2.0 / 9) ≈ 0.67 seconds
+    
+    # During this time, ball rises:
+    # h = v * t - 0.5 * g * t²
+    # h = 17 * 0.67 - 0.5 * 9.81 * 0.67²
+    # h ≈ 9.2 m (above bounce point!)
+    
+    return {
+        'deploy_time': 0.67,
+        'deploy_altitude': 9.2,
+        'final_sail_velocity': spin_rate * cable_length,  # tangential
+    }
+```
+
+---
+
+## 7. CHAMPION BRAIN ACTIVATION
+
+### 7.1 Boot Sequence
+
+The Champion brain (DreamerV3) activates on impact detection:
+
+```
+    BRAIN ACTIVATION TIMELINE
+    ═════════════════════════
+    
+    ──────────────────────────────────────────────────────────────────►
+                                                                    time
+    
+    │ DORMANT │ IMPACT │ BOOT │ CALIBRATE │ SAIL CONTROL │ MARIONETTE │
+    │         │        │      │           │              │    MODE    │
+    │         │        │      │           │              │            │
+    │ zzz...  │  !!!   │ ████ │ ◎ ◎ ◎ ◎  │   ~~~~ ⛵    │   FLYING   │
+    │         │        │      │           │              │            │
+    ├─────────┼────────┼──────┼───────────┼──────────────┼────────────┤
+       -∞     T=0     50ms   100ms       300ms          500ms+
+    
+    
+    BOOT SEQUENCE DETAIL:
+    ═════════════════════
+    
+    T+0ms:    Accelerometer detects >80G → WAKE signal
+    T+10ms:   IMU initialization
+    T+20ms:   Tension sensors online (all drums)
+    T+30ms:   RSSM state estimator starts
+    T+50ms:   First control output (brake drums to prevent overshoot)
+    T+100ms:  Sail positions estimated from cable tensions
+    T+200ms:  Aerodynamic model engaged
+    T+300ms:  Full marionette control active
+    T+500ms:  Champion brain has authority
+```
+
+### 7.2 Mid-Air Orientation Recovery
+
+After chaotic bounce + deploy, the system must stabilize:
+
+```
+    STABILIZATION CHALLENGE
+    ═══════════════════════
+    
+    POST-BOUNCE (Chaotic):              TARGET (Stable):
+    
+         ⛵                                    ⛵     ⛵
+        /                                       \   /
+       /   ⛵                                    \ /
+      │   /                                   ┌──┴──┐
+      ◎──/     ← Tumbling,                    │CORE │ ← Level,
+        \        tangled?                     └──┬──┘   symmetric
+         \                                       │
+          ⛵                                  ⛵──┼──⛵
+                                                 
+    Champion uses:
+    1. Differential cable tension → torque for rotation
+    2. Sail pitch modulation → aerodynamic moments
+    3. Collective pitch → altitude control
+```
+
+---
+
+## 8. OPERATIONAL ENVELOPE
+
+### 8.1 Throw Parameters
+
+| Parameter | Min | Optimal | Max | Notes |
+|-----------|-----|---------|-----|-------|
+| Throw Speed | 8 m/s | 15-20 m/s | 30 m/s | Harder = higher bounce |
+| Throw Angle | -90° (straight down) | -60° to -45° | 0° (horizontal) | Steep = clean bounce |
+| Spin Imparted | 0 rad/s | 2-4 rad/s | 10 rad/s | Spin aids deployment |
+| Release Height | 1.0 m | 1.5-2.0 m | 3.0 m | Higher = more time |
+
+### 8.2 Environmental Requirements
+
+```
+    SURFACE REQUIREMENTS:
+    ═════════════════════
+    
+    ✓ GOOD SURFACES           ✗ BAD SURFACES
+    ──────────────            ─────────────
+    • Concrete                • Sand (absorbs energy)
+    • Asphalt                 • Grass (unpredictable)
+    • Hard-packed dirt        • Water (no bounce lol)
+    • Gym floor               • Mud
+    • Metal deck              • Foam/carpet
+    
+    
+    WIND CONDITIONS:
+    ════════════════
+    
+    Optimal: 3-8 m/s (light breeze)
+    - Enough wind for sail control
+    - Not so much it tumbles the ball pre-impact
+    
+    Maximum: 15 m/s
+    - Beyond this, deploy timing unreliable
+```
+
+---
+
+## 9. INTEGRATION WITH MARIONETTE SPOOL
+
+This system IS the marionette spool, just with a bouncy ball deployment shell:
+
+```
+    SYSTEM EQUIVALENCE
+    ══════════════════
+    
+    STANDARD MARIONETTE                RICOCHET DEPLOYMENT
+    (hand throw)                       (bouncy ball)
+    
+    ┌───────┐                          ┌───────────────┐
+    │SPOOL  │                          │   SUPERBALL   │
+    │       │ ← Human                  │ ┌───────────┐ │
+    │ BRAIN │   throws                 │ │   SPOOL   │ │ ← Human
+    │       │                          │ │   BRAIN   │ │   throws
+    └───────┘                          │ └───────────┘ │
+        │                              └───────┬───────┘
+        │                                      │
+        ▼                                      ▼
+    UNRAVEL by                            UNRAVEL by
+    centrifugal force                     IMPACT + BOUNCE
+    from throw spin                       + centrifugal
+        │                                      │
+        ▼                                      ▼
+    ┌───────────────┐                  ┌───────────────┐
+    │  MARIONETTE   │                  │  MARIONETTE   │
+    │  FLIGHT MODE  │     ═════        │  FLIGHT MODE  │
+    └───────────────┘                  └───────────────┘
+    
+                      SAME SYSTEM!
+                      (different deployment trigger)
+```
+
+---
+
+## 10. VARIANT: BOLA MODE CASCADE
+
+For the full bola experience - throw MULTIPLE balls that link mid-air:
+
+```
+    MULTI-BALL BOLA ERUPTION
+    ════════════════════════
+    
+    THROW:                  BOUNCE:                 LINK:
+    
+      ○   ○   ○              ⛵ ⛵   ⛵ ⛵          ⛵───────⛵
+       \  │  /                \│/     \│/           \       /
+        \ │ /                  ◎──��────◎             \     /
+         \│/                   │       │              \   /
+          ▼                    ↑       ↑               \ /
+    ═══════════         ═══════════════════         ════╋════
+                                                        │
+                              MAGNETIC              ⛵───┼───⛵
+                              DOCKING                   │
+                                                    ════╬════
+                                                        │
+                                                   FULL BOLA
+                                                   CONSTELLATION!
+```
+
+---
+
+## 11. IMPLEMENTATION NOTES
+
+### Python Module Location
+`src/physics/ricochet_deployment.py`
+
+### Key Classes
+- `SuperballShell` - Rubber shell physics + latch mechanism
+- `ImpactTrigger` - G-force detection and timing
+- `BounceDynamics` - Restitution and rebound calculation  
+- `EruptionSequencer` - Shell separation + sail payout timing
+- `RicochetMarionette` - Full integrated system
+
+### Integration Points
+- `src/physics/marionette_spool.py` - Core spool mechanics
+- `src/physics/slingshot_dynamics.py` - Bola physics
+- `src/physics/tether_dynamics.py` - Cable payout
+- `src/ai/dreamer_interface.py` - Champion brain
+
+---
+
+## 12. FUTURE WORK
+
+1. **Multi-bounce recovery** - What if first bounce fails to trigger?
+2. **Angle compensation** - Non-vertical bounces, spin correction
+3. **Water landing variant** - Buoyant shell for maritime ops
+4. **Sound-triggered variant** - Clap or whistle to deploy (no ground needed)
+
+---
+
+*"The ground is not the enemy. The ground is the launch pad."*
+
+**— RICOCHET-001 Design Philosophy**

src/physics/__init__.py

@@ -40,6 +40,15 @@ from .cable_geometry import (
     OPERATIONAL_SECTORS
 )
 
+from .ricochet_deployment import (
+    RicochetMarionette,
+    DeploymentState,
+    BounceDynamics,
+    ImpactTrigger,
+    ShellSeparator,
+    SailPayout,
+)
+
 __all__ = [
     # Tether
     'TetherConstraint',
@@ -64,4 +73,11 @@ __all__ = [
     'OperationalSector',
     'TangleState',
     'OPERATIONAL_SECTORS',
+    # Ricochet Deployment (Bouncy Ball Bola)
+    'RicochetMarionette',
+    'DeploymentState',
+    'BounceDynamics',
+    'ImpactTrigger',
+    'ShellSeparator',
+    'SailPayout',
 ]

src/physics/ricochet_deployment.py

@@ -0,0 +1,936 @@
+"""
+Ricochet Deployment System
+==========================
+BOUNCY BALL BOLA ERUPTION - Throw it at the ground, it bounces, SAILS DEPLOY!
+
+The RICOCHET-001 system uses a high-restitution rubber shell to:
+1. Store the marionette spool system in compressed form
+2. Trigger deployment on ground impact (G-force activated latch)
+3. Harvest bounce energy as FREE upward launch velocity
+4. Unfurl sails during the upward trajectory
+
+Physics:
+- Polybutadiene rubber shell (coefficient of restitution ~0.87)
+- G-force triggered latch (80-500G operating range)
+- Centrifugal sail unfurling during bounce
+- Champion brain activates mid-flight
+
+    THROW → IMPACT → BOUNCE → ERUPTION → MARIONETTE MODE
+      ◉       ▄◉▄       ◉        ⛵⛵⛵         ⛵ ⛵
+      │      ═════       ↑        \│/           \   /
+      ▼                            ◉             \ /
+    ═════                                      ┌──┴──┐
+                                               │BRAIN│
+                                               └─────┘
+
+Source: blueprints/RICOCHET-001_bouncy_ball_deployment.md
+"""
+
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple, Optional, Callable
+from enum import Enum, auto
+
+
+class DeploymentState(Enum):
+    """Ricochet system operational states."""
+    DORMANT = auto()          # Pre-throw, all systems inactive
+    BALLISTIC_DOWN = auto()   # In flight, approaching ground
+    IMPACT = auto()           # Ground contact, compression phase
+    BOUNCE = auto()           # Rebound phase, latch triggered
+    ERUPTING = auto()         # Shell separating, sails deploying
+    UNFURLING = auto()        # Cables paying out, sails extending
+    STABILIZING = auto()      # Champion brain taking control
+    MARIONETTE = auto()       # Full autonomous flight
+
+
+class ShellState(Enum):
+    """Rubber shell integrity states."""
+    INTACT = auto()           # Closed, protecting payload
+    TRIGGERED = auto()        # Latch released
+    SEPARATING = auto()       # Petals opening
+    DETACHED = auto()         # Petals fully separated
+
+
+class LatchState(Enum):
+    """G-force triggered latch states."""
+    ARMED = auto()            # Ready to trigger
+    TRIGGERED = auto()        # G-force threshold exceeded
+    RELEASED = auto()         # Latch mechanism opened
+
+
+@dataclass
+class RubberShellConfig:
+    """Configuration for the superball rubber shell."""
+    # Geometry
+    diameter: float = 0.20              # meters (20cm default)
+    shell_thickness: float = 0.008      # meters (8mm rubber)
+    
+    # Material properties (polybutadiene rubber)
+    restitution_coefficient: float = 0.87   # Bounce efficiency
+    rubber_density: float = 920.0           # kg/m³
+    
+    # Mass budget
+    shell_mass: float = 0.35            # kg (rubber shell only)
+    payload_mass: float = 1.15          # kg (spool + sails + brain)
+    
+    @property
+    def total_mass(self) -> float:
+        return self.shell_mass + self.payload_mass
+    
+    @property
+    def inner_diameter(self) -> float:
+        return self.diameter - 2 * self.shell_thickness
+
+
+@dataclass 
+class LatchConfig:
+    """Configuration for the G-force triggered latch."""
+    trigger_g_min: float = 80.0     # Minimum G to trigger (prevents accidental)
+    trigger_g_max: float = 500.0    # Maximum survivable G
+    trigger_duration: float = 0.001  # Seconds of sustained G required
+    release_time: float = 0.005     # Seconds for mechanical release
+
+
+@dataclass
+class SailDeployConfig:
+    """Configuration for sail deployment during bounce."""
+    num_sails: int = 4
+    sail_mass: float = 0.15         # kg per sail
+    cable_length: float = 2.0       # meters max extension
+    cable_stiffness: float = 5000   # N/m
+    drum_brake_torque: float = 0.5  # N*m max braking
+    
+    # Sail geometry
+    sail_area: float = 0.3          # m² per sail
+    sail_aspect_ratio: float = 4.0  # span²/area
+
+
+@dataclass
+class BrainBootConfig:
+    """Configuration for Champion brain activation."""
+    wake_delay: float = 0.010       # seconds after impact detection
+    imu_init_time: float = 0.020    # seconds for IMU calibration
+    estimator_start: float = 0.030  # seconds to start state estimation
+    first_control: float = 0.050    # seconds to first control output
+    full_authority: float = 0.300   # seconds to full marionette control
+
+
+@dataclass
+class ImpactEvent:
+    """Captured data from ground impact."""
+    timestamp: float                # seconds
+    position: np.ndarray           # world position of impact
+    velocity_in: np.ndarray        # velocity at impact (m/s)
+    velocity_out: np.ndarray       # velocity after bounce (m/s)
+    peak_g_force: float            # maximum G experienced
+    contact_duration: float        # seconds on ground
+    surface_normal: np.ndarray     # ground surface normal
+    latch_triggered: bool          # did G exceed threshold?
+
+
+@dataclass
+class DeploymentTelemetry:
+    """Real-time deployment status."""
+    state: DeploymentState
+    shell_state: ShellState
+    latch_state: LatchState
+    
+    # Position/velocity
+    position: np.ndarray = field(default_factory=lambda: np.zeros(3))
+    velocity: np.ndarray = field(default_factory=lambda: np.zeros(3))
+    angular_velocity: np.ndarray = field(default_factory=lambda: np.zeros(3))
+    
+    # Deployment progress
+    shell_separation_fraction: float = 0.0  # 0=closed, 1=fully open
+    cable_payout_fractions: np.ndarray = field(default_factory=lambda: np.zeros(4))
+    
+    # Brain status
+    brain_booted: bool = False
+    brain_authority: float = 0.0    # 0=none, 1=full control
+    
+    # Impact data
+    last_impact: Optional[ImpactEvent] = None
+
+
+class ImpactTrigger:
+    """
+    G-force based latch trigger system.
+    
+    Monitors acceleration and triggers when sustained G-force
+    exceeds threshold. Prevents accidental triggers from handling.
+    """
+    
+    def __init__(self, config: LatchConfig):
+        self.config = config
+        self.state = LatchState.ARMED
+        
+        # Detection state
+        self._g_history: List[Tuple[float, float]] = []  # (time, g_force)
+        self._trigger_start_time: Optional[float] = None
+        
+    def reset(self):
+        """Reset to armed state."""
+        self.state = LatchState.ARMED
+        self._g_history.clear()
+        self._trigger_start_time = None
+        
+    def update(self, acceleration: np.ndarray, dt: float, current_time: float) -> bool:
+        """
+        Update trigger with current acceleration.
+        
+        Args:
+            acceleration: Current acceleration vector (m/s²)
+            dt: Time step
+            current_time: Current simulation time
+            
+        Returns:
+            True if latch just triggered this frame
+        """
+        if self.state == LatchState.RELEASED:
+            return False
+            
+        # Calculate G-force magnitude
+        g_force = np.linalg.norm(acceleration) / 9.81
+        
+        # Store in history
+        self._g_history.append((current_time, g_force))
+        
+        # Trim old history (keep last 50ms)
+        cutoff = current_time - 0.050
+        self._g_history = [(t, g) for t, g in self._g_history if t > cutoff]
+        
+        # Check trigger condition
+        if g_force >= self.config.trigger_g_min:
+            if self._trigger_start_time is None:
+                self._trigger_start_time = current_time
+            
+            # Check if sustained long enough
+            # For impact events, we treat single-frame high-G as valid trigger
+            sustained_time = current_time - self._trigger_start_time
+            if sustained_time >= self.config.trigger_duration or g_force >= self.config.trigger_g_min * 1.5:
+                # Either sustained long enough OR so strong it triggers immediately
+                self.state = LatchState.TRIGGERED
+                return True
+        else:
+            # Reset trigger timer if G dropped
+            self._trigger_start_time = None
+            
+        return False
+    
+    def release(self):
+        """Complete latch release after trigger."""
+        self.state = LatchState.RELEASED
+        
+    def get_peak_g(self) -> float:
+        """Get peak G-force from history."""
+        if not self._g_history:
+            return 0.0
+        return max(g for _, g in self._g_history)
+
+
+class BounceDynamics:
+    """
+    Physics engine for rubber ball impact and bounce.
+    
+    Models:
+    - Hertzian contact mechanics (compression)
+    - Viscoelastic rebound (energy return)
+    - Surface normal reflection
+    """
+    
+    def __init__(self, shell_config: RubberShellConfig):
+        self.config = shell_config
+        
+    def compute_bounce(self,
+                       velocity_in: np.ndarray,
+                       surface_normal: np.ndarray = None) -> Tuple[np.ndarray, float, float]:
+        """
+        Calculate bounce velocity from impact.
+        
+        Args:
+            velocity_in: Impact velocity vector (m/s)
+            surface_normal: Ground normal (default: [0, 0, 1] = flat ground)
+            
+        Returns:
+            velocity_out: Rebound velocity vector (m/s)
+            peak_g: Peak G-force during impact
+            contact_time: Ground contact duration (s)
+        """
+        if surface_normal is None:
+            surface_normal = np.array([0.0, 0.0, 1.0])
+        surface_normal = surface_normal / np.linalg.norm(surface_normal)
+        
+        # Decompose velocity into normal and tangential
+        v_normal_mag = np.dot(velocity_in, surface_normal)
+        v_normal = v_normal_mag * surface_normal
+        v_tangent = velocity_in - v_normal
+        
+        # Only bounce if approaching ground (negative normal component)
+        if v_normal_mag >= 0:
+            # Not approaching ground, no bounce
+            return velocity_in.copy(), 0.0, 0.0
+        
+        # Reflect normal component with restitution loss
+        v_normal_out = -v_normal * self.config.restitution_coefficient
+        
+        # Tangential component mostly preserved (slight friction loss)
+        friction_factor = 0.95
+        v_tangent_out = v_tangent * friction_factor
+        
+        # Combine for output velocity
+        velocity_out = v_normal_out + v_tangent_out
+        
+        # Contact time (Hertzian approximation for rubber)
+        # Typically 10-20ms for rubber ball
+        impact_speed = abs(v_normal_mag)
+        contact_time = self._estimate_contact_time(impact_speed)
+        
+        # Peak G-force
+        delta_v = abs(v_normal_mag) + np.linalg.norm(v_normal_out)
+        peak_acceleration = delta_v / contact_time
+        peak_g = peak_acceleration / 9.81
+        
+        return velocity_out, peak_g, contact_time
+    
+    def _estimate_contact_time(self, impact_speed: float) -> float:
+        """
+        Estimate ground contact duration based on impact speed.
+        
+        Faster impacts = shorter contact (ball compresses faster).
+        """
+        # Empirical model for rubber ball
+        # Base contact time ~15ms, decreases with speed
+        base_time = 0.015
+        speed_factor = 1.0 / (1.0 + impact_speed / 20.0)
+        return base_time * speed_factor + 0.005  # Minimum 5ms
+    
+    def compute_compression(self, impact_speed: float) -> float:
+        """
+        Calculate shell compression during impact.
+        
+        Returns fraction of diameter compressed (0-0.5).
+        """
+        # Simplified spring model
+        # Higher speed = more compression
+        max_compression = 0.4  # 40% of diameter max
+        compression = min(max_compression, impact_speed / 50.0)
+        return compression
+
+
+class ShellSeparator:
+    """
+    Models shell petal separation after latch release.
+    
+    The shell splits along pre-scored seams like a blooming flower.
+    Petals carry sail tips outward as they separate.
+    """
+    
+    def __init__(self, num_petals: int = 4):
+        self.num_petals = num_petals
+        self.state = ShellState.INTACT
+        
+        # Separation dynamics
+        self.separation_fraction = 0.0
+        self.separation_velocity = 0.0  # m/s radial
+        
+        # Petal states
+        self.petal_angles: np.ndarray = np.linspace(0, 2*np.pi, num_petals, endpoint=False)
+        self.petal_positions: List[np.ndarray] = [np.zeros(3) for _ in range(num_petals)]
+        
+        # Physics params
+        self.spring_force = 50.0        # N initial separation spring
+        self.petal_mass = 0.08          # kg per petal
+        self.drag_coefficient = 0.5     # Air resistance on petals
+        
+    def trigger(self):
+        """Initiate shell separation."""
+        if self.state == ShellState.INTACT:
+            self.state = ShellState.TRIGGERED
+            self.separation_velocity = 2.0  # Initial separation speed m/s
+    
+    def update(self, dt: float, airspeed: float = 0.0):
+        """
+        Update shell separation physics.
+        
+        Args:
+            dt: Time step
+            airspeed: Current airspeed for drag calculation
+        """
+        if self.state == ShellState.INTACT:
+            return
+            
+        if self.state == ShellState.TRIGGERED:
+            self.state = ShellState.SEPARATING
+        
+        if self.state == ShellState.SEPARATING:
+            # Spring force decreases with separation
+            spring_remaining = max(0, 1.0 - self.separation_fraction)
+            spring_accel = (self.spring_force * spring_remaining) / self.petal_mass
+            
+            # Air drag on petals (opposes motion)
+            drag_accel = 0.5 * 1.225 * self.drag_coefficient * 0.01 * \
+                         self.separation_velocity**2 / self.petal_mass
+            
+            # Net acceleration
+            accel = spring_accel - drag_accel
+            
+            # Integrate
+            self.separation_velocity += accel * dt
+            self.separation_velocity = max(0, self.separation_velocity)  # No negative
+            
+            # Update separation fraction (assuming 0.5m max separation)
+            max_separation = 0.5  # meters
+            self.separation_fraction += (self.separation_velocity * dt) / max_separation
+            
+            if self.separation_fraction >= 1.0:
+                self.separation_fraction = 1.0
+                self.state = ShellState.DETACHED
+                
+    def get_petal_positions(self, core_position: np.ndarray, 
+                            core_orientation: np.ndarray = None) -> List[np.ndarray]:
+        """Get world positions of all petals."""
+        if self.state == ShellState.INTACT:
+            return [core_position.copy() for _ in range(self.num_petals)]
+        
+        # Petals move radially outward
+        separation_distance = self.separation_fraction * 0.5  # meters
+        
+        positions = []
+        for i, angle in enumerate(self.petal_angles):
+            # Radial direction in XY plane
+            direction = np.array([np.cos(angle), np.sin(angle), 0.0])
+            petal_pos = core_position + direction * separation_distance
+            positions.append(petal_pos)
+            
+        return positions
+
+
+class SailPayout:
+    """
+    Manages cable payout from drum during deployment.
+    
+    Centrifugal force pulls sails outward, paying out cable
+    from spring-loaded drums. Champion brain can brake drums
+    to control payout rate.
+    """
+    
+    def __init__(self, config: SailDeployConfig):
+        self.config = config
+        
+        # Per-sail state
+        self.cable_lengths = np.zeros(config.num_sails)  # Current payout
+        self.cable_rates = np.zeros(config.num_sails)    # Payout velocity
+        self.sail_positions = [np.zeros(3) for _ in range(config.num_sails)]
+        self.sail_velocities = [np.zeros(3) for _ in range(config.num_sails)]
+        
+        # Sail angles (radially distributed)
+        self.sail_angles = np.linspace(0, 2*np.pi, config.num_sails, endpoint=False)
+        
+        # Drum braking (controlled by Champion brain)
+        self.drum_brakes = np.zeros(config.num_sails)  # 0=free, 1=full brake
+        
+    def update(self,
+               core_position: np.ndarray,
+               core_velocity: np.ndarray,
+               angular_velocity: np.ndarray,
+               dt: float):
+        """
+        Update sail positions based on centrifugal unfurling.
+        
+        Args:
+            core_position: Spool core world position
+            core_velocity: Spool core world velocity
+            angular_velocity: Core angular velocity (rad/s)
+            dt: Time step
+        """
+        spin_rate = np.linalg.norm(angular_velocity)
+        
+        for i in range(self.config.num_sails):
+            # Current radial position
+            r = self.cable_lengths[i] + 0.1  # Minimum radius 10cm
+            
+            # Centrifugal acceleration
+            a_cent = spin_rate**2 * r
+            
+            # Sail drag (opposes radial motion)
+            v_radial = self.cable_rates[i]
+            drag_force = 0.5 * 1.225 * 0.5 * self.config.sail_area * v_radial**2
+            drag_accel = drag_force / self.config.sail_mass
+            if v_radial > 0:
+                drag_accel = -drag_accel  # Opposes motion
+            
+            # Drum brake force
+            brake_accel = self.drum_brakes[i] * self.config.drum_brake_torque / \
+                          (self.config.sail_mass * r + 0.01)
+            
+            # Cable tension (if at max length)
+            cable_limit_accel = 0.0
+            if self.cable_lengths[i] >= self.config.cable_length:
+                # Spring back
+                overshoot = self.cable_lengths[i] - self.config.cable_length
+                cable_limit_accel = -self.config.cable_stiffness * overshoot / self.config.sail_mass
+            
+            # Net radial acceleration
+            a_radial = a_cent + drag_accel - brake_accel + cable_limit_accel
+            
+            # Integrate cable payout
+            self.cable_rates[i] += a_radial * dt
+            self.cable_rates[i] = max(0, self.cable_rates[i])  # No negative payout
+            
+            self.cable_lengths[i] += self.cable_rates[i] * dt
+            self.cable_lengths[i] = np.clip(self.cable_lengths[i], 0, self.config.cable_length * 1.05)
+            
+            # Update sail world position
+            angle = self.sail_angles[i]
+            radial_dir = np.array([np.cos(angle), np.sin(angle), 0.0])
+            self.sail_positions[i] = core_position + radial_dir * (self.cable_lengths[i] + 0.1)
+            
+            # Sail velocity = core velocity + tangential velocity from spin
+            tangent_dir = np.array([-np.sin(angle), np.cos(angle), 0.0])
+            tangent_speed = spin_rate * (self.cable_lengths[i] + 0.1)
+            self.sail_velocities[i] = core_velocity + tangent_dir * tangent_speed
+    
+    def get_deployment_fraction(self) -> float:
+        """Get average deployment fraction across all sails."""
+        return np.mean(self.cable_lengths) / self.config.cable_length
+    
+    def apply_brake(self, sail_index: int, brake_force: float):
+        """Apply brake to specific sail drum."""
+        self.drum_brakes[sail_index] = np.clip(brake_force, 0, 1)
+    
+    def release_all_brakes(self):
+        """Release all drum brakes for free unfurling."""
+        self.drum_brakes[:] = 0.0
+
+
+class ChampionBootSequencer:
+    """
+    Manages Champion brain boot sequence during deployment.
+    
+    The brain activates on impact detection and progressively
+    gains authority over the marionette system.
+    """
+    
+    def __init__(self, config: BrainBootConfig):
+        self.config = config
+        
+        # Boot state
+        self.boot_started = False
+        self.boot_complete = False
+        self.boot_start_time = 0.0
+        
+        # Subsystem status
+        self.imu_ready = False
+        self.estimator_ready = False
+        self.control_ready = False
+        
+        # Authority ramp (0 = no control, 1 = full authority)
+        self.authority = 0.0
+        
+    def start_boot(self, current_time: float):
+        """Begin boot sequence on impact detection."""
+        if not self.boot_started:
+            self.boot_started = True
+            self.boot_start_time = current_time
+            
+    def update(self, current_time: float) -> Dict[str, bool]:
+        """
+        Update boot sequence progress.
+        
+        Returns:
+            Status dict of subsystem readiness
+        """
+        if not self.boot_started:
+            return {'booting': False, 'imu': False, 'estimator': False, 'control': False}
+        
+        elapsed = current_time - self.boot_start_time
+        
+        # IMU initialization
+        if elapsed >= self.config.imu_init_time:
+            self.imu_ready = True
+        
+        # State estimator
+        if elapsed >= self.config.estimator_start:
+            self.estimator_ready = True
+        
+        # Control system
+        if elapsed >= self.config.first_control:
+            self.control_ready = True
+        
+        # Authority ramp-up (linear from first_control to full_authority)
+        if elapsed >= self.config.first_control:
+            ramp_duration = self.config.full_authority - self.config.first_control
+            ramp_progress = (elapsed - self.config.first_control) / ramp_duration
+            self.authority = np.clip(ramp_progress, 0, 1)
+        
+        if elapsed >= self.config.full_authority:
+            self.boot_complete = True
+        
+        return {
+            'booting': True,
+            'imu': self.imu_ready,
+            'estimator': self.estimator_ready,
+            'control': self.control_ready,
+            'authority': self.authority
+        }
+
+
+class RicochetMarionette:
+    """
+    Complete RICOCHET-001 bouncy ball deployment system.
+    
+    Integrates:
+    - Rubber shell physics (bounce)
+    - G-force triggered latch
+    - Shell separation
+    - Sail payout
+    - Champion brain boot
+    
+    Usage:
+        ricochet = RicochetMarionette()
+        ricochet.throw(position, velocity, spin)
+        
+        while simulating:
+            ricochet.step(dt)
+            telemetry = ricochet.get_telemetry()
+    """
+    
+    def __init__(self,
+                 shell_config: RubberShellConfig = None,
+                 latch_config: LatchConfig = None,
+                 sail_config: SailDeployConfig = None,
+                 brain_config: BrainBootConfig = None):
+        
+        # Configs
+        self.shell_config = shell_config or RubberShellConfig()
+        self.latch_config = latch_config or LatchConfig()
+        self.sail_config = sail_config or SailDeployConfig()
+        self.brain_config = brain_config or BrainBootConfig()
+        
+        # Subsystems
+        self.bounce_physics = BounceDynamics(self.shell_config)
+        self.trigger = ImpactTrigger(self.latch_config)
+        self.shell = ShellSeparator(num_petals=4)
+        self.sails = SailPayout(self.sail_config)
+        self.brain_boot = ChampionBootSequencer(self.brain_config)
+        
+        # State
+        self.state = DeploymentState.DORMANT
+        self.position = np.zeros(3)
+        self.velocity = np.zeros(3)
+        self.angular_velocity = np.zeros(3)
+        self.orientation = np.eye(3)  # Rotation matrix
+        
+        # Simulation
+        self.time = 0.0
+        self.gravity = np.array([0.0, 0.0, -9.81])
+        
+        # Impact history
+        self.impacts: List[ImpactEvent] = []
+        
+        # Ground plane (default: z=0)
+        self.ground_height = 0.0
+        self.ground_normal = np.array([0.0, 0.0, 1.0])
+        
+    def throw(self,
+              position: np.ndarray,
+              velocity: np.ndarray,
+              angular_velocity: np.ndarray = None):
+        """
+        Initialize throw of the bouncy ball.
+        
+        Args:
+            position: Starting position (m)
+            velocity: Initial velocity vector (m/s)
+            angular_velocity: Initial spin (rad/s)
+        """
+        self.position = np.array(position, dtype=np.float64)
+        self.velocity = np.array(velocity, dtype=np.float64)
+        if angular_velocity is None:
+            self.angular_velocity = np.array([0, 0, 3.0], dtype=np.float64)
+        else:
+            self.angular_velocity = np.array(angular_velocity, dtype=np.float64)
+        
+        self.state = DeploymentState.BALLISTIC_DOWN
+        self.time = 0.0
+        
+        # Reset subsystems
+        self.trigger.reset()
+        self.shell = ShellSeparator(num_petals=4)
+        self.sails = SailPayout(self.sail_config)
+        self.brain_boot = ChampionBootSequencer(self.brain_config)
+        self.impacts.clear()
+        
+    def step(self, dt: float):
+        """
+        Advance simulation by one time step.
+        
+        Args:
+            dt: Time step in seconds
+        """
+        self.time += dt
+        
+        if self.state == DeploymentState.DORMANT:
+            return
+        
+        # Ballistic motion (before and during bounce)
+        if self.state in [DeploymentState.BALLISTIC_DOWN, DeploymentState.BOUNCE]:
+            self._step_ballistic(dt)
+        
+        # Check for ground impact
+        if self.state == DeploymentState.BALLISTIC_DOWN:
+            if self.position[2] <= self.ground_height + self.shell_config.diameter / 2:
+                self._handle_impact()
+        
+        # Shell separation
+        if self.state in [DeploymentState.ERUPTING, DeploymentState.UNFURLING]:
+            self.shell.update(dt, np.linalg.norm(self.velocity))
+        
+        # Sail deployment physics (in air after bounce)
+        if self.state in [DeploymentState.UNFURLING, DeploymentState.STABILIZING]:
+            self._step_unfurling(dt)
+            self.sails.update(self.position, self.velocity, self.angular_velocity, dt)
+            
+            # Check if fully deployed
+            if self.sails.get_deployment_fraction() > 0.95:
+                if self.state == DeploymentState.UNFURLING:
+                    self.state = DeploymentState.STABILIZING
+        
+        # Brain boot sequence
+        if self.state in [DeploymentState.BOUNCE, DeploymentState.ERUPTING,
+                          DeploymentState.UNFURLING, DeploymentState.STABILIZING]:
+            status = self.brain_boot.update(self.time)
+            if status.get('authority', 0) >= 1.0:
+                self.state = DeploymentState.MARIONETTE
+        
+        # Marionette mode physics (simplified - full physics in marionette_spool.py)
+        if self.state == DeploymentState.MARIONETTE:
+            self._step_marionette(dt)
+    
+    def _step_ballistic(self, dt: float):
+        """Simple ballistic motion under gravity."""
+        # Velocity integration
+        self.velocity += self.gravity * dt
+        
+        # Air drag (simplified)
+        speed = np.linalg.norm(self.velocity)
+        if speed > 0.1:
+            drag_coeff = 0.4
+            area = np.pi * (self.shell_config.diameter / 2)**2
+            drag_force = 0.5 * 1.225 * drag_coeff * area * speed**2
+            drag_accel = drag_force / self.shell_config.total_mass
+            drag_dir = -self.velocity / speed
+            self.velocity += drag_dir * drag_accel * dt
+        
+        # Position integration
+        self.position += self.velocity * dt
+    
+    def _step_unfurling(self, dt: float):
+        """
+        Physics during sail unfurling phase (post-bounce).
+        
+        Sails are deploying, providing some drag/lift, but not yet
+        fully controlled by Champion brain.
+        """
+        # Gravity
+        self.velocity += self.gravity * dt
+        
+        # Partial sail drag (increases with deployment)
+        deploy_frac = self.sails.get_deployment_fraction()
+        effective_area = deploy_frac * self.sail_config.num_sails * self.sail_config.sail_area
+        
+        speed = np.linalg.norm(self.velocity)
+        if speed > 0.1 and effective_area > 0:
+            # Drag from deploying sails
+            drag_coeff = 0.8  # Partially deployed sails are draggy
+            drag_force = 0.5 * 1.225 * drag_coeff * effective_area * speed**2
+            drag_accel = drag_force / self.shell_config.payload_mass
+            drag_dir = -self.velocity / speed
+            self.velocity += drag_dir * drag_accel * dt
+            
+            # Partial lift (if moving upward or wind present)
+            if self.velocity[2] > 0:
+                # Ascending - sails can catch air
+                lift_coeff = 0.3 * deploy_frac
+                lift_force = 0.5 * 1.225 * lift_coeff * effective_area * speed**2
+                lift_accel = lift_force / self.shell_config.payload_mass
+                self.velocity[2] += lift_accel * dt * 0.5  # Partial lift
+        
+        # Position integration
+        self.position += self.velocity * dt
+        
+        # Floor clamp (don't go through ground)
+        min_height = self.ground_height + 0.5  # Sails need clearance
+        if self.position[2] < min_height:
+            self.position[2] = min_height
+            self.velocity[2] = max(0, self.velocity[2])
+        
+        # Spin decay
+        self.angular_velocity *= 0.999
+
+    def _handle_impact(self):
+        """Process ground impact event."""
+        self.state = DeploymentState.IMPACT
+        
+        # Compute bounce
+        v_out, peak_g, contact_time = self.bounce_physics.compute_bounce(
+            self.velocity, self.ground_normal
+        )
+        
+        # Check G-force trigger
+        # Simulate acceleration spike
+        accel_spike = np.array([0, 0, peak_g * 9.81])
+        triggered = self.trigger.update(accel_spike, contact_time, self.time)
+        
+        # Record impact
+        impact = ImpactEvent(
+            timestamp=self.time,
+            position=self.position.copy(),
+            velocity_in=self.velocity.copy(),
+            velocity_out=v_out.copy(),
+            peak_g_force=peak_g,
+            contact_duration=contact_time,
+            surface_normal=self.ground_normal.copy(),
+            latch_triggered=triggered
+        )
+        self.impacts.append(impact)
+        
+        # Apply bounce
+        self.velocity = v_out
+        self.position[2] = self.ground_height + self.shell_config.diameter / 2
+        
+        # State transition
+        if triggered:
+            self.state = DeploymentState.BOUNCE
+            self.trigger.release()
+            self.shell.trigger()
+            self.brain_boot.start_boot(self.time)
+            
+            # Quick transition to erupting
+            self.state = DeploymentState.ERUPTING
+            
+            # Then to unfurling
+            self.state = DeploymentState.UNFURLING
+        else:
+            # Bounce but no trigger - go back to ballistic
+            self.state = DeploymentState.BALLISTIC_DOWN
+    
+    def _step_marionette(self, dt: float):
+        """
+        Simplified marionette physics.
+        
+        Full implementation should integrate with marionette_spool.py
+        """
+        # Basic gravity + lift
+        lift_coefficient = 0.3 * self.sails.get_deployment_fraction()
+        wind = np.array([5.0, 0.0, 0.0])  # Assume constant wind
+        
+        # Aerodynamic lift from sails
+        total_sail_area = self.sail_config.num_sails * self.sail_config.sail_area
+        wind_speed = np.linalg.norm(wind - self.velocity)
+        lift_force = 0.5 * 1.225 * lift_coefficient * total_sail_area * wind_speed**2
+        lift_accel = np.array([0, 0, lift_force / self.shell_config.payload_mass])
+        
+        # Apply forces
+        self.velocity += (self.gravity + lift_accel) * dt
+        self.position += self.velocity * dt
+        
+        # Angular damping
+        self.angular_velocity *= 0.99
+    
+    def get_telemetry(self) -> DeploymentTelemetry:
+        """Get current deployment status."""
+        return DeploymentTelemetry(
+            state=self.state,
+            shell_state=self.shell.state,
+            latch_state=self.trigger.state,
+            position=self.position.copy(),
+            velocity=self.velocity.copy(),
+            angular_velocity=self.angular_velocity.copy(),
+            shell_separation_fraction=self.shell.separation_fraction,
+            cable_payout_fractions=self.sails.cable_lengths / self.sail_config.cable_length,
+            brain_booted=self.brain_boot.boot_complete,
+            brain_authority=self.brain_boot.authority,
+            last_impact=self.impacts[-1] if self.impacts else None
+        )
+    
+    def get_sail_positions(self) -> List[np.ndarray]:
+        """Get world positions of all sails."""
+        return [pos.copy() for pos in self.sails.sail_positions]
+    
+    def get_petal_positions(self) -> List[np.ndarray]:
+        """Get world positions of shell petals."""
+        return self.shell.get_petal_positions(self.position)
+
+
+# =============================================================================
+# DEMO / TEST
+# =============================================================================
+
+def demo_ricochet_deployment():
+    """
+    Demonstrate bouncy ball deployment.
+    """
+    print("=" * 60)
+    print("RICOCHET-001: BOUNCY BALL BOLA DEPLOYMENT DEMO")
+    print("=" * 60)
+    
+    # Create system
+    ricochet = RicochetMarionette()
+    
+    # Throw parameters - HARD throw at the ground!
+    start_pos = np.array([0.0, 0.0, 2.0])    # 2m above ground
+    throw_vel = np.array([5.0, 0.0, -20.0])  # Forward and DOWN hard
+    throw_spin = np.array([0.0, 0.0, 10.0])  # STRONG spin for centrifugal unfurl
+    
+    print(f"\nThrow from: {start_pos}")
+    print(f"Velocity:   {throw_vel} m/s")
+    print(f"Spin:       {throw_spin} rad/s")
+    
+    # Execute throw
+    ricochet.throw(start_pos, throw_vel, throw_spin)
+    
+    # Simulate with progress reporting
+    dt = 0.001  # 1ms time step
+    max_time = 2.0
+    
+    print("\nSimulating...")
+    
+    state_changes = []
+    
+    while ricochet.time < max_time:
+        prev_state = ricochet.state
+        ricochet.step(dt)
+        
+        if ricochet.state != prev_state:
+            state_changes.append((ricochet.time, ricochet.state))
+            print(f"  T={ricochet.time:.3f}s: {prev_state.name} → {ricochet.state.name}")
+    
+    # Final status
+    telemetry = ricochet.get_telemetry()
+    print("\n" + "=" * 60)
+    print("FINAL STATUS")
+    print("=" * 60)
+    print(f"State:              {telemetry.state.name}")
+    print(f"Position:           {telemetry.position}")
+    print(f"Velocity:           {telemetry.velocity}")
+    print(f"Shell separation:   {telemetry.shell_separation_fraction:.1%}")
+    print(f"Sail deployment:    {telemetry.cable_payout_fractions}")
+    print(f"Brain authority:    {telemetry.brain_authority:.1%}")
+    
+    if telemetry.last_impact:
+        print(f"\nImpact details:")
+        print(f"  Peak G-force:     {telemetry.last_impact.peak_g_force:.1f} G")
+        print(f"  Contact time:     {telemetry.last_impact.contact_duration*1000:.1f} ms")
+        print(f"  Latch triggered:  {telemetry.last_impact.latch_triggered}")
+    
+    print("\nSail positions:")
+    for i, pos in enumerate(ricochet.get_sail_positions()):
+        print(f"  Sail {i}: {pos}")
+    
+    return ricochet
+
+
+if __name__ == "__main__":
+    demo_ricochet_deployment()