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/modules/nahual/libs/providers/fs/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "nahual-provider-fs"
+version = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+description = "DataProvider de filesystem local con discernimiento de contenido (shipote-discern)."
+
+[dependencies]
+nahual-core = { workspace = true }
+async-trait = { workspace = true }
+tokio = { workspace = true }
+notify = { workspace = true }
+shuma-discern = { path = "../../../../shuma/shuma-discern" }

crates/modules/nahual/libs/providers/fs/src/lib.rs

@@ -0,0 +1,119 @@
+//! Provider de filesystem local. Crate puro: cero dependencia de UI.
+//! Implementa `nahual_core::DataProvider` listando hijos de un path con
+//! `std::fs::read_dir` y leyendo archivos a `Vec<u8>` via `tokio::io`.
+
+use async_trait::async_trait;
+use shuma_discern::{DiscernPipeline, Hint};
+use std::fs;
+use std::io::{Cursor, Read};
+use std::path::Path;
+use std::pin::Pin;
+use std::sync::Arc;
+use tokio::io::{AsyncRead, AsyncWrite};
+use nahual_core::{DataProvider, DisplayType, EntityNode};
+
+pub const PROVIDER_ID: &str = "local_fs";
+
+/// Bytes que samplea el discerner por archivo. 4 KiB cubre headers de
+/// formatos comunes (PNG, ELF, JSON/TOML hasta una clave de profundidad
+/// razonable) sin saturar I/O al expandir un directorio.
+const DISCERN_SAMPLE_BYTES: usize = 4096;
+
+/// Tamaño máximo de archivo que sampleamos. Archivos más grandes se
+/// discernen igual via los primeros 4 KiB: el `seek/read` siempre lee
+/// head, y el costo es O(SAMPLE) sin importar el size total.
+/// Mantenemos esta constante por documentación; no se usa para skipear.
+const _DISCERN_SAMPLE_DOC: () = ();
+
+pub struct FileDataProvider {
+    discerner: Arc<DiscernPipeline>,
+}
+
+impl FileDataProvider {
+    pub fn new() -> Self {
+        Self {
+            discerner: Arc::new(DiscernPipeline::default_pipeline()),
+        }
+    }
+}
+
+impl Default for FileDataProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl DataProvider for FileDataProvider {
+    fn provider_id(&self) -> String {
+        PROVIDER_ID.to_string()
+    }
+
+    async fn list_children(&self, parent_id: Option<&str>) -> Result<Vec<EntityNode>, String> {
+        let path = parent_id.unwrap_or(".");
+        let mut children = Vec::new();
+
+        if let Ok(entries) = fs::read_dir(path) {
+            for entry in entries.filter_map(|e| e.ok()) {
+                let path = entry.path();
+                let name = path
+                    .file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .into_owned();
+                let is_dir = path.is_dir();
+                let display_type = if is_dir { DisplayType::Folder } else { DisplayType::File };
+
+                // Discernimos sólo archivos. Folders no tienen MIME útil.
+                let mime_type = if is_dir {
+                    None
+                } else {
+                    discern_head(&path, &self.discerner)
+                };
+
+                children.push(EntityNode {
+                    id: path.to_string_lossy().into_owned(),
+                    name,
+                    display_type,
+                    mime_type,
+                });
+            }
+        }
+
+        Ok(children)
+    }
+
+    async fn get_read_stream(
+        &self,
+        entity_id: &str,
+    ) -> Result<Pin<Box<dyn AsyncRead + Send>>, String> {
+        let content = fs::read(Path::new(entity_id)).map_err(|e| e.to_string())?;
+        Ok(Box::pin(Cursor::new(content)))
+    }
+
+    async fn get_write_stream(
+        &self,
+        _entity_id: &str,
+    ) -> Result<Pin<Box<dyn AsyncWrite + Send>>, String> {
+        Err("Escritura en streaming no implementada para FS".to_string())
+    }
+}
+
+/// Lee el head del archivo y lo pasa por el DiscernPipeline. Devuelve el
+/// MIME detectado (si alguno) o `None` si no hubo match.
+///
+/// Sync intencional: estamos dentro del runtime que ya es async, pero la
+/// lectura es de tamaño fijo (4 KiB) y va a page cache; el costo de
+/// `tokio::fs` no compensaría para esto.
+fn discern_head(path: &Path, discerner: &DiscernPipeline) -> Option<String> {
+    let mut buf = vec![0u8; DISCERN_SAMPLE_BYTES];
+    let mut f = fs::File::open(path).ok()?;
+    let n = f.read(&mut buf).ok()?;
+    buf.truncate(n);
+    let path_str = path.to_str();
+    let hint = Hint {
+        path: path_str,
+        size_total: None,
+    };
+    discerner.discern(&buf, &hint).and_then(|d| d.mime)
+}