refactor(naming): A1 — ente→arje, vista→revista, pluma→fana

Rename batch de la Fase A del PLAN_MACRO:
- 25 crates ente-* → arje-* (protocol/init/runtime/compat). El linaje
  arje (init Linux) queda con prefijo coherente.
- vista → revista (revista-core + revista-web).
- pluma → fana (fana-md + fana-md-reader-web). fana absorbe el linaje
  markdown de pluma; será el writer DAG editor (prioridad alta).

Cambios:
- git mv de 29 crate dirs + 2 SDDs
- package/lib/bin names + path refs + imports .rs reescritos
- workspace Cargo.toml + comentarios de sección
- SDDs de init/runtime/compat/protocol actualizados a arje-
- SDD de revista + SDD de fana (reescrito: writer DAG editor)
- docs/STATUS.md, ROADMAP.md, PLAN_MACRO.md, arje-boot.md,
  arje-replace-systemd.md actualizados
- docs/changelog/akasha.md → chasqui.md

scripts/rename-fase-a.py idempotente (--dry-run soportado).
cargo check --workspace verde.

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

crates/modules/shuma/shuma-core/Cargo.toml

@@ -6,13 +6,13 @@ rust-version.workspace = true
 license.workspace = true
 authors.workspace = true
 publish.workspace = true
-description = "Runtime de shipote: WorkspaceManager sobre ente-incarnate. Estado in-memory, lifecycle, reaping."
+description = "Runtime de shuma: WorkspaceManager sobre arje-incarnate. Estado in-memory, lifecycle, reaping."
 
 [dependencies]
 shuma-card = { path = "../shuma-card" }
 shuma-discern = { path = "../shuma-discern" }
 brahman-card = { path = "../../../protocol/brahman-card" }
-ente-incarnate = { path = "../../../init/ente-incarnate" }
+arje-incarnate = { path = "../../../init/arje-incarnate" }
 nix = { workspace = true }
 libc = { workspace = true }
 anyhow = { workspace = true }

crates/modules/shuma/shuma-core/src/lib.rs

@@ -18,7 +18,7 @@ pub mod pipeline;
 pub mod stats;
 
 use brahman_card::{Card, Payload, Supervision};
-use ente_incarnate::{Incarnator, IncarnatorConfig};
+use arje_incarnate::{Incarnator, IncarnatorConfig};
 use nix::sys::signal::{kill, Signal};
 use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
 use nix::unistd::Pid;
