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/init/ente-zero/src/bus.rs

@@ -0,0 +1,143 @@
+//! Listener del bus interno. Vive en PID 1, acepta conexiones de Entes hijos,
+//! extrae credenciales del kernel vía SO_PEERCRED, y enruta cada request al
+//! grafo. Conexión bidireccional: el grafo puede *empujar* requests hacia
+//! una conexión registrada (forwarding de Invoke al proveedor).
+//!
+//! ## Por qué bidireccional
+//!
+//! Un Ente que provee `Capability::Endpoint` debe poder *recibir* invokes
+//! sin abrir más sockets. Después de Announce, el grafo guarda el lado de
+//! escritura de su conexión y lo usa para forwardear.
+
+use crate::events::GraphEvent;
+use ente_bus::{read_frame, write_frame, BusMessage, BusPayload, BusResponse, PeerCreds};
+use nix::sys::socket::{getsockopt, sockopt::PeerCredentials};
+use std::path::PathBuf;
+use tokio::net::{UnixListener, UnixStream};
+use tokio::sync::{mpsc, oneshot};
+use tracing::{error, info, trace, warn};
+use ulid::Ulid;
+
+pub fn default_socket_path() -> PathBuf {
+    if let Ok(p) = std::env::var(ente_bus::ENV_BUS_SOCK) {
+        return p.into();
+    }
+    let runtime = std::env::var("XDG_RUNTIME_DIR")
+        .unwrap_or_else(|_| std::env::var("TMPDIR").unwrap_or_else(|_| "/tmp".into()));
+    let user = std::env::var("USER").unwrap_or_else(|_| "ente".into());
+    format!("{runtime}/ente-bus-{user}.sock").into()
+}
+
+pub fn spawn_bus(path: PathBuf, graph_tx: mpsc::Sender<GraphEvent>) -> anyhow::Result<PathBuf> {
+    let _ = std::fs::remove_file(&path);
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    let listener = UnixListener::bind(&path)?;
+    info!(path = %path.display(), "bus interno escuchando");
+
+    let path_returned = path.clone();
+    tokio::spawn(async move {
+        loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    let tx = graph_tx.clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = handle_conn(stream, tx).await {
+                            warn!(?e, "bus connection ended");
+                        }
+                    });
+                }
+                Err(e) => {
+                    error!(?e, "bus accept failed, listener cerrando");
+                    return;
+                }
+            }
+        }
+    });
+
+    Ok(path_returned)
+}
+
+async fn handle_conn(stream: UnixStream, graph_tx: mpsc::Sender<GraphEvent>) -> anyhow::Result<()> {
+    // SO_PEERCRED: el kernel adjunta pid/uid/gid al socket en connect/accept.
+    // No-falsificable desde el cliente.
+    let creds = getsockopt(&stream, PeerCredentials)
+        .map_err(|e| anyhow::anyhow!("getsockopt PEERCRED: {e}"))?;
+    let peer = PeerCreds {
+        pid: creds.pid(),
+        uid: creds.uid(),
+        gid: creds.gid(),
+    };
+    trace!(?peer, "bus conn aceptada");
+
+    let (mut reader, mut writer) = stream.into_split();
+    let (out_tx, mut out_rx) = mpsc::channel::<BusMessage>(64);
+
+    // Writer task: única vía de escritura al socket. Multiplexa entre
+    // respuestas a peticiones del cliente y forwards iniciados por el grafo.
+    let writer_task = tokio::spawn(async move {
+        while let Some(msg) = out_rx.recv().await {
+            if let Err(e) = write_frame(&mut writer, &msg).await {
+                warn!(?e, "bus writer falló, terminando");
+                return;
+            }
+        }
+    });
+
+    let mut announced_id: Option<Ulid> = None;
+    let result: anyhow::Result<()> = (async {
+        loop {
+            let msg = match read_frame(&mut reader).await {
+                Ok(m) => m,
+                Err(e) => {
+                    trace!(?e, "bus conn read terminó");
+                    return Ok(());
+                }
+            };
+            match msg.payload {
+                BusPayload::Request(req) => {
+                    let is_announce = matches!(req, ente_bus::BusRequest::Announce { .. });
+                    let (reply_tx, reply_rx) = oneshot::channel();
+                    if graph_tx.send(GraphEvent::BusRequest {
+                        peer,
+                        from: msg.from,
+                        request: req,
+                        outbound: out_tx.clone(),
+                        reply: reply_tx,
+                    }).await.is_err() {
+                        warn!("graph cerrado, terminando bus connection");
+                        return Ok(());
+                    }
+                    let response = reply_rx.await.unwrap_or_else(|_| {
+                        BusResponse::Error("graph dropped reply channel".into())
+                    });
+                    if is_announce && matches!(response, BusResponse::Ok) {
+                        // Auth del Announce ya fue verificada por el grafo;
+                        // memorizamos para cleanup en cierre.
+                        announced_id = msg.from;
+                    }
+                    let out = BusMessage {
+                        from: None,
+                        seq: msg.seq,
+                        payload: BusPayload::Response(response),
+                    };
+                    if out_tx.send(out).await.is_err() { return Ok(()); }
+                }
+                BusPayload::Response(resp) => {
+                    // Respuesta a un Invoke que el grafo forwardeó a este peer.
+                    let _ = graph_tx.send(GraphEvent::BusResponse {
+                        seq: msg.seq,
+                        response: resp,
+                    }).await;
+                }
+            }
+        }
+    }).await;
+
+    if let Some(id) = announced_id {
+        let _ = graph_tx.send(GraphEvent::BusConnClosed { ente_id: Some(id) }).await;
+    }
+    writer_task.abort();
+    result
+}