
● Reporte técnico — Monorepo Brahman

  Estado al 2026-05-19 · 126 crates · ~78,000 LOC · cargo check --workspace verde

  ---
  0 · Panorama

  Sistema operativo fractal en Rust: cada cómputo se modela como Card, los módulos
   se acoplan sólo vía contratos serializables (brahman-card), el aislamiento es
  uniforme (ente-incarnate), y el routing es un service-locator de tipos
  (brahman-broker). El monorepo se reorganizó hoy en 6 capas físicas:

  crates/
  ├── protocol/    9 crates · contratos + routing
  ├── init/        5 crates · PID 1 + encarnación Linux
  ├── runtime/     5 crates · bus + cas + wasm + brain
  ├── compat/    14 crates · shims D-Bus systemd
  ├── modules/   62 crates · funcionalidad de dominio
  └── apps/      23 crates · binarios finales

  ---
  1 · Capa protocol/ — 6,260 LOC · ★★★★☆

  ┌─────────────────┬──────┬──────┬──────┬──────────────────────────────────┐
  │      crate      │ LOC  │ test │ TODO │               rol                │
  │                 │      │  s   │  s   │                                  │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-card    │ 1,29 │ sí   │ 5    │ Card { soma, payload, flow,      │
  │                 │ 0    │      │      │ permissions, ... }               │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-card-wi │ 165  │ sí   │ 0    │ Extracción WIT desde componentes │
  │ t               │      │      │      │  WASM                            │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-cards   │ 643  │ sí   │ 2    │ Templates Nickel + helpers       │
  │                 │      │      │      │ consumer/producer/broker         │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-handsha │ 2,94 │ sí   │ 10   │ Init↔módulo: Hello/Ping/ListSess │
  │ ke              │ 2    │      │      │ ions/ListMatches                 │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-broker  │ 995  │ sí   │ 2    │ Matching híbrido (Exact +        │
  │                 │      │      │      │ Structural)                      │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-admin   │ 225  │ no   │ 0    │ Socket admin para snapshots      │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-sidecar │ 565  │ sí   │ 0    │ spawn(card) para apps            │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ brahman-net     │ 423  │ no   │ 0    │ libp2p                           │
  │                 │      │      │      │ (TCP+noise+yamux+kad+identify)   │
  ├─────────────────┼──────┼──────┼──────┼──────────────────────────────────┤
  │ ente-card       │ —    │ —    │ —    │ Alias legacy (re-export)         │
  └─────────────────┴──────┴──────┴──────┴──────────────────────────────────┘

  Hecho. Handshake fase 1–3 (libp2p stream → DHT discovery → trust Ed25519).
  Broker emparejando con dos estrategias. Sidecar reusable por todas las apps.
  Allowlist/denylist con hot reload <250ms.

  Pendiente. Fase 4 trust: capabilities revocables, beyond-peer (delegación),
  métricas exportables. Tests faltan en brahman-admin (lo único sin cobertura).

  ---
  2 · Capa init/ — ~3,600 LOC · ★★★★☆

  ┌────────────────┬──────┬────────────────────────────────────────────────────┐
  │     crate      │ tipo │                        rol                         │
  ├────────────────┼──────┼────────────────────────────────────────────────────┤
  │ ente-zero      │ bin  │ PID 1: reap loop + bus + handshake server +        │
  │                │      │ brahman-net opc.                                   │
  ├────────────────┼──────┼────────────────────────────────────────────────────┤
  │ ente-kernel    │ lib  │ bootstrap_kernel_surface, subreaper,               │
  │                │      │ SIGCHLD/uevent streams                             │
  ├────────────────┼──────┼────────────────────────────────────────────────────┤
  │ ente-soma      │ lib  │ Wrapper ~30 LOC sobre ente-incarnate (compat API   │
  │                │      │ histórica)                                         │
  ├────────────────┼──────┼────────────────────────────────────────────────────┤
  │ ente-incarnate │ lib  │ clone(2) + namespaces + cgroup + rlimits + cpu +   │
  │                │      │ child_pre_exec                                     │
  ├────────────────┼──────┼────────────────────────────────────────────────────┤
  │ ente-snapshot  │ lib  │ FractalSnapshot JSON (v1–v4 con forward-compat)    │
  └────────────────┴──────┴────────────────────────────────────────────────────┘

  Hecho. Bootea bare metal + QEMU + initramfs (documentado en docs/arje-boot.md).
  ente-incarnate con builder pattern, ChildStdio + ChildPreExec declarativo,
  async-signal-safe. Snapshot v4 con replay buffer persistido + live pipelines.

  Pendiente. Cobertura de tests sobre snapshot restore con stale fds. Validación
  de re-encarnación tras restore.

  ---
  3 · Capa runtime/ — ~3,400 LOC · ★★★☆☆

  ┌────────────┬───────────────────────────────────────────────────────┬───────┐
  │   crate    │                          rol                          │ TODOs │
  ├────────────┼───────────────────────────────────────────────────────┼───────┤
  │ ente-bus   │ Unix SOCK_STREAM + postcard.                          │ 1     │
  │            │ Announce/Invoke/ListEntes                             │       │
  ├────────────┼───────────────────────────────────────────────────────┼───────┤
  │ ente-cas   │ SHA-256 content-addressed: blobs Wasm + audit log     │ 0     │
  ├────────────┼───────────────────────────────────────────────────────┼───────┤
  │ ente-wasm  │ Encarna Payload::Wasm vía wasmi en thread dedicado    │ 1     │
  ├────────────┼───────────────────────────────────────────────────────┼───────┤
  │ ente-brain │ Rule engine + observer estadístico + audit chain      │ 11    │
  ├────────────┼───────────────────────────────────────────────────────┼───────┤
  │ ente-echo  │ Ente prueba — Capability::Endpoint(echo)              │ 1     │
  └────────────┴───────────────────────────────────────────────────────┴───────┘

  Hecho. Bus + CAS + wasm operativos. SO_PEERCRED para identidad. Audit chain
  hashea cada evento del bus al CAS.

  Pendiente crítico. ente-brain concentra el 78% de la deuda técnica de esta capa:
   el rule engine declarativo está parcialmente implementado, falta el evaluador
  completo de policies + observer cross-ente.

  ---
  4 · Capa compat/ — ~5,000 LOC · ★★★☆☆

  14 shims D-Bus operativos como binarios standalone. Suficiente para que
  desktop-file-utils, xdg-open, gnome-session, login managers y CLIs systemd-aware
   no rompan al arrancar sobre ente-zero.

  Hecho. Cada shim reclama un well-known name (org.freedesktop.X1), implementa la
  interfaz mínima del ecosistema, loggea al audit de ente-brain.

  Pendiente. Métodos avanzados — Inhibit/Sleep hooks en logind, SetVariable en
  localed, MachineImage operations en machined. Necesarios para correr GNOME Shell
   end-to-end sin parches.

  ---
  5 · modules/semantic_dht/ (minga) — 5,091 LOC · ★★★★☆

  ┌─────────────┬───────┬──────────────────────────────────────────────┐
  │    crate    │  LOC  │                     rol                      │
  ├─────────────┼───────┼──────────────────────────────────────────────┤
  │ minga-core  │ 3,085 │ Parser tree-sitter + α-hashing (5 lenguajes) │
  ├─────────────┼───────┼──────────────────────────────────────────────┤
  │ minga-p2p   │ 1,105 │ libp2p kad + bootstrap + provider records    │
  ├─────────────┼───────┼──────────────────────────────────────────────┤
  │ minga-store │ 425   │ Sled backend para índice local               │
  ├─────────────┼───────┼──────────────────────────────────────────────┤
  │ minga-cli   │ 474   │ CLI: index, search, peers, bootstrap         │
  ├─────────────┼───────┼──────────────────────────────────────────────┤
  │ minga-vfs   │ 2     │ STUB — Mount FUSE de mónadas remotas         │
  └─────────────┴───────┴──────────────────────────────────────────────┘

  Hecho. α-hashing cubre Rust (let-else, if-let, or-patterns, let-chains), Python,
   TypeScript, JavaScript, Go. Indexa repos reales. DHT publica + descubre via
  kad. 15 TODOs en core (más patterns para edge cases).

  Bloqueante para uso end-to-end. minga-vfs es stub de 2 LOC. Sin él no hay forma
  de montar las mónadas indexadas como filesystem navegable.

  ---
  6 · modules/nahual/ (ex-yahweh) — 15,968 LOC · ★★★★★

  Framework GPUI backbone del monorepo.

  Libs (núcleo, 8 crates): core, theme, launcher, bus, meta-schema, meta-runtime,
  providers/{fs,sqlite}. Tema persistente entre runs, MetaUi declarativa,
  providers de datos.

  Widgets (12 crates): tree, container_core, splitter, tabs, tiled, text_input,
  meta-form, banner, card, stat-card, app-header, theme-switcher. Cada uno <500
  LOC, reusable individualmente.

  Hecho. Tests E2E con gpui::TestAppContext. nahual-shell define el patrón
  estándar de explorer (sidebar+main+status+hot-reload). Consumido por 5 explorers
   + cosmobiologia.

  Pendiente. Mantenimiento. Documentar el patrón "explorer estándar" como guía de
  extensión.

  ---
  7 · modules/pineal/ (ex-lapaloma) — ~3,900 LOC · ★★★☆☆

  13 crates de data-viz con backends pluggables (CPU+GPUI, GPU stub, SVG export).

  Funcionales (5 charts): core (878), render (386), cartesian (1397), financial
  (688), stream (231), phosphor (312), export.

  Stubs (<50 LOC c/u): polar, heatmap, treemap, flow, mesh.

  Hecho. Trait Canvas agnóstico, RenderPlan con RenderCmd variants, backend GPUI
  completo. Cartesian con axes + viewport + series. Financial con candlestick +
  OHLC. Streaming a 60Hz con phosphor trail (alpha decay).

  Pendiente. Cerrar los 5 stubs en orden polar → heatmap → treemap → flow → mesh.

  ---
  8 · modules/nakui/ — 7,063 LOC · ★★★★☆

  ERP categórico: entidades = objetos, morfismos = operaciones de negocio.

  Hecho. Schema declarativo Nickel (migrado de KCL). Event log con replay al
  startup. Snapshot/compaction automático. Validación FieldKind cross-field. 6
  módulos ERP estándar incluidos como ejemplos. CRUD completo + Action::Morphism
  wired al pipeline.

  Pendiente. Documentar el patrón de morfismos en Nickel como guía para extender
  el ERP a dominios nuevos.

  ---
  9 · modules/akasha/ (ex-nouser) — 4,395 LOC · ★★★☆☆

  ┌──────────────────┬───────┬────────────────────────────────────────────────┐
  │      crate       │  LOC  │                      rol                       │
  ├──────────────────┼───────┼────────────────────────────────────────────────┤
  │ akasha-core      │ 2,215 │ Daemon: scanner FS + DB sled + cluster k-means │
  ├──────────────────┼───────┼────────────────────────────────────────────────┤
  │ akasha-card      │ 709   │ Card del daemon + capabilities                 │
  ├──────────────────┼───────┼────────────────────────────────────────────────┤
  │ akasha-nous      │ (lib) │ Protocolo Nous (JSON line-delimited)           │
  ├──────────────────┼───────┼────────────────────────────────────────────────┤
  │ akasha-nous-mock │ (bin) │ Embeddings deterministas (testing)             │
  ├──────────────────┼───────┼────────────────────────────────────────────────┤
  │ akasha-nous-real │ 642   │ Embeddings con fastembed + ort                 │
  └──────────────────┴───────┴────────────────────────────────────────────────┘

  Hecho. Pipeline scan+embed+cluster funcional. notify watcher con debounce +
  re-publish al broker. Hidratación vía sled + path_hint. Centroid model
  versionado. Cache de embeddings con write-through al CAS de arje.

  Pendiente crítico. Tests sobre cluster.rs (k-means actual es naive). Manejo de
  drift de embeddings cuando cambia el modelo subyacente.

  ---
  10 · modules/shuma/ (ex-shipote) — 6,907 LOC · ★★★★☆

  ┌────────────────┬───────┬───────────────────────────────────────────────────┐
  │     crate      │  LOC  │                        rol                        │
  ├────────────────┼───────┼───────────────────────────────────────────────────┤
  │ shuma-core     │ 3,518 │ WorkspaceManager + pipeline + persist +           │
  │                │       │ flow_channel                                      │
  ├────────────────┼───────┼───────────────────────────────────────────────────┤
  │ shuma-card     │ 655   │ WorkspaceSpec + PipelineSpec + ExitPolicy +       │
  │                │       │ DiscernPolicy                                     │
  ├────────────────┼───────┼───────────────────────────────────────────────────┤
  │ shuma-protocol │ 444   │ Wire postcard length-prefixed                     │
  ├────────────────┼───────┼───────────────────────────────────────────────────┤
  │ shuma-discern  │ 307   │ DiscernPipeline + MagicBytes/Card/Json/Toml/Utf8  │
  │                │       │ probes                                            │
  └────────────────┴───────┴───────────────────────────────────────────────────┘

  Hecho. 20 fases completadas (A→S, ver docs/changelog/shuma.md):
  - A: 9 crates iniciales + smoke E2E
  - B: pipelines con discern enrichment
  - C: pipeline aislado con O_CLOEXEC + TTL + persistencia
  - D: snapshot v2 + saved pipelines + log capture
  - E: stderr separado + fan-out 1→N + tap→broker
  - F: data plane vivo (FlowChannel con accept loop)
  - G: replay buffer + templating + child_pre_exec declarativo
  - H: stats memory+CPU + stop graceful + replay configurable
  - I: memory.peak + pipeline stop selectivo + sparkline shell
  - J: CPU% multi-core + pipeline --tail + replay por bytes
  - K: cpu_cores + quota report + restart-on-failure
  - L: quota enforcement + cgroup memory.max + pipeline restart
  - M: backoff exponencial + quota breaches card + logs --follow
  - N: drain shutdown + snapshot v3 live_pipelines + batched query
  - O: collision detection sockets + stats history server-side
  - P: throughput metering + stats history persistido + auth SO_PEERCRED
  - Q: throughput card + rate-limit token-bucket + snapshot incremental
  - R: health endpoint + audit log tracing + token bucket real
  - S: audit log persistente + HTTP/JSON gateway

  Pendiente. Auth en gateway (token, mTLS). Rotación de audit.log con N backups.
  WIT contracts reales. shipote-shell click handler. Métricas Prometheus.

  ---
  11 · modules/gioser/ — 2,535 LOC · ★★★★★

  5 crates agnósticos (geom, physics, palette, shaders, canvas-web) + cdylib
  apps/gioser-web. Landing personal con chacana 3D + tilt físico al mouse + 4 tips
   elementales en Markdown.

  Hecho. Operativa. Build pipeline scripts/build-gioser-web.sh. Tests sobre
  geom/physics/palette puros. 0 TODOs.

  ---
  12 · modules/pluma/ — 178 LOC · ★★★☆☆

  ┌──────────────────┬─────┬───────────────────────────────────────┐
  │      crate       │ LOC │                  rol                  │
  ├──────────────────┼─────┼───────────────────────────────────────┤
  │ pluma-md         │ 90  │ Wrapper pulldown-cmark con AST simple │
  ├──────────────────┼─────┼───────────────────────────────────────┤
  │ pluma-reader-web │ 88  │ Reader DOM: fetch + inject + theming  │
  └──────────────────┴─────┴───────────────────────────────────────┘

  Pendiente. AST con inline elements (links, emphasis) accesibles desde Rust. Sin
  tests (todavía).

  ---
  13 · modules/vista/ — 530 LOC · ★★★★☆ (NUEVO HOY)

  ┌────────────┬─────┬───────┬────────────────────────────────────────────┐
  │   crate    │ LOC │ tests │                    rol                     │
  ├────────────┼─────┼───────┼────────────────────────────────────────────┤
  │ vista-core │ 175 │ 5/5   │ DeckState agnóstico + snap + drag decision │
  ├────────────┼─────┼───────┼────────────────────────────────────────────┤
  │ vista-web  │ 355 │ —     │ Binding DOM (PointerEvent → DeckState)     │
  └────────────┴─────┴───────┴────────────────────────────────────────────┘

  Hecho hoy. Lógica de snap (umbral 8px + bias 1.3) y máquina de estados
  (pointer_down/move/end → DragOutcome) extraída a core agnóstico. vista-web pasa
  a binding fino. Reusable en backends no-web.

  ---
  14 · modules/barra/ — 280 LOC · ★★★★☆ (NUEVO HOY)

  ┌────────────┬─────┬───────┬─────────────────────────────────────────────┐
  │   crate    │ LOC │ tests │                     rol                     │
  ├────────────┼─────┼───────┼─────────────────────────────────────────────┤
  │ barra-core │ 90  │ 5/5   │ Task + render_html + sanitize + escape      │
  ├────────────┼─────┼───────┼─────────────────────────────────────────────┤
  │ barra-web  │ 190 │ —     │ Mount sobre <ul> + click delegate + centers │
  └────────────┴─────┴───────┴─────────────────────────────────────────────┘

  Hecho hoy. Modelo Task + render HTML puro extraído a core. barra-web mantiene
  mount/click/lookups DOM intrínsecos.

  ---
  15 · modules/cosmobiologia/ — 21,502 LOC · ★★★☆☆

  Crate más grande del monorepo. 11 sub-crates.

  ┌──────────────────────────────────┬────────┬─────────┬───────┐
  │              crate               │  LOC   │  tests  │ TODOs │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-canvas             │ 2,850  │ no      │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-engine             │ 2,687  │ sí      │ 12    │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-tree               │ 2,295  │ no      │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-render             │ 1,474  │ sí      │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-panel              │ 1,037  │ sí      │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-modules            │ 955    │ —       │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ cosmobiologia-store              │ 760    │ sí      │ —     │
  ├──────────────────────────────────┼────────┼─────────┼───────┤
  │ (resto: model, theme, card, web) │ ~1,000 │ parcial │ —     │
  └──────────────────────────────────┴────────┴─────────┴───────┘

  Hecho. Render agnóstico (DrawCommand + compose_wheel) con dos backends: GPUI
  nativo + WASM SVG. App standalone funcional. Server HTTP single-user con CRUD.
  Cliente web demo SSR. Crate WASM con fallback inteligente. Compose wheel rico
  (palette + dial 3D + spread + coord labels).

  Pendiente (roadmap del proyecto):

  ┌───────┬──────────────────────────────────┬─────────────────────────┐
  │   #   │               área               │    crates afectados     │
  ├───────┼──────────────────────────────────┼─────────────────────────┤
  │ 55-62 │ Sistema GR (8 tareas)            │ engine + canvas + panel │
  ├───────┼──────────────────────────────────┼─────────────────────────┤
  │ 63    │ FFT armónico                     │ engine + modules        │
  ├───────┼──────────────────────────────────┼─────────────────────────┤
  │ 64-65 │ Research bank (corpus + queries) │ store + engine          │
  ├───────┼──────────────────────────────────┼─────────────────────────┤
  │ 66    │ 3D celestial sphere              │ render + canvas         │
  ├───────┼──────────────────────────────────┼─────────────────────────┤
  │ 67    │ Rectificador automático          │ engine + modules        │
  └───────┴──────────────────────────────────┴─────────────────────────┘

  ---
  16 · apps/ — 23 binarios

  ┌───────────────┬────────────────────────────────────────────────────────────┐
  │   categoría   │                            apps                            │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Protocol      │ brahman-broker-explorer, brahman-demo                      │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │               │ nahual-shell, nahual-file-explorer,                        │
  │ Nahual suite  │ nahual-database-explorer, nahual-text-viewer,              │
  │               │ nahual-image-viewer                                        │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Akasha        │ akasha-explorer                                            │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Nakui         │ nakui-ui, nakui-explorer                                   │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Minga         │ minga-explorer                                             │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Shuma         │ shuma-daemon, shuma-cli, shuma-gateway, shuma-shell        │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Pineal demos  │ pineal-demo, pineal-stream-demo, pineal-phosphor-demo,     │
  │               │ pineal-financial-demo                                      │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Web           │ gioser-web (cdylib)                                        │
  ├───────────────┼────────────────────────────────────────────────────────────┤
  │ Cosmobiología │ cosmobiologia (GPUI), cosmobiologia-cli,                   │
  │               │ cosmobiologia-server                                       │
  └───────────────┴────────────────────────────────────────────────────────────┘

  ---
  17 · Tooling y artefactos cross-cutting

  scripts/
  ├── reorg.py              ← migración monorepo (hoy)
  ├── split-changelog.py    ← partición CHANGELOG (hoy)
  ├── bootstrap-demo.sh     ← escenario reproducible
  ├── build-arje-initrd.sh  ← initramfs CPIO+gzip musl-static
  ├── build-gioser-web.sh   ← WASM + wasm-bindgen
  ├── install-arje-as-init.sh, uninstall-arje.sh
  └── run-arje-qemu.sh

  seeds/
  ├── arje-minimal.card.json  ← shell bare
  ├── arje-host.card.json     ← full host (13 sub-cards)
  └── arje-prod.card.json     ← 15 sub-cards prod (tmpfiles, binfmt, daemons,
  getty)

  docs/
  ├── STATUS.md, ROADMAP.md  ← global (hoy)
  ├── arje-boot.md           ← initrd + QEMU + bare metal
  ├── arje-replace-systemd.md
  └── changelog/             ← 7 buckets por proyecto (hoy)

  ---
  18 · Métricas agregadas

  ┌───────────────────────┬────────────────────────────────────────────────────┐
  │       dimensión       │                       valor                        │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ Total crates          │ 126                                                │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ Binarios [[bin]]      │ 35                                                 │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ Librerías             │ 89                                                 │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ cdylib (WASM)         │ 2 (gioser-web, cosmobiologia-web)                  │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ LOC totales           │ ~78,000                                            │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ Crates con tests      │ 65 / 126 (52%) — esperable, compat shims sin tests │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ TODOs/FIXMEs/todo!()  │ 155 total · 78% concentrado en 4 crates            │
  ├───────────────────────┼────────────────────────────────────────────────────┤
  │ Cobertura cargo check │ 100% (workspace verde)                             │
  └───────────────────────┴────────────────────────────────────────────────────┘

  Concentración de deuda técnica:
  - cosmobiologia-engine: 12 TODOs (sistema GR, harmonics)
  - ente-brain: 11 TODOs (rule engine)
  - brahman-handshake: 10 TODOs (trust fase 4)
  - shuma-core: 14 TODOs (supervisión avanzada)
  - Otros 65 crates: 108 TODOs distribuidos

  ---
  19 · Plan global a finalización

  Orden topológico (bottom-up del stack), con dependencias declaradas.

  Hito 1 · Cobertura crítica (semana 1-2)

  Cierra los gaps donde el código existe pero no hay tests, antes de añadir
  features sobre código no validado.

  ┌───────────────────────────────────────────┬───────────────┬───────────────┐
  │                   tarea                   │     crate     │  desbloquea   │
  ├───────────────────────────────────────────┼───────────────┼───────────────┤
  │ Tests E2E sobre cosmobiologia-canvas      │ cosmo-canvas  │ confianza UI  │
  ├───────────────────────────────────────────┼───────────────┼───────────────┤
  │ Tests E2E sobre cosmobiologia-tree        │ cosmo-tree    │ confianza UI  │
  ├───────────────────────────────────────────┼───────────────┼───────────────┤
  │ Tests sobre akasha-core::cluster          │ akasha-core   │ drift         │
  │ (k-means)                                 │               │ handling      │
  ├───────────────────────────────────────────┼───────────────┼───────────────┤
  │ Tests FractalSnapshot restore con stale   │ ente-snapshot │ resiliencia   │
  │ fds                                       │               │               │
  ├───────────────────────────────────────────┼───────────────┼───────────────┤
  │ Tests sobre brahman-admin (único protocol │ brahman-admin │ cierre suite  │
  │  sin tests)                               │               │               │
  └───────────────────────────────────────────┴───────────────┴───────────────┘

  Salida: ≥1 test por crate sin cobertura actual + matriz de panics.

  Hito 2 · Cerrar stubs bloqueantes (semana 2-3)

  ┌────────────────┬───────────────────┬───────────────────────────────┐
  │      stub      │ LOC actual → meta │            impacto            │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ minga-vfs      │ 2 → ~600          │ Mount FUSE de mónadas remotas │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ pineal-polar   │ <50 → ~300        │ Coord polar funcional         │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ pineal-heatmap │ <50 → ~250        │ Grid 2D color-mapped          │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ pineal-treemap │ <50 → ~300        │ Rectangular treemap           │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ pineal-flow    │ <50 → ~400        │ Sankey diagrams               │
  ├────────────────┼───────────────────┼───────────────────────────────┤
  │ pineal-mesh    │ <50 → ~250        │ Triangle mesh + barycentric   │
  └────────────────┴───────────────────┴───────────────────────────────┘

  Bloqueante de minga-vfs: estabilizar tras Hito 1 (sin tests es prematuro).

  Hito 3 · Cerrar TODOs concentrados (semana 3-5, paralelo)

  Tres tracks independientes, paralelizables:

  Track A — Brain rule engine (ente-brain, 11 TODOs)
  - Evaluador completo de policies declarativas
  - Observer estadístico cross-ente (Bayesian update)
  - Reglas como Cards (recursión: policies son módulos)

  Track B — Shuma supervisión (shuma-core, 14 TODOs)
  - Auth gateway (token via env / mTLS)
  - Rotación audit.log con N backups
  - WIT contracts reales sobre flow types
  - Métricas exportables (Prometheus endpoint)
  - shipote-shell click handler

  Track C — Handshake fase 4 (brahman-handshake, 10 TODOs)
  - Capabilities revocables
  - Trust beyond peer (delegación)
  - Métricas + audit chain hacia brain

  Hito 4 · Cosmobiología innovaciones (semana 4-7)

  Roadmap del proyecto, 5 áreas:

  1. Sistema GR (#55-#62) — dual-ring directas+conversas, scrubbing live, HUD
  triggers, modo rectificación. Requiere expansión de cosmobiologia-engine +
  cosmobiologia-panel.
  2. FFT armónico (#63) — detección automática de ciclos en órbitas. Sobre
  cosmobiologia-modules.
  3. Research bank (#64-#65) — corpus de cartas + queries. Sobre
  cosmobiologia-store + cosmobiologia-engine.
  4. 3D celestial sphere (#66) — renderer esférico vs el 2D actual. Sobre
  cosmobiologia-render + cosmobiologia-canvas.
  5. Rectificador automático (#67) — ajuste de hora natal vía eventos confirmados.
   Sobre cosmobiologia-engine + cosmobiologia-modules.

  Hito 5 · Compat avanzado systemd (semana 5-7, paralelo a Hitos 3-4)

  ┌──────────────────────┬──────────────────────┬────────────────────┐
  │         shim         │   método pendiente   │     desbloquea     │
  ├──────────────────────┼──────────────────────┼────────────────────┤
  │ ente-logind-compat   │ Inhibit, Sleep hooks │ GNOME power mgmt   │
  ├──────────────────────┼──────────────────────┼────────────────────┤
  │ ente-localed-compat  │ SetVariable          │ apps con locale UI │
  ├──────────────────────┼──────────────────────┼────────────────────┤
  │ ente-machined-compat │ MachineImage ops     │ nspawn workflows   │
  └──────────────────────┴──────────────────────┴────────────────────┘

  Meta: GNOME Shell arrancable sobre ente-zero sin parches.

  Hito 6 · Polish + DX + onboarding (semana 7-8)

  - scripts/check.sh que corra fmt + clippy + test --workspace
  - Aliases legacy de binario: shipote → shuma, yahweh → nahual
  - README raíz que apunte a los 16 SDDs y al ROADMAP
  - Actualizar seeds/arje-*.card.json con nombres nuevos
  - Pluma AST con inline elements completos

  ---
  20 · Diagrama de dependencias del stack

                      ┌──────────────┐
                      │  apps/ (23)  │
                      └──────┬───────┘
                             ↓
              ┌──────────────────────────────┐
              │       modules/ (62)          │
              │                              │
              │  cosmobiologia ←──────┐      │
              │       ↓               │      │
              │  nahual + pineal      │      │
              │       ↓               │      │
              │  shuma  akasha  nakui │      │
              │       minga           │      │
              │  gioser pluma vista   │      │
              │  barra                │      │
              └──────────────┬────────────┬──┘
                             ↓            │
                      ┌─────────────┐     │
                      │  runtime/   │←────┘
                      │ bus·cas·    │
                      │ wasm·brain  │
                      └──────┬──────┘
                             ↓
                      ┌─────────────┐
                      │   init/     │
                      │ ente-zero,  │
                      │ kernel,     │
                      │ incarnate   │
                      └──────┬──────┘
                             ↓
                      ┌─────────────────┐
                      │   protocol/     │
                      │ card·handshake· │
                      │ broker·sidecar  │ ← TODOS dependen de esto
                      │ net             │
                      └─────────────────┘

                      [compat/ corre en paralelo, consume bus/card]

  ---
  21 · Cronograma global

  sem 1     sem 2     sem 3     sem 4     sem 5     sem 6     sem 7     sem 8
  ├─Hito1──►
            ├─Hito2──►
                      ├─Hito3 Track A (brain)──────────────►
                      ├─Hito3 Track B (shuma)──────────────►
                      ├─Hito3 Track C (handshake)──────────►
                                ├─Hito4 (cosmo innov)─────────────────►
                                          ├─Hito5 (compat avanzado)──►
                                                              ├─Hito6 (polish)─►

  Solo persona: ~7-8 semanas continuas. Paralelizado (3 tracks Hito 3 + Hito 4 +
  Hito 5 disjuntos): ~3-4 semanas.

  ---
  22 · Bloqueantes críticos (vigilar)

  1. minga-vfs stub → sin él el sistema de archivos de mónadas no existe → bloquea
   akasha como fuente de datos integrada.
  2. ente-brain rule engine parcial → sin él, la observabilidad fractal es opaca →
   bloquea decisiones políticas autónomas del Init.
  3. Cosmobiología canvas/tree sin tests → 5,145 LOC de UI sin red de seguridad →
  cualquier refactor en GPUI es riesgoso.
  4. Compat shims básicos → Inhibit/SetVariable/MachineImage faltan → GNOME no es
  estable sobre arje.

  ---
  23 · Resumen de un vistazo

  ┌───────────────┬─────────┬────────┬───────┬─────────────────────────────────┐
  │  capa/módulo  │ madurez │  LOC   │ tests │        acción siguiente         │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ protocol      │ ★★★★☆   │ 6,260  │ sí    │ fase 4 trust (Hito 3C)          │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ init          │ ★★★★☆   │ 3,600  │ parc. │ snapshot restore tests (H1)     │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ runtime       │ ★★★☆☆   │ 3,400  │ parc. │ brain rule engine (H3A)         │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ compat        │ ★★★☆☆   │ 5,000  │ no    │ métodos avanzados (H5)          │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ minga         │ ★★★★☆   │ 5,091  │ sí    │ vfs (H2) ◄ BLOQUEANTE           │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ nahual        │ ★★★★★   │ 15,968 │ E2E   │ mantenimiento                   │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ pineal        │ ★★★☆☆   │ 3,900  │ sí    │ 5 stubs (H2)                    │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ nakui         │ ★★★★☆   │ 7,063  │ sí    │ docs morfismos (H6)             │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ akasha        │ ★★★☆☆   │ 4,395  │ parc. │ cluster tests (H1)              │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ shuma         │ ★★★★☆   │ 6,907  │ sí    │ auth gateway (H3B)              │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ gioser        │ ★★★★★   │ 2,535  │ sí    │ estable                         │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ pluma         │ ★★★☆☆   │ 178    │ no    │ AST inline (H6)                 │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ vista (HOY)   │ ★★★★☆   │ 530    │ 5/5   │ estable                         │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ barra (HOY)   │ ★★★★☆   │ 280    │ 5/5   │ estable                         │
  ├───────────────┼─────────┼────────┼───────┼─────────────────────────────────┤
  │ cosmobiologia │ ★★★☆☆   │ 21,502 │ parc. │ tests canvas/tree (H1) + innov  │
  │               │         │        │       │ (H4)                            │
  └───────────────┴─────────┴────────┴───────┴─────────────────────────────────┘

  Trazo desde aquí: Hito 1 desbloquea Hito 2, que desbloquea Hito 3 en paralelo
  con Hito 4 y Hito 5, cerrando con Hito 6 polish. Estimación realista a v1.0
  estable: 6-8 semanas continuas o 3-4 semanas con paralelización agresiva.


  temas de dudas (sí te dije que esa ia estaba loca en ese texto):
  1. no es hypervisor, pero sí ejecuta procesos con capacidad de aislamiento. lo que hablamos antes, acláralo si no lo hablamos antes. pero vamos a estar conectados con brahman, posiblemente ejecutando procesos en dht.
  2. usa tu criterio, pero la idea es que este como compositor es el pintor del lienzo, pero va a tener la capacidad de delegar a través de brahman trozos de su superficie a otras aplicaciones/módulos, y estos a su vez pueden disponer de subtrozos para otras aplicaciones/modulos. así que vamos a hacer, tanto pintar en wayland, como orquestar las aplicaciones que tendremos dentro. para aplicaciones agnósticas, que va a ser lo "normal", va a comportarse digamos como un compositor normal.
  3. no, usa protocolo logind. eso del criu déjalo para un futuro. lo del aislamiento va a seguir la misma política de las cards.

  del navegador:
  tienes razón. bueno, sigue las mejores reglas para repartir la responsabilidad. es el compositor el que define los layers, no? y la pintada. y se las da a las aplicaciones que se lo piden que puede ejecutar el shell/launcher, ayudame en eso, que hoy no dormí bien. modularidad horizontal.

 decisiones:
 1. carmen.
 2. minga es el git, no la red. la red dht debería ser un core invisible para todo el ecosistema brahman. o sea, c.
 3. criu. déjalo para otro día pero no lo olvides.
 4. c.
 5. declarado.
 6. si es forzado, no. pero cuando sea grande lo voy a querer.











  ---
  Nuevo PLAN_MACRO con subtareas multi-nivel

  FASE A · Foundations cleanup + renames batch (sem 1-2)
  ├─ A1 · Rename batch en código
  │   ├─ A1.1  Modificar scripts/rename-fase-a.py (add MOVES + PKG_RENAMES)
  │   ├─ A1.2  Dry-run verificación
  │   ├─ A1.3  Ejecutar: git mv + sed Cargo.toml + sed .rs + workspace toml
  │   ├─ A1.4  cargo check --workspace verde
  │   ├─ A1.5  Actualizar SDDs (init, runtime, compat → arje; revista; fana)
  │   ├─ A1.6  Actualizar docs/STATUS.md, ROADMAP.md, PLAN_MACRO.md
  │   ├─ A1.7  Mover
  docs/changelog/{init,runtime,compat,minga,nahual,nakui,protocol}.md (referencias
   internas a arje-)
  │   └─ A1.8  Commit + push
  │
  ├─ A2 · Split arje-brain en 3 sub-crates
  │   ├─ A2.1  arje-brain-rules (engine + rules + dispatch — 678 LOC)
  │   ├─ A2.2  arje-brain-cognitive (observer + crystallize + autopromote — 799
  LOC)
  │   ├─ A2.3  arje-brain-audit (audit + introspect + metrics — 1,201 LOC)
  │   ├─ A2.4  arje-brain umbrella opcional (features-based) o eliminar
  │   ├─ A2.5  Migrar consumidores (arje-zero, chasqui-core)
  │   └─ A2.6  cargo check + commit
  │
  ├─ A3 · Unificar loader duplicado
  │   ├─ A3.1  Mover arje-brain/loader.rs → brahman-cards
  │   ├─ A3.2  brahman-cards gana load_card_file + load_rules_file +
  extract_*_from_json
  │   ├─ A3.3  arje-brain depende de brahman-cards
  │   └─ A3.4  cargo check + commit
  │
  ├─ A4 · Extraer sandokan-lifecycle de shuma-core
  │   ├─ A4.1  Crear crate runtime/sandokan-lifecycle
  │   ├─ A4.2  Mover primitivas: TTL + restart backoff + quota enforce + drain +
  snapshot
  │   ├─ A4.3  shuma-core depende de sandokan-lifecycle como cliente
  │   ├─ A4.4  Tests existentes siguen pasando
  │   └─ A4.5  cargo check + commit
  │
  ├─ A5 · Ampliar arje-incarnate con pivot_root + OverlayFS
  │   ├─ A5.1  Agregar pivot_root al builder de Incarnator
  │   ├─ A5.2  Agregar capa OverlayFS declarativa (rootfs RO + session RW)
  │   ├─ A5.3  Tests: chroot básico funciona + overlay funciona
  │   └─ A5.4  cargo check + commit
  │
  └─ A6 · Crear brahman-ssh-multiplex
      ├─ A6.1  Wrapper sobre russh
      ├─ A6.2  Canales paralelos + TCP_NODELAY + KeepAlive 15s
      ├─ A6.3  Reconexión silenciosa
      ├─ A6.4  Tests con servidor SSH local
      └─ A6.5  cargo check + commit

  FASE B · Core libraries (sem 2-5)
  ├─ B1 · sandokan (orquestador library)
  │   ├─ B1.1  Trait Engine { run/track/telemetry }
  │   ├─ B1.2  LocalEngine (in-process: arje-incarnate + arje-brain-rules +
  broker)
  │   ├─ B1.3  DaemonEngine (postcard sobre Unix socket)
  │   ├─ B1.4  RemoteEngine (sobre brahman-ssh-multiplex + DaemonEngine remoto)
  │   ├─ B1.5  Engine::auto() detecta socket y elige
  │   └─ B1.6  Tests + integración con arje-zero como daemon host
  │
  ├─ B2 · verbo (embeddings multi-backend)
  │   ├─ B2.1  verbo-core (trait Provider, ModelId, EmbeddingVector)
  │   ├─ B2.2  verbo-cohere (HTTP API remoto)
  │   ├─ B2.3  verbo-bge-local (bge-code-large vía ort)
  │   ├─ B2.4  verbo-mini-local (MiniLM-L6-v2 384d vía ort, para badu)
  │   ├─ B2.5  verbo-fastembed (fallback)
  │   ├─ B2.6  verbo-daemon (binario --backend X, multi-instancia)
  │   ├─ B2.7  verbo-client (cliente IPC)
  │   └─ B2.8  Migrar chasqui-nous-real de fastembed inline → verbo-client
  │
  ├─ B3 · brahman-dht (library DHT agnóstica)
  │   ├─ B3.1  Sobre brahman-net libp2p (kad + provider records)
  │   ├─ B3.2  Trait DhtBackend con kind: Code | Card | Persona | ...
  │   ├─ B3.3  Publish + lookup + announce
  │   └─ B3.4  Consumido por minga-p2p (kind=Code), brahman-card-discovery
  (kind=Card), agorapura (kind=Persona)
  │
  └─ B4 · brahman-card-discovery
      ├─ B4.1  Trait CardSearch + impls local (CAS + filesystem) + dht (vía
  brahman-dht)
      ├─ B4.2  Filtros por kind, flow type, capabilities
      └─ B4.3  Widget nahual/widgets/card-browser consume CardSearch

  FASE C · Apps standalone (sem 4-12, paralelizables)
  ├─ C1 · fana (prioridad alta — absorbe pluma + nuevo writer's DAG editor)
  │   ├─ C1.1  fana-core (NarrativeAtom + NarrativeGraph + CoherenceState)
  │   ├─ C1.2  fana-md (absorbe pluma-md como parser markdown)
  │   ├─ C1.5  fana-store (sled o RocksDB + bincode/rkyv zero-copy)
  │   ├─ C1.6  fana-llm (cliente HTTP a LLMs remotos vía reqwest)
  │   ├─ C1.7  fana-render-plan (DrawCommands agnósticos: editor + sidepane +
  ghost trace)
  │   ├─ C1.8  fana-editor-gpui (WorkspaceEditor View custom +
  OscilloscopeSidepane + GhostTrace)
  │   ├─ C1.9  fana-md-reader-web (absorbe pluma-reader-web, sigue siendo dep de
  gioser-web)
  │   ├─ C1.10 fana-editor-web (futuro WASM editor)
  │   ├─ C1.11 apps/fana (binario GPUI)
  │   └─ C1.12 apps/fana-web (futuro cdylib)
  │
  ├─ C2 · badu (note-taking, ex-akashi)
  ├─ C3 · dominium (simulador psicológico)
  ├─ C4 · takiy (composición musical)
  ├─ C5 · matilda (server admin)
  ├─ C6 · mirada (compositor Wayland, ex-carmen)
  └─ C7 · agorapura (identidad humana federada)

  FASE D · charka (paralelo multi-mes)
  FASE E · yachay (integrador, sem 12-18)
  FASE F · Cobertura tests + cerrar stubs cosmo/pineal (continuo)
  FASE G · Backlog (rimay, yuyay, apu, tinkuy, nutu, ...)






  cargo build -p sandokan-cli
  ./target/debug/sandokan daemon &              # terminal/background
  ./target/debug/sandokan run /bin/sleep 300    # → card_id
  ./target/debug/sandokan list
  ./target/debug/sandokan status <card-id>
  ./target/debug/sandokan stop <card-id>






● Comandos de prueba

  target/ está en 22 GB — pero tranquilo: está gitignored, el repo git
  real son 96 MB. El "desborde" es disco, no el repositorio. Más abajo
  el cargo clean.

  Todo de una

  cargo check --workspace        # compila los ~145 crates
  cargo test  --workspace        # corre TODOS los tests (~270)

  sandokan — el ejecutable interactivo

  cargo build -p sandokan-cli
  ./target/debug/sandokan daemon &                 # deja el daemon
  corriendo
  ./target/debug/sandokan run /bin/sleep 300       # imprime un card_id
  ./target/debug/sandokan list                     # lo ves activo
  ./target/debug/sandokan status   <card-id>       # → Running
  ./target/debug/sandokan telemetry <card-id>      # → mem / nproc
  ./target/debug/sandokan stop     <card-id>       # → detenido
  ./target/debug/sandokan status   <card-id>       # → Killed

  Tests por área (lo construido esta sesión)

  # Fase A — foundations
  cargo test -p arje-brain-rules -p arje-brain-cognitive -p
  arje-brain-audit \
             -p sandokan-lifecycle -p arje-incarnate

  # Fase B — orquestador + discovery
  cargo test -p sandokan-core -p sandokan-local -p sandokan-daemon -p sandokan \
             -p brahman-dht -p brahman-card-discovery -p  brahman-ssh-multiplex

  # Fase F — pineal (6 charts)
  cargo test -p pineal-render -p pineal-export -p pineal-heatmap \
             -p pineal-polar -p pineal-treemap -p pineal-flow -p
  pineal-mesh

  # Apps Fase C — núcleos
  cargo test -p fana-core -p fana-graph -p fana-store -p fana-semantic
    # fana
  cargo test -p shuma-intent
   # shuma shell
  cargo test -p verbo-core -p verbo-mock
   # verbo
  cargo test -p dominium-core
   # dominium

  Validación arje (boot — ya existía)

  seeds/validate.sh seeds/arje-minimal.card.json

  ⚠  Disco — cargo clean

  target/ = 22 GB y va a seguir creciendo (gpui, libp2p, russh son
  pesados). Cuando quieras recuperar ese espacio:

  cargo clean         # borra target/ entero — recupera ~22 GB

  Tras eso, el próximo cargo build recompila todo desde cero (lento,
  ~varios min). Recomendación: corré tus pruebas, y cuando termines una
   tanda, cargo clean. No afecta nada del código ni del repo — sólo
  artefactos de compilación.

  ¿Querés que lo corra yo ahora (cargo clean), o lo dejás para cuando
  termines de probar esta tanda? Si lo corro ahora, tu próxima prueba
  recompila de cero.



  Lo construido — 6 módulos, 16 crates nuevos

  ┌───────────┬───────────────────────────────┬───────┬────────────────────────────────┐
  │  módulo   │            crates             │ tests │             estado             │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ dominium  │ render-plan, canvas-gpui, app │ 37    │ ✅ completo                    │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ verbo     │ verbo-daemon                  │ 8     │ ✅ daemon entre-procesos       │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ fana      │ render-plan, editor-gpui, app │ 12    │ ✅ editor DAG (prioridad alta) │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ agorapura │ core, graph, app              │ 22    │ ✅ identidad federada          │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ badu      │ core, gravity, app            │ 29    │ núcleo + demo                  │
  ├───────────┼───────────────────────────────┼───────┼────────────────────────────────┤
  │ takiy     │ takiy-core                    │ 24    │ núcleo de teoría musical       │
  └───────────┴───────────────────────────────┴───────┴────────────────────────────────┘

  132 tests nuevos, todos verdes. cargo check --workspace verde en cada commit. 14 commits pusheados.

  Para que verifiques tú (apps GPUI — no las puedo ver)

  cargo run -p dominium    # simulador isométrico vivo
  cargo run -p fana        # editor DAG — «Mutar raíz» dispara la onda de choque
  cargo run -p shuma-shell # el shell de 3 zonas

  Ya verifiqué yo (CLI, corren bien)

  cargo run -p agorapura   # Venezuela atestigua a Yumaira; firma falsa rechazada; veredictos por política
  cargo run -p badu        # cuaderno: grafo de enlaces + clústeres por gravedad semántica


  Verificación

  Apps GPUI — necesito que las veas tú:
  cargo run -p dominium      # simulador isométrico vivo
  cargo run -p fana          # editor DAG — «Mutar raíz» dispara la onda de choque
  cargo run -p shuma-shell   # el shell de 3 zonas

  Demos CLI — ya las verifiqué yo, corren bien:
  cargo run -p agorapura     # Venezuela atestigua a Yumaira; veredictos por política
  cargo run -p badu          # cuaderno: grafo de enlaces + clústeres por gravedad
  cargo run -p matilda       # inventario → docker-compose + nginx + plan de reconciliación
  cargo run -p yachay        # notebook: orden de ejecución + digest cambia al editar




  matilda — el puente plan→ejecución

  Avancé el módulo de server admin con matilda-apply: traduce el Plan de reconciliación a pasos concretos —los archivos a escribir y los comandos a
  correr en el servidor— y a un script bash listo para ejecutar. cargo run -p matilda ahora lo imprime:

  # crear contenedor «api»
  docker run -d --name api --restart unless-stopped -p 9000:9000 ...
  # actualizar contenedor «web»
  docker rm -f web
  docker run -d --name web ...
  # crear vhost «api.jlsoltech.com»
  cat > /etc/nginx/sites-enabled/api.jlsoltech.com.conf <<'MATILDA_EOF'
  server { listen 443 ssl; ... }
  MATILDA_EOF
  nginx -t && nginx -s reload




  1 · El ejecutable

  apps/matilda ya es un ejecutable CLI completo:
  cargo run -p matilda -- example > /tmp/inv.json
  cargo run -p matilda -- plan /tmp/inv.json --discover
  cargo run -p matilda -- apply /tmp/inv.json --host deploy@servidor

  2 · Embebido en el shell — cargo run -p shuma-shell

  matilda ahora es una herramienta del shell, no una app aparte. Dentro de la ventana de shuma:

  :matilda plan   /tmp/inv.json     → tarjeta con el plan de reconciliación
  :matilda script /tmp/inv.json     → tarjeta con el script bash
  :matilda apply  /tmp/inv.json     → ejecuta el script de verdad

  - Reconcilia contra el estado real de la máquina (lee tus contenedores docker + sitios nginx).
  - plan/script aparecen como tarjetas sintéticas en el feed.
  - apply corre el script como cualquier comando: salida en streaming, captura acotada, botón de matar, acordeón — todo el aparato del shell,
  gratis.
  - El panel [RUN] tiene ahora una sección [tools] con ⚙ matilda — un clic precarga :matilda plan  en el input para que sólo nombres el archivo.



  Flujo end-to-end demoable hoy sin gráficos:
  cargo run -p mirada-body --example headless -- /tmp/mirada.sock   # el Cuerpo
  MIRADA_SOCKET=/tmp/mirada.sock cargo run -p mirada                # el Cerebro
  Sin MIRADA_SOCKET, mirada corre en simulación: ventanas sintéticas y teclado propio (n abre, j/k foco, tab cicla layout, 1-9 escritorios).



  El Cuerpo de verdad — mirada-compositor:
  Compositor Wayland teselante real sobre smithay, backend winit (corre anidado, una ventana dentro de tu sesión X11/Wayland).
  cargo run -p mirada-compositor                                   # autónomo: Cerebro Desktop embebido, un solo proceso
  WAYLAND_DISPLAY=wayland-1 foot                                    # lanza clientes contra él (imprime su WAYLAND_DISPLAY al arrancar)
  MIRADA_SOCKET=/tmp/mirada.sock cargo run -p mirada-compositor     # enlazado: la app mirada (Cerebro GPUI) decide la geometría
  Habla wl_compositor/xdg_shell/wl_shm/wl_seat/wl_data_device; compone con GlesRenderer. Reusa mirada-body y mirada-link.
  Ver crates/apps/mirada-compositor/README.md.