@@ -38,7 +38,7 @@ pub enum CoreError {
     #[error("compile: {0}")]
     Compile(#[from] shuma_card::CompileError),
     #[error("incarnate: {0}")]
-    Incarnate(#[from] ente_incarnate::IncarnateError),
+    Incarnate(#[from] arje_incarnate::IncarnateError),
 }
 
 #[derive(Debug)]
@@ -682,9 +682,9 @@ impl WorkspaceManager {
         // hace OOM kill al exceder memory.max — enforcement automático
         // sin policy adicional. Falla silenciosa si no hay delegation.
         if !spec.soma.cgroup.path.is_empty() {
-            if let Ok(abs) = ente_incarnate::cgroup::ensure_cgroup(&spec.soma.cgroup) {
+            if let Ok(abs) = arje_incarnate::cgroup::ensure_cgroup(&spec.soma.cgroup) {
                 let applied =
-                    ente_incarnate::cgroup::apply_rlimits_to_cgroup(&abs, &spec.soma.rlimits);
+                    arje_incarnate::cgroup::apply_rlimits_to_cgroup(&abs, &spec.soma.rlimits);
                 if !applied.is_empty() {
                     warnings.push(format!("cgroup limits applied: {}", applied.join(", ")));
                 }
@@ -842,11 +842,11 @@ impl WorkspaceManager {
         use std::os::fd::IntoRawFd;
         let (sout_r, sout_w) =
             nix::unistd::pipe2(nix::fcntl::OFlag::O_CLOEXEC).map_err(|e| {
-                CoreError::Incarnate(ente_incarnate::IncarnateError::Pipe(e))
+                CoreError::Incarnate(arje_incarnate::IncarnateError::Pipe(e))
             })?;
         let (serr_r, serr_w) =
             nix::unistd::pipe2(nix::fcntl::OFlag::O_CLOEXEC).map_err(|e| {
-                CoreError::Incarnate(ente_incarnate::IncarnateError::Pipe(e))
+                CoreError::Incarnate(arje_incarnate::IncarnateError::Pipe(e))
             })?;
         let sout_r_fd = sout_r.into_raw_fd();
         let sout_w_fd = sout_w.into_raw_fd();
@@ -856,7 +856,7 @@ impl WorkspaceManager {
         let stdout_buf = logbuf::LogBuf::new();
         let stderr_buf = logbuf::LogBuf::new();
 
-        let stdio = ente_incarnate::ChildStdio {
+        let stdio = arje_incarnate::ChildStdio {
             stdin_fd: None,
             stdout_fd: Some(sout_w_fd),
             stderr_fd: Some(serr_w_fd),

crates/modules/shuma/shuma-core/src/persist.rs

@@ -282,7 +282,7 @@ pub struct RestoreOutcome {
 mod tests {
     use super::*;
     use crate::WorkspaceManager;
-    use ente_incarnate::IncarnatorConfig;
+    use arje_incarnate::IncarnatorConfig;
     use shuma_card::{ExitPolicy, WorkspaceSpec};
     use std::sync::Arc;
 

crates/modules/shuma/shuma-core/src/pipeline.rs

@@ -1,7 +1,7 @@
 //! Pipeline runtime: encadena nodos con pipes y opcionalmente intercepta
 //! cada flow para discernir su contenido.
 //!
-//! Cada nodo se encarna via [`ente_incarnate::Incarnator`] — eso significa
+//! Cada nodo se encarna via [`arje_incarnate::Incarnator`] — eso significa
 //! que **cada comando puede tener su propio SomaSpec** (namespaces, cgroup,
 //! rlimits) heredado del workspace. La conexión stdin↔stdout se hace con
 //! `pipe2(2)` + `ChildStdio` declarativo: el callback de clone(2) hace los
@@ -9,7 +9,7 @@
 
 use crate::CoreError;
 use brahman_card::Payload;
-use ente_incarnate::{ChildStdio, Incarnator};
+use arje_incarnate::{ChildStdio, Incarnator};
 use nix::fcntl::OFlag;
 use nix::unistd::pipe2;
 use shuma_card::PipelineSpec;
@@ -87,7 +87,7 @@ pub async fn run_pipeline(
     let mut edge_w: Vec<RawFd> = vec![-1; spec.edges.len()];
     for i in 0..spec.edges.len() {
         let (r, w) = pipe2(OFlag::O_CLOEXEC).map_err(|e| {
-            CoreError::Incarnate(ente_incarnate::IncarnateError::Pipe(e))
+            CoreError::Incarnate(arje_incarnate::IncarnateError::Pipe(e))
         })?;
         edge_r[i] = r.into_raw_fd();
         edge_w[i] = w.into_raw_fd();
@@ -110,7 +110,7 @@ pub async fn run_pipeline(
         }
         // Splitter: pipe propio para el productor → splitter lee y replica a edge_w[*].
         let (prod_r, prod_w) = pipe2(OFlag::O_CLOEXEC).map_err(|e| {
-            CoreError::Incarnate(ente_incarnate::IncarnateError::Pipe(e))
+            CoreError::Incarnate(arje_incarnate::IncarnateError::Pipe(e))
         })?;
         producer_stdout_fd[i] = Some(prod_w.into_raw_fd());
         let prod_r_fd = prod_r.into_raw_fd();
@@ -147,7 +147,7 @@ pub async fn run_pipeline(
                 // Merger: lee de N edge_r y escribe a un nuevo pipe cuyo
                 // read end es el stdin del consumer.
                 let (cons_r, cons_w) = pipe2(OFlag::O_CLOEXEC).map_err(|e| {
-                    CoreError::Incarnate(ente_incarnate::IncarnateError::Pipe(e))
+                    CoreError::Incarnate(arje_incarnate::IncarnateError::Pipe(e))
                 })?;
                 consumer_stdin_fd[j] = Some(cons_r.into_raw_fd());
                 let inputs: Vec<RawFd> = predecessors[j]
@@ -169,7 +169,7 @@ pub async fn run_pipeline(
             Payload::Native { .. } | Payload::Legacy { .. } => {}
             _ => {
                 return Err(CoreError::Incarnate(
-                    ente_incarnate::IncarnateError::NonExecutablePayload,
+                    arje_incarnate::IncarnateError::NonExecutablePayload,
                 ))
             }
         }
@@ -638,7 +638,7 @@ fn _keep_raw(_: &dyn AsRawFd) {}
 mod tests {
     use super::*;
     use brahman_card::Payload;
-    use ente_incarnate::IncarnatorConfig;
+    use arje_incarnate::IncarnatorConfig;
     use shuma_card::{CommandRef, DiscernPolicy, FlowEdge, PipelineSpec, WorkspaceId};
 
     fn cmd(label: &str, exec: &str, argv: &[&str]) -> CommandRef {

crates/modules/shuma/shuma-discern/src/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! Trait + pipeline + discerners default. Devuelve un [`Discernment`] con
 //! `TypeRef` consistente con el broker, confidence, MIME y un `lens` hint
-//! para UIs (reusa el espíritu del `dominant_lens` de akasha).
+//! para UIs (reusa el espíritu del `dominant_lens` de chasqui).
 
 #![forbid(unsafe_code)]