# renaser — Fase 7 :: Apps que nacen del Grafo

Plan de ataque. Para el estado general ver `ROADMAP.md`; para la arquitectura,
`ARCHITECTURE.md`.

## El objetivo

Hoy el kernel lleva el userspace **empotrado en su propio binario**:
`main.rs` tiene cuatro `include_bytes!` (`app.wasm`, `discola.wasm`,
`glotona.wasm`, `cronista.wasm`) y cinco llamadas `encender_app` con regiones
escritas a mano. Eso contradice la tesis de renaser: el almacenamiento es un
**grafo de objetos direccionado por contenido**, no un binario monolítico.

La Fase 7 **destruye el `include_bytes!` del userspace**. Las aplicaciones
pasan a ser objetos del grafo; el kernel las descubre, las verifica por su
hash y las inyecta en caliente en `wasmi`. Qué apps arrancan, con qué cuota y
en qué región lo dicta un **Manifiesto de Génesis** que también vive en el
grafo. (La fuente `font.ttf` sigue empotrada: es del kernel, no del userspace.)

## El problema de la génesis

Hay un huevo-y-gallina: el kernel lee el manifiesto para saber qué cargar,
pero el manifiesto y el bytecode tienen que haber sido escritos antes. En un
disco virgen no hay nada. Dos vías para sembrarlo:

- **A — el kernel siembra.** En un disco sin manifiesto, el kernel graba en el
  grafo el bytecode de unas apps de génesis y un manifiesto por defecto. El
  bytecode de génesis llega vía `include_bytes!` — todavía.
- **B — `boot` siembra la imagen.** El constructor de imagen (anfitrión)
  pre-puebla el disco con los objetos de bytecode y el manifiesto. El kernel
  jamás empotra una app.

B es el estado final puro, pero exige enseñarle a `boot` el formato del grafo
(objetos, BLAKE3, log, superbloque) — trabajo de anfitrión considerable. Se
ataca **incremental**, como las Fases 6.1a/b/c.

## Sub-fases

### 7a — El Manifiesto y la carga desde el grafo (semilla por el kernel) — ✅ HECHA

1. **`manifiesto.rs`** *(andamiaje ya creado)* — tipos `Manifiesto` /
   `EntradaApp`, (de)serialización postcard. Hoy es un módulo `no_std` del
   kernel; no se comparte con las apps (la frontera app↔kernel es el ABI WASM
   numérico, no tipos Rust).
2. **`almacen.rs`** — el `SuperBloque` gana un segundo ancla,
   `manifiesto: Option<Hash>`, gemelo de `raiz`. `VERSION` sube de `1` a `2`
   (un disco v1 se reformatea, como ya hace `init` con discos ajenos).
   Getters `manifiesto()` / `fijar_manifiesto()`.
3. **`manifiesto::sembrar_genesis()`** — en un disco sin manifiesto: graba el
   bytecode de las apps de génesis (`include_bytes!`, **sólo aquí**), compone
   un `Manifiesto` por defecto con sus regiones y cuotas, lo graba y lo ancla.
4. **`manifiesto::cargar()`** — lee el ancla del superbloque, recupera el
   objeto, lo deserializa.
5. **`kernel_main`** — reemplaza las cinco `encender_app` escritas a mano por:
   cargar el manifiesto (o sembrarlo si falta) e iterar sus `EntradaApp`.
6. **`wasm/mod.rs`** — el techo de memoria deja de ser la constante
   `TECHO_MEMORIA` y pasa a venir por-app del manifiesto (`EntradaApp`).
7. **Verificar en QEMU** — la pantalla debe verse idéntica a la Fase 6.2
   (cinco apps en sus regiones), pero ahora **nacidas del grafo**.

### 7b — La imagen sembrada por `boot`; muere `include_bytes!` — ✅ HECHA

- `boot` (anfitrión) aprende el formato del grafo y pre-puebla la imagen de
  disco con los objetos de bytecode + el manifiesto.
- El kernel pierde los `include_bytes!` del userspace; `sembrar_genesis` se
  retira o queda como camino vacío de respaldo.

### 7c — Persistencia inter-sesión — ✅ HECHA

- Una app (cronista evolucionada, o una nueva interactiva) guarda su estado
  mutado como un objeto nuevo del grafo al recibir teclado.
- Cada `EntradaApp` usa su campo `estado: Option<Hash>` (ya previsto en el
  tipo). Al guardar, el kernel reescribe el manifiesto; al arrancar, le pasa
  ese estado a la app para que despierte donde quedó.
- Probablemente una capacidad host nueva para que el kernel se entere del
  hash de estado nuevo que la app produjo.

## Guardarraíles (directiva de la arquitecta)

- **No romper `check-shared-cores.sh`.** Si algún tipo del manifiesto llegara
  a compartirse entre apps y kernel, debe habitar un núcleo estrictamente
  `no_std`. Hoy no se comparte: `manifiesto.rs` es kernel-only.
- **Errores recuperables con `Result`.** Si el kernel lee del grafo un objeto
  de bytecode corrupto (su hash recomputado ≠ su id), `almacen::recuperar` ya
  lo detecta — devuelve `Err`. El kernel **niega esa instanciación**, pinta la
  baliza de desalojo en la región de esa app, y **sigue levantando el resto**.
  Un módulo podrido nunca tumba el arranque.

## Estructura de archivos

| archivo | estado | rol en la Fase 7 |
| --- | --- | --- |
| `kernel/src/manifiesto.rs` | **nuevo (7a)** | tipos `Manifiesto`/`EntradaApp` + (de)serialización + carga/siembra |
| `kernel/src/almacen.rs` | a modificar (7a) | `SuperBloque.manifiesto`, `VERSION` 2, getters |
| `kernel/src/main.rs` | a modificar (7a) | `kernel_main` itera el manifiesto en vez de `include_bytes!` |
| `kernel/src/wasm/mod.rs` | a modificar (7a) | techo de memoria por-app desde el manifiesto |
| `boot/` | a modificar (7b) | siembra la imagen de disco con el grafo |
