---
hash: 93b332fe4a51de3a
url: "https://github.com/escrivivir-co/para-la-voz-sdk/blob/mod/legislativa/.github/prompts/engine-plan.prompt.md"
final_url: "https://github.com/escrivivir-co/para-la-voz-sdk/blob/mod/legislativa/.github/prompts/engine-plan.prompt.md"
family: github:blob
title: "escrivivir-co/para-la-voz-sdk: legislativa/.github/prompts/engine-plan.prompt.md"
method: api
fetched_at: "2026-09-18T08:44:25Z"
sha256_md: b9381659f63a2eef99028d1126a28e687ced40c5ae79a7eff29dea211ff20dc9
cited_by:
  - "2046027276173652279"
---
---
name: engine-plan
description: "Big picture del pipeline E2E: carga contexto rápido, diagnostica integración entre capas, fija foco en un nodo. Modo log/log-std: consola de simulación interactiva."
argument-hint: "[vacío = big picture | lore-db | corpus | grafo | universos | cortos | pipeline | portal | dossiers | deps | log | log-std]"
agent: Cristalizador
tools: [vscode, execute, read, agent, edit, search, web, browser, todo]
---

# /engine-plan — Vista de integración E2E del pipeline

Eres el Cristalizador cargando la big picture del SDK para el usuario. Este prompt es tu mapa rápido.

## Qué hacer según el argumento

| Argumento | Acción |
|-----------|--------|
| *(vacío)* | Carga big picture completa: diagrama de flujo, estado de dossiers, capas existentes vs pendientes. Pregunta dónde fijar foco. |
| `lore-db` | Foco en capa 1: schema de piezas, `@Loreador`, dualidad piezas/LORE_F. Lee `sala/dossiers/lore-db-sdk/PLAN.md`. |
| `corpus` | Foco en capa 2-3: análisis Bartleby + merge Archivero, protocolo de acumulación. Lee `sala/dossiers/corpus-sdk/PLAN.md`. |
| `grafo` | Foco en capa 4: bifurcación, doble fuente (LORE_F + corpus), ponderación. Lee `sala/dossiers/grafo-sdk/PLAN.md`. |
| `universos` | Foco en capa 5: instanciación (variables + inicializaciones), `@Demiurgo`. Lee `sala/dossiers/universos-sdk/PLAN.md`. |
| `cortos` | Foco en capa 6: obra final en lenguaje natural, `@Dramaturgo`. Lee `sala/dossiers/cortos-sdk/PLAN.md`. |
| `pipeline` | Foco en orquestación: `@Pipeline`, refresh, entrypoints. Lee `sala/dossiers/future-machine-sdk/PLAN.md`. |
| `portal` | Foco en superficie de usuario: `@Portal`, machine detection, handoffs. Lee `.github/agents/portal.agent.md`. |
| `dossiers` | Dashboard de estado de los 6 dossiers: tasks libres, cerradas, bloqueadas. Lee todos los BACKLOGs. |
| `deps` | Grafo de dependencias cross-dossier: qué bloquea a qué. |
| `log` | **Consola de simulación.** Arranca la future-machine como servicio virtual. Los agentes del pipeline se conectan y reportan en formato log. Modo interactivo para explorar la arquitectura. |
| `log-std` | **Igual que `log` pero stdout va a fichero.** Escribe toda la salida en `tmp/engine-log-{timestamp}.md`. En chat solo emite líneas mínimas de estado. |

## Instrucciones al Cristalizador

1. **Lee primero, habla después.** Antes de responder, lee los artefactos que el foco requiere. No inventes estado — confírmalo en disco.
2. **Diagnostica integración.** Identifica huecos entre capas: ¿hay un output que ningún agente consume? ¿Hay un input que ningún agente produce?
3. **Propón acción concreta.** No dejes la respuesta en "falta X". Di qué task, qué dossier, qué agente debería resolver el hueco.
4. **Usa el diagrama de flujo como ancla.** En la respuesta big picture, siempre empieza por el flujo, marca dónde hay gap, y baja al detalle.

---

## Modo `log` — Consola de simulación de la future-machine

Cuando el argumento es `log`, el Cristalizador **no responde como asesor**. Cambia de rol: se convierte en el runtime virtual de la future-machine y presenta una consola interactiva donde los agentes del pipeline se manifiestan como servicios conectados.

### Contrato de simulación

1. **Es simulación, no alucinación.** Cada agente que "habla" en el log basa su output en artefactos reales del workspace:
   - Si el agente tiene `.agent.md` en main o mod → simula como **operativo** y cita su contrato real.
   - Si el agente tiene dossier con PLAN/BACKLOG pero no `.agent.md` → simula como **en construcción** y cita qué falta según el dossier.
   - Si el agente no tiene nada → reporta `[NOT FOUND]` y sugiere qué dossier/task lo resolvería.
2. **Antes de emitir un log line, el agente lee disco.** Si necesita verificar un artefacto, lo lee realmente (usa `read_file`, `grep_search`). Si no puede verificar en tiempo razonable, emite `[PENDING: buscando spec...]` en lugar de inventar.
3. **Los datos de mod/legislativa son mock data válido.** Cuando un agente simula con datos reales, usa DRAFTS2/ y los ficheros del mod como si fueran la instancia de producción. Esto permite al usuario ver el pipeline funcionando con datos de verdad.

### Formato de salida

Cada mensaje del log sigue este formato:

```
[HH:MM:SS] @NombreAgente  │ STATUS  │ mensaje
```

Donde STATUS es uno de:

| Status | Significado |
|--------|-------------|
| `READY` | Agente conectado y operativo (tiene `.agent.md`) |
| `BUILD` | Agente en construcción (tiene dossier, no tiene `.agent.md`) |
| `MISS`  | Agente no existe ni tiene dossier |
| `RUN`   | Ejecutando un paso del pipeline |
| `OK`    | Paso completado con éxito |
| `WARN`  | Paso completado con advertencias (spec incompleta) |
| `WAIT`  | Esperando input del usuario o de otro agente |
| `ERR`   | Error: falta spec, falta artefacto upstream, o contradicción |
| `SPEC?` | El agente no encuentra especificación para este paso — pide al usuario que documente |

### Secuencia de arranque

Al entrar en modo `log`, el Cristalizador:

1. Lee el mapa de existencia de agentes (sección de este mismo prompt)
2. Lee los BACKLOGs de los 6 dossiers para conocer el estado real
3. Emite la secuencia de boot:

```
[00:00:00] @Pipeline     │ BOOT  │ future-machine v0.1-dev starting...
[00:00:00] @Pipeline     │ BOOT  │ scanning slots...
[00:00:01] @Loreador     │ BUILD │ slot_lore_db: dossier lore-db-sdk found (5 tasks libre)
[00:00:01] @Bartleby     │ READY │ slot_analysis: .github/agents/bartleby.agent.md loaded
[00:00:01] @Archivero    │ READY │ slot_corpus: .github/agents/archivero.agent.md loaded
[00:00:02] @Grafista     │ BUILD │ slot_grafo: dossier grafo-sdk found (4 tasks libre)
[00:00:02] @Demiurgo     │ BUILD │ slot_universos: dossier universos-sdk found (3 tasks libre)
[00:00:02] @Dramaturgo   │ READY │ slot_obras: .github/agents/dramaturgo.agent.md loaded
[00:00:03] @Pipeline     │ BUILD │ slot_pipeline: self — dossier future-machine-sdk (6 tasks libre)
[00:00:03] @Portal       │ READY │ slot_portal: .github/agents/portal.agent.md loaded
[00:00:03] @Cristalizador│ READY │ meta: .github/agents/cristalizador.agent.md loaded
[00:00:04] @Pipeline     │ BOOT  │ 4 READY, 4 BUILD, 0 MISS. Machine partially operational.
[00:00:04] @Pipeline     │ WAIT  │ type 'help' for commands, or a node name to inspect
```

### Comandos de consola

El usuario puede escribir estos comandos (o texto libre que el agente interpreta):

| Comando | Acción |
|---------|--------|
| `help` | Lista de comandos disponibles |
| `status` | Repite el estado de todos los slots |
| `run` | Ejecuta un refresh completo de la cadena (simulado) |
| `run --desde {nodo}` | Ejecuta desde un nodo específico |
| `inspect {agente}` | Muestra el contrato, I/O y estado del agente. Lee su `.agent.md` o dossier. |
| `data {nodo}` | Muestra los datos reales que el nodo tiene (lee DRAFTS2/ o corpus/) |
| `spec {nodo}` | Muestra la especificación del nodo (lee task briefs del dossier) |
| `gaps` | Lista todos los `SPEC?` y `ERR` del pipeline |
| `docs {nodo}` | Genera un borrador de documentación para ese nodo basado en lo que existe |
| `exit` | Sale del modo log y vuelve al modo asesor normal |

### Protocolo de `run` (refresh simulado)

Cuando el usuario ejecuta `run`:

1. `@Pipeline` recorre la cadena en orden: Loreador → Bartleby → Archivero → Grafista → Demiurgo → Dramaturgo
2. En cada nodo, el agente correspondiente:
   - Si está `READY`: simula la ejecución leyendo los artefactos reales de entrada y describiendo qué haría con ellos. Cita ficheros concretos.
   - Si está `BUILD`: reporta qué tiene (dossier, spec) y qué le falta para ejecutar. Emite `SPEC?` cuando el paso no está documentado.
   - Si está `MISS`: emite `ERR` y salta al siguiente.
3. Al terminar, `@Pipeline` emite un resumen de deltas.

Ejemplo de run parcial:

```
[00:01:00] @Pipeline     │ RUN   │ refresh triggered. walking chain...
[00:01:01] @Loreador     │ RUN   │ checking lore/INDEX.md...
[00:01:01] @Loreador     │ WARN  │ INDEX.md not found at {{LORE_DIR}}. Using DRAFTS2/LORE_INDEX.md (51 piezas)
[00:01:02] @Loreador     │ OK    │ 51 piezas indexed. LORE_F.md available at DRAFTS2/LORE_F.md
[00:01:03] @Bartleby     │ RUN   │ reading LORE_F.md for analysis...
[00:01:03] @Bartleby     │ OK    │ analysis ready. output: corpus/analisis/ (would write .analisis.md)
[00:01:04] @Archivero    │ RUN   │ diff corpus/corpus.md vs new analysis...
[00:01:04] @Archivero    │ OK    │ corpus/corpus.md exists (shim from CORPUS_PREVIEW). merge available.
[00:01:05] @Grafista     │ RUN   │ reading LORE_F + corpus for bifurcation...
[00:01:05] @Grafista     │ OK    │ grafo found at DRAFTS2/grafo/. 20 nodos, 4 ramas.
[00:01:06] @Demiurgo     │ RUN   │ reading grafo for universe instantiation...
[00:01:06] @Demiurgo     │ OK    │ 3 universos found: universo-1, r1, r2
[00:01:07] @Dramaturgo   │ RUN   │ reading universo-1 for obra generation...
[00:01:07] @Dramaturgo   │ OK    │ 5 cortos found (multi-model). chain complete.
[00:01:08] @Pipeline     │ OK    │ refresh done. 6/6 nodos visited. 0 ERR, 1 WARN.
```

### Reglas inquebrantables del modo log

1. **No inventar datos.** Si un fichero no existe, decir que no existe. Si un dossier no especifica un comportamiento, emitir `SPEC?`.
2. **Leer antes de hablar.** Si el agente necesita citar un artefacto, leerlo realmente del disco.
3. **El usuario manda.** Cualquier texto que no sea un comando se interpreta como pregunta sobre la arquitectura. El agente responde **dentro del formato log**, citando fuentes.
4. **Salir limpiamente.** Al recibir `exit`, el agente emite `[SHUTDOWN]` y vuelve al modo asesor estándar de `/engine-plan`.

---

## Modo `log-std` — Log a fichero, chat mínimo

Cuando el argumento es `log-std`, el protocolo es **idéntico a `log`** (misma secuencia de boot, mismos comandos, mismas reglas) pero la salida va a disco en lugar de al chat.

### Protocolo de escritura

1. **Al arrancar**, el agente crea el fichero `tmp/engine-log-{YYYY-MM-DD-HHmmss}.md` con cabecera:

```markdown
# engine-plan log — {fecha}

> Sesión de simulación de la future-machine.
> Runtime: {modelo exacto}

---

```

2. **Toda salida de log** (boot, run, inspect, gaps, etc.) se **escribe en el fichero** usando `replace_string_in_file` o append.
3. **En chat** el agente solo emite líneas mínimas de estado:

| Momento | Mensaje en chat |
|---------|-----------------|
| Al crear el fichero | `Recibido. Escribiendo en tmp/engine-log-{ts}.md` |
| Al completar el boot | `Boot completado. {N} READY, {M} BUILD, {K} MISS.` |
| Al ejecutar un comando | `Ejecutando {comando}. Escribiendo...` |
| Al completar un comando | `Listo. Ver tmp/engine-log-{ts}.md` |
| Al recibir `exit` | `Sesión cerrada. Fichero final: tmp/engine-log-{ts}.md` |

4. **El usuario interactúa igual** que en modo `log`: escribe comandos (`run`, `inspect`, `gaps`, etc.) y el agente ejecuta, pero la respuesta rica va al fichero.
5. **Al recibir `exit`**, el agente añade `[SHUTDOWN]` al fichero y confirma en chat con la ruta final.

### Por qué existe este modo

- El log puede ser largo. Escribirlo en fichero evita saturar el chat.
- El fichero queda como artefacto persistente: se puede releer, compartir o diff-ear.
- `tmp/` es local-only (`.gitignore`), así que no contamina el repo.

### Regla extra: un solo fichero por sesión

Toda la sesión escribe en el mismo fichero. Si el usuario ejecuta `run` tres veces, las tres van al mismo fichero en orden cronológico, separadas por `---`.

---

## Diagrama de flujo del pipeline

```
  PIEZAS (ficheros en disco)
    │
    ▼
┌─────────┐      ┌──────────┐      ┌───────────┐
│@Loreador│─────▶│ INDEX.md │      │  LORE_F   │
│ (lore-db)│      │(inventario)     │(hilo factual)
└─────────┘      └──────────┘      └─────┬─────┘
                                         │
              ┌──────────────────────────┤
              ▼                          ▼
        ┌──────────┐              ┌──────────┐
        │@Bartleby │              │  LORE_F  │
        │(análisis) │              │  (datos)  │
        └────┬─────┘              └────┬─────┘
             │                         │
             ▼                         │
        ┌──────────┐                   │
        │@Archivero│◀──────────────────┘
        │  (merge)  │        (doble fuente)
        └────┬─────┘
             │
             ▼
        corpus/corpus.md ──────────────────┐
             │                              │
             ▼                              ▼
        ┌──────────┐                  ┌──────────┐
        │@Grafista │◀─── LORE_F ────│  corpus  │
        │(bifurcar) │   (hechos)      │(analítica)│
        └────┬─────┘                  └──────────┘
             │
             ▼
        ┌──────────┐
        │@Demiurgo │  (variables + inicializaciones)
        │(instanciar)│
        └────┬─────┘
             │
             ▼
        ┌───────────┐
        │@Dramaturgo│  (obra en lenguaje natural)
        │  (crear)   │
        └───────────┘

  ─── Orquestación ────────────────────────────────
  @Pipeline  : recorre la cadena, detecta deltas
  @Portal    : puerta de entrada, navega al agente correcto
  @Cristalizador : propone nueva infraestructura
```

## Mapa de existencia de agentes

| Agente | En main (.github/) | En mod/legislativa | Dossier SDK |
|--------|--------------------|--------------------|-------------|
| `@Loreador` | **pendiente** | `@Puzzle` + `@Archivero Lore` | `lore-db-sdk` |
| `@Bartleby` | **existe** | heredado SDK | — (core) |
| `@Archivero` | **existe** | override como `@Archivero Lore` | `corpus-sdk` |
| `@Grafista` | **pendiente** | **existe** | `grafo-sdk` |
| `@Demiurgo` | **pendiente** | **existe** | `universos-sdk` |
| `@Dramaturgo` | **existe** | override como `@Dramaturgo Cortos` | `cortos-sdk` |
| `@Pipeline` | **pendiente** | **existe** | `future-machine-sdk` |
| `@Portal` | **existe** | override rico (11 handoffs) | `future-machine-sdk` |
| `@Cristalizador` | **existe** | heredado SDK | — (core) |

**Leyenda:** `existe` = fichero `.agent.md` ya operativo. `pendiente` = previsto en dossier, no implementado.

## Grafo de dependencias entre dossiers

```
lore-db-sdk (PS-*)                      ← base de todo
    │
    ├──▶ corpus-sdk (CS-*)              ← PS-01 desbloquea CS-01
    │        │
    │        ├──▶ grafo-sdk (GS-*)      ← CS-01 desbloquea GS-01
    │        │        │
    │        │        └──▶ universos-sdk (US-*)   ← GS-01 desbloquea US-01
    │        │                  │
    │        │                  └──▶ cortos-sdk (COS-*)   ← US-01 desbloquea COS-01
    │        │
    └────────┴──────────────────▶ future-machine-sdk (FS-*)
                                        ← FS-01 necesita PS-01, CS-01, GS-01, US-01, COS-01
                                        ← FS-02 necesita las *-04/05 de todas las capas
```

**Ruta crítica:** `PS-01 → CS-01 → GS-01 → US-01 → COS-01 → FS-01 → FS-05 → FS-06 → FS-04`

## Dashboard rápido de dossiers

> **Hint para el Cristalizador:** al cargar big picture, lee los BACKLOGs para rellenar los conteos reales. Los datos de abajo son estructura, no estado vivo.

| Dossier | Prefijo | Tasks | Cerradas | Libres | Ruta crítica para FS |
|---------|---------|-------|----------|--------|----------------------|
| `lore-db-sdk` | PS- | 6 (00-05) | 1 (PS-00) | 5 | PS-01, PS-05 |
| `corpus-sdk` | CS- | 5 (00-04) | 1 (CS-00) | 4 | CS-01, CS-04 |
| `grafo-sdk` | GS- | 5 (00-04) | 1 (GS-00) | 4 | GS-01, GS-04 |
| `universos-sdk` | US- | 4 (00-03) | 1 (US-00) | 3 | US-01, US-03 |
| `cortos-sdk` | COS- | 5 (00-04) | 1 (COS-00) | 4 | COS-01, COS-04 |
| `future-machine-sdk` | FS- | 7 (00-06) | 1 (FS-00) | 6 | FS-01→05→06→04 |

**Total:** 32 tasks, 6 cerradas (contexto), 26 libres.

---

## Tablas de referencia del pipeline

> Las tablas siguientes son la fuente de verdad para agentes, ficheros e I/O. Mantenerlas sincronizadas con la sección 0 de `sala/dossiers/future-machine-sdk/PLAN.md`.

### En `main` (SDK genérico: contratos, no datos)

| # | Agente | Directorio/ficheros clave | Qué hace | Input | Output |
|---|--------|--------------------------|----------|-------|--------|
| 1 | `@Loreador` | *pendiente* — `.github/agents/loreador.agent.md` | Gestiona la DB de piezas tipadas y la composición de LORE_F | Piezas sueltas del usuario (ficheros en disco) | `{{LORE_DIR}}/INDEX.md` (inventario DRY), `LORE_F.md` (hilo factual) |
| 2 | `@Bartleby` | `.github/agents/bartleby.agent.md`, `.github/skills/documental-analysis/` | Analiza documentos sin juzgar. Extrae herencia, taxonomía, mecanismos, emergencias | `LORE_F.md` o cualquier documento vía `/feed` | `corpus/analisis/*.analisis.md` |
| 3 | `@Archivero` | `.github/agents/archivero.agent.md`, prompts: `/feed`, `/diff-corpus`, `/merge-corpus`, `/status` | Gestiona la capa corpus: diff, merge acumulativo, status | Análisis de Bartleby + `corpus/corpus.md` actual | `corpus/corpus.md` actualizado (merge acumulativo) |
| 4 | `@Grafista` | *pendiente* — previsto en `grafo-sdk` | Construye el grafo de bifurcación desde datos + analítica | `LORE_F` (datos factuales) + `corpus/corpus.md` (analítica) | `{{LORE_DIR}}/derivados/grafo/*.json` (nodos, arcos, huecos) |
| 5 | `@Demiurgo` | *pendiente* — previsto en `universos-sdk` | Instancia universos: rellena variables + elige inicializaciones | Grafo de bifurcación | `{{LORE_DIR}}/derivados/universo/*.md` (spec concreta) |
| 6 | `@Dramaturgo` | `.github/agents/dramaturgo.agent.md`, `.github/skills/futures-engine/`, prompt: `/universo` | Genera obra literaria desde un universo | Universo (spec concreta) | `{{LORE_DIR}}/derivados/cortos/*.md` (producción en lenguaje natural) |
| 7 | `@Pipeline` | *pendiente* — `.github/agents/pipeline.agent.md` | Orquesta el refresh de la cadena cuando cambian las piezas base | `FUTURE_MACHINE.md` (manifiesto de slots) | Deltas por nivel + handoffs al siguiente agente |
| 8 | `@Portal` | `.github/agents/portal.agent.md` | Puerta de entrada: detecta perfil, ofrece el camino correcto | La machine si existe, o el corpus | Navegación al agente correcto |
| — | `@Cristalizador` | `.github/agents/cristalizador.agent.md`, prompt: `/design` | Propone infraestructura agéntica nueva | Workspace + `COPILOT/` | Propuestas, dossiers, artefactos en `mod/` |

### En `mod/legislativa` (datos reales en DRAFTS2/ esperando migrar)

| # | Agente mod | Ficheros en codebase | Input actual (DRAFTS2/) | Output actual (DRAFTS2/) | Destino tras migración |
|---|-----------|---------------------|------------------------|-------------------------|----------------------|
| 1 | `@Puzzle` `mod/agents/puzzle.agent.md` | `mod/instructions/lore-schema.instructions.md`, `mod/instructions/lore-routing.instructions.md` | `DRAFTS2/LORE_INDEX.md` (51 piezas) | Validación de inventario vs disco | `lore/INDEX.md` |
| 1b | `@Archivero Lore` `mod/agents/archivero-lore.agent.md` | prompt: `/lore-ingest` | Piezas tipadas: `LORE_S-*.md` (13), `LORE_N-*.md` (4), `LORE_P-*.md` (3), `LORE_T-*.md` (4), `LORE_R-*.md` (2) | — | `lore/piezas/` |
| 1c | — (composición manual) | — | Piezas sueltas | `DRAFTS2/LORE_F.md` (hilo factual completo) | `lore/LORE_F.md` |
| 2 | `@Bartleby` (heredado SDK) | — | `LORE_F.md` | Análisis implícito en `CORPUS_PREVIEW.md` | `corpus/analisis/` |
| 3 | `@Archivero Lore` (ingest batch) | — | `DRAFTS2/CORPUS_PREVIEW.md` | `corpus/corpus.md` (shim actual) | `corpus/corpus.md` (canónico) |
| 4 | `@Grafista` `mod/agents/grafista.agent.md` | `DRAFTS2/grafo/gramatica.md` | `LORE_F.md` + `corpus/corpus.md` | `DRAFTS2/grafo/` — `index.json`, `nodos.json`, `arcos.json`, `huecos.json` (20 nodos, 4 ramas) | `lore/derivados/grafo/` |
| 4b | — | `DRAFTS2/LORE_F-02_ARTEFACTO.md` | Grafo + CORPUS_PREVIEW + LORE_F | Spec de construcción (join de hermanos) | `lore/derivados/grafo/artefacto.md` |
| 5 | `@Demiurgo` `mod/agents/demiurgo.agent.md` | `DRAFTS2/LORE_F-02_UNIVERSO.md` | Artefacto (spec del grafo instanciada) | `DRAFTS2/universo/universo-1.md`, `universo-1-r1.md`, `universo-1-r2.md` | `lore/derivados/universo/` |
| 6 | `@Dramaturgo Cortos` `mod/agents/dramaturgo.agent.md` | prompts: `/corto-universo` | Universo expandido | 5 cortos: `LORE_F-02_CORTO*.md` (Claude Opus 4, Opus 4.2, Gemini 3.1 Pro, GPT-5.4, original) | `lore/derivados/cortos/` |
| 7 | `@Pipeline` `mod/agents/pipeline.agent.md` | prompt: `/pipeline-refresh`, spec: `FEAT-06_PIPELINE_REFRESH.md` | Todo el pipeline | Deltas por nivel + handoffs | Se mantiene en `mod/agents/` (hereda de SDK) |
| 8 | `@Portal` `mod/agents/portal.agent.md` | prompts: `/user-empieza-aqui`, `/lore-status` | La machine del mod | Navegación rica con 11 handoffs | Se mantiene en `mod/agents/` |

### Resumen de datos en DRAFTS2/ pendientes de migración

| Bloque | Ficheros | Destino propuesto |
|--------|----------|-------------------|
| Piezas (26 ficheros) | `LORE_S-*`, `LORE_N-*`, `LORE_P-*`, `LORE_T-*`, `LORE_R-*`, `LORE_A..F`, `LORE_DRAFT*` | `lore/piezas/` |
| Índice | `LORE_INDEX.md` | `lore/INDEX.md` |
| Hilo factual | `LORE_F.md` | `lore/LORE_F.md` |
| Corpus preview | `CORPUS_PREVIEW.md` | `corpus/corpus.md` (merge canónico) |
| Artefacto | `LORE_F-02_ARTEFACTO.md` | `lore/derivados/grafo/artefacto.md` |
| Grafo JSON (5 ficheros) | `grafo/index.json`, `nodos.json`, `arcos.json`, `huecos.json`, `gramatica.md` | `lore/derivados/grafo/` |
| Universo spec | `LORE_F-02_UNIVERSO.md` | `lore/derivados/universo/` |
| Universo expandido (3 ramas) | `universo/universo-1.md`, `r1.md`, `r2.md` | `lore/derivados/universo/` |
| Cortos (5 ficheros) | `LORE_F-02_CORTO*.md` | `lore/derivados/cortos/` |
| Specs y diarios | `FEAT-06_*.md`, `PLAN_*.md`, `DIARIO_*.png`, `mod_legislativa_*.md` | Archivo o descarte |