refactor(monorepo): reorganización lógica + renames + SDDs + split CHANGELOG

Reorganización física de crates/:
- core/ (mezclaba 6 propósitos) se divide en protocol/, init/, runtime/, compat/
- shared/ (3 crates) se redistribuye en protocol/ e init/
- lapaloma (sub-módulo de ui_engine) se promueve a modules/pineal/

Renames de proyectos:
- shipote → shuma (runtime de sandboxes)
- nouser → akasha (explorador de Mónadas)
- yahweh → nahual (motor GPUI, antes ui_engine/)
- lapaloma → pineal (data-viz agnóstica)

Fraccionamiento UI → core agnóstico:
- vista-core (DeckState + snap, 175 LOC, 5 tests verdes)
- barra-core (Task + render_html + sanitize, 90 LOC, 5 tests verdes)
- vista-web y barra-web ahora son thin DOM bindings

Documentación nueva:
- 16 SDDs por subdirectorio (≤80 LOC c/u): protocol/init/runtime/compat
  + 10 módulos + apps/
- docs/STATUS.md con cifras reales por proyecto
- docs/ROADMAP.md con plan a finalización (6 hitos, ~6-8 semanas)
- CHANGELOG.md particionado en docs/changelog/<proyecto>.md (7 buckets)

Automatización:
- scripts/reorg.py — script idempotente que: git mv directorios, renombra
  package names, recomputa path = refs, reescribe imports rust, actualiza
  workspace Cargo.toml. Soporta --dry-run.
- scripts/split-changelog.py — particiona CHANGELOG por componente.

Validación:
- cargo check --workspace pasa (124 crates + 2 nuevos cores).
- 10 tests adicionales (5 en vista-core + 5 en barra-core) verdes.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/apps/pineal-stream-demo/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "pineal-stream-demo"
+version = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+authors = { workspace = true }
+publish = { workspace = true }
+description = "Lapaloma — demo de streaming: RingBuffer + timer 60 Hz + sweep render. Showcase del zero-alloc en hot path."
+
+[dependencies]
+gpui = { workspace = true }
+nahual-launcher = { path = "../../modules/nahual/libs/launcher" }
+nahual-theme = { path = "../../modules/nahual/libs/theme" }
+pineal-core = { path = "../../modules/pineal/core" }
+pineal-render = { path = "../../modules/pineal/render", features = ["gpui"] }
+pineal-stream = { path = "../../modules/pineal/stream" }

crates/apps/pineal-stream-demo/src/main.rs

@@ -0,0 +1,125 @@
+//! `pineal-stream-demo` — osciloscopio sintético.
+//!
+//! Ventana con un `LapalomaStreamElement` montado sobre un
+//! `RingBuffer` de 512 slots. Un timer en el background executor
+//! empuja un sample cada **16 ms** (≈ 60 Hz) y dispara
+//! `cx.notify()`. El sample es la suma de dos sinusoides desfasadas
+//! más un poquito de ruido determinístico.
+//!
+//! El efecto visual: la traza barre la ventana como en un
+//! osciloscopio CRT — split-at-head deja un "cursor" donde
+//! arranca la traza fresca, la traza vieja se mantiene a la
+//! derecha hasta que el cursor la sobrescriba.
+//!
+//! Showcase del **P2 zero-alloc en hot path**: el `push(v)` del
+//! RingBuffer son 2 escrituras + 2 increments. Cero allocations
+//! por frame, ningún `Vec` se reasigna.
+
+use std::time::Duration;
+
+use gpui::{div, prelude::*, px, Context, IntoElement, Render, Window};
+
+use pineal_core::ring::RingBuffer;
+use pineal_render::{Color, StrokeStyle};
+use pineal_stream::pineal_stream;
+use nahual_launcher::launch_app;
+use nahual_theme::Theme;
+
+const RING_CAPACITY: usize = 512;
+const SAMPLE_PERIOD: Duration = Duration::from_millis(16);
+
+fn main() {
+    launch_app(
+        "Lapaloma — stream (osciloscopio sintético 60 Hz)",
+        (900., 480.),
+        StreamDemo::new,
+    );
+}
+
+struct StreamDemo {
+    buffer: RingBuffer,
+    /// Tick count global. Sirve de fase para la señal sintética y
+    /// se muestra en el header para verificar que el timer corre.
+    t: u64,
+}
+
+impl StreamDemo {
+    fn new(cx: &mut Context<Self>) -> Self {
+        cx.spawn(async move |this, cx| {
+            let timer = cx.background_executor().clone();
+            loop {
+                timer.timer(SAMPLE_PERIOD).await;
+                let r = this.update(cx, |me, cx| {
+                    me.tick();
+                    cx.notify();
+                });
+                if r.is_err() {
+                    break;
+                }
+            }
+        })
+        .detach();
+
+        Self {
+            buffer: RingBuffer::new(RING_CAPACITY),
+            t: 0,
+        }
+    }
+
+    fn tick(&mut self) {
+        let v = synthesize(self.t);
+        self.buffer.push(v);
+        self.t = self.t.wrapping_add(1);
+    }
+}
+
+/// Señal sintética: suma de dos sinusoides + jitter determinístico.
+/// El rango efectivo queda en `[-1, 1]` aproximadamente.
+fn synthesize(t: u64) -> f32 {
+    let phase = t as f32;
+    let signal = (phase * 0.07).sin() * 0.75 + (phase * 0.19).sin() * 0.22;
+    let jitter = ((phase * 37.0).sin() * 1000.0).fract() * 0.04;
+    signal + jitter
+}
+
+impl Render for StreamDemo {
+    fn render(&mut self, _w: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = Theme::global(cx).clone();
+
+        let plot_bg = Color::rgba(0.08, 0.10, 0.13, 1.0);
+        let stroke = StrokeStyle::new(1.8, Color::from_hex(0xa3be8c));
+
+        let stream = pineal_stream(self.buffer.clone(), stroke)
+            .background(plot_bg)
+            .y_range(-1.2, 1.2);
+
+        let fill_pct = (self.buffer.filled_len() * 100) / RING_CAPACITY;
+
+        div()
+            .size_full()
+            .bg(theme.bg_app.clone())
+            .p(px(16.))
+            .flex()
+            .flex_col()
+            .gap(px(10.))
+            .child(
+                div()
+                    .text_color(theme.fg_text)
+                    .text_size(px(18.))
+                    .child("Lapaloma — stream"),
+            )
+            .child(
+                div()
+                    .flex()
+                    .gap(px(16.))
+                    .text_size(px(11.))
+                    .text_color(theme.fg_muted)
+                    .child(format!("cap = {}", RING_CAPACITY))
+                    .child(format!("head = {}", self.buffer.head()))
+                    .child(format!("filled = {}%", fill_pct))
+                    .child(format!("t = {}", self.t))
+                    .child(format!("rev = {}", self.buffer.revision())),
+            )
+            .child(div().w_full().flex_grow().child(stream))
+    }
+}