@jossuealcala/madre 0.3.3 → 0.4.1

package/CONTRIBUTING.md

@@ -22,6 +22,8 @@ node ./bin/madre.mjs start --no-open    # the room from source, URL in the termi
 
 ## Writing a module
 
+For a module of your own, outside this repository, read `docs/SDK.md`: one `.mjs` file in `~/.pulse/modules/` or `<project>/.madre/modules/`, no build, reloaded from MODULES. What follows is for modules that ship inside MADRE.
+
 A module is one file in `src/modules/`, registered in `src/modules/index.mjs`:
 
 ```js
@@ -71,7 +73,7 @@ docs/report-collector/    the Worker that turns sentinel reports into issues
 
 - A version is **closed only when it is on npm**. Until then its changelog section reads *Sin publicar* and keeps growing; no new number is opened while the previous one is unpublished.
 - One published version = one `vX.Y.Z` tag = one GitHub release = one changelog section. Tags and releases are created at publish time, never before.
-- Patch (`0.2.x`) for fixes and additions inside existing modules; the patch number may reach two digits. Minor (`0.x`) for a new mode, a new module, a new agent, or a change to what leaves the machine. Major when the room's ledger or memory format stops being readable by the previous version.
+- Patch (`0.x.Y`) for fixes and additions inside existing modules; the patch number may reach two digits. Minor (`0.x`) for a new mode, a new module, a new agent, or a change to what leaves the machine. Major when the room's ledger or memory format stops being readable by the previous version.
 - `scripts/release.mjs` does the closing in one go: checks the tree is clean and CI-green, runs the suite and pack:check, turns *Sin publicar* into the dated section, tags, pushes, creates the release and prints the publish command.
 
 Open questions go to issues with the `question` label. Ideas go through `✎ FEEDBACK` in MU/TH/UR or a plain issue. Be kind to the crew.

package/README.md

@@ -1,259 +1,141 @@
 <p align="center">
-  <a href="https://jossuealcala.com/en/"><img src="https://raw.githubusercontent.com/jossuealcacao-exe/madre/main/docs/madre-banner.svg" alt="MADRE · MU/TH/UR 6000 · INTERFACE 2037" width="100%"></a>
+  <a href="https://madre.run"><img src="https://raw.githubusercontent.com/jossuealcacao-exe/madre/main/docs/madre-banner.svg" alt="MADRE · MU/TH/UR 6000 · INTERFACE 2037" width="100%"></a>
 </p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/@jossuealcala/madre"><img alt="npm" src="https://img.shields.io/npm/v/@jossuealcala/madre?style=flat-square&label=npm&color=9bff66&labelColor=050605"></a>
   <a href="https://github.com/jossuealcacao-exe/madre/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/jossuealcacao-exe/madre/ci.yml?style=flat-square&label=CI&color=9bff66&labelColor=050605"></a>
-  <img alt="status" src="https://img.shields.io/badge/status-beta-ffb000?style=flat-square&labelColor=050605">
   <img alt="node" src="https://img.shields.io/badge/node-%E2%89%A5%2022.5-9bff66?style=flat-square&labelColor=050605">
-  <img alt="dependencies" src="https://img.shields.io/badge/dependencies-0-9bff66?style=flat-square&labelColor=050605">
-  <img alt="license" src="https://img.shields.io/badge/license-Apache--2.0-9bff66?style=flat-square&labelColor=050605">
-  <img alt="crew" src="https://img.shields.io/badge/crew-Codex%20%C2%B7%20Claude%20%C2%B7%20Gemini%20%C2%B7%20OpenCode%20%C2%B7%20%40madre-9bff66?style=flat-square&labelColor=050605">
+  <img alt="dependencies" src="https://img.shields.io/badge/dependencias-0-9bff66?style=flat-square&labelColor=050605">
+  <img alt="license" src="https://img.shields.io/badge/licencia-Apache--2.0-9bff66?style=flat-square&labelColor=050605">
 </p>
 
 ```
-MU/TH/UR 6000 · INTERFACE 2037 · MADRE IS READY · BETA
-
-  ONE LOCAL ROOM · FOUR AI CODING AGENTS · ONE SHARED MEMORY · A FIFTH AGENT THAT IS THE MEMORY ITSELF
-  READ-ONLY BY DEFAULT · CONTROL WHEN YOU SAY SO · NOTHING LEAVES THIS MACHINE ON ITS OWN
+MU/TH/UR 6000 · INTERFACE 2037 · MADRE IS READY
 ```
 
-# MADRE
+<br>
 
-Una sala local donde los agentes de IA que ya tienes instalados trabajan juntos sobre un proyecto real y comparten una memoria. *One local room where Codex, Claude Code, Gemini CLI and OpenCode work on a project together, with a memory every one of them recalls.*
+# Los agentes que ya tienes.<br>Una sala. Una memoria.
 
-MADRE no es una nube ni una cuenta. Lanza el CLI de cada agente como proceso, con la sesión que ese CLI ya tiene, y mantiene el proyecto bajo tu control: los agentes leen por defecto, crean solo donde tú dices y editan solo cuando armas CONTROL.
+Codex, Claude Code, Gemini CLI y OpenCode trabajando sobre el mismo proyecto,
+en la misma conversación, recordando lo mismo.
 
 ```
 npx @jossuealcala/madre start
 ```
 
----
-
-## ARRANQUE · LOS PRIMEROS CINCO MINUTOS
+Eso es todo. No hay cuenta que crear, ni nube que configurar, ni llave que pegar.
+MADRE usa las sesiones que esas CLIs ya tienen en tu máquina.
 
-Necesitas Node 22.5 o superior y al menos una de estas CLIs con sesión iniciada: **Codex**, **Claude Code**, **Gemini CLI**, **OpenCode**. Si además corre **Ollama** con un modelo de chat, la sala tiene un quinto agente local.
-
-1. Entra a la carpeta del proyecto y corre `npx @jossuealcala/madre start`. MADRE detecta qué CLIs tienes y quién tiene sesión. Si nadie está en línea, abre un asistente en la terminal: un número corre el inicio de sesión de esa CLI, `s` abre la sala.
-2. La sala abre en `http://127.0.0.1:4317`. Elige un agente en el selector o escribe `@claude …`. El chip junto a `to @agente` dice en qué modo sale el mensaje; `#1 EXCHANGE`, solo lectura, es el predeterminado.
-3. Para conectar o reconectar una IA sin terminal: `MU/TH/UR → ⚙ CONNECTIONS`. Codex y Claude tienen `SIGN IN`; Gemini y OpenCode muestran el comando exacto para su propio prompt. Ninguna credencial pasa por MADRE.
-4. Con Ollama, `MODULES → OLLAMA` ya está encendido: la memoria se embebe localmente y `@madre` aparece en la fila.
-5. `⚙ CONNECTIONS → MEMORY` ajusta quién destila la memoria y cada cuánto. `◉ NOSTROMO` muestra lo que la sala recuerda.
+<p align="center">
+  <img src="https://raw.githubusercontent.com/jossuealcacao-exe/madre/main/docs/room.png" alt="La sala de MADRE: Codex y Claude respondiendo en el mismo hilo sobre el mismo proyecto" width="100%">
+</p>
 
-```bash
-npx @jossuealcala/madre doctor      # qué agentes hay, quién tiene sesión, si hay versión nueva
-npx @jossuealcala/madre setup       # el asistente de conexión, cuando quieras
-npx @jossuealcala/madre start --no-open --project RUTA
-```
+<p align="center"><sub>Una pregunta. Dos agentes. El segundo leyó al primero.</sub></p>
 
-**Tres nombres.** **MADRE** es el producto. **MU/TH/UR** es su voz operativa: diagnóstico, conexiones, ajustes. **PULSE** es el canal sobre el que corre la sala: el registro de eventos, el bloque de delegación, la carpeta `.pulse/` donde caen los artefactos; por eso esos identificadores conservan su nombre.
+<br>
 
 ---
 
-## LA SALA
-
-**La barra.** La marca con su latido, la raíz del proyecto, la tripulación, `LIVE`, las alertas (`STOP ALL`, versión nueva), `MODULES`, `MU/TH/UR`, tema y panel de archivos. Cada esfera de agente lleva un anillo con su consumo: el límite real del proveedor cuando el CLI lo publica, si no, la ventana local de MADRE. Un clic la despliega.
+<br>
 
-**Las burbujas.** Cada respuesta dice quién habla, a quién, en qué modo y con qué modelo; debajo, hora, tokens del turno y acumulado. Markdown completo, tablas, bloques de código con COPY. Las rutas que un agente menciona (`src/room.mjs:42`) abren el visor. Al pasar el ratón: valorar bien o mal, copiar, responder con otro agente.
+## Una conversación, no cuatro terminales
 
-**El compositor.**
+Escribes `@codex` y contesta Codex. Escribes `@claude` y contesta Claude, **leyendo lo que Codex acaba de decir**. Pides una mesa redonda y cada uno opina por turno sobre lo mismo.
 
-| Escribes | Pasa |
-|---|---|
-| `@codex`, `@claude`, `@gemini`, `@opencode`, `@madre` | Menciona a un agente; `@` abre la lista |
-| `!src/room.mjs:12-20` | Adjunta un archivo del proyecto, con líneas si las das; `!` busca entre los archivos |
-| `#0` a `#3` | Fija el modo de permiso de ese mensaje |
-| `/create …`, `/image …`, `/stopall`, `/git …`, `/ahp …` | Comandos; `/` abre el menú. `/git push` muestra qué saldría; solo `/git push confirm` lo envía |
-| `STOPALL` | Freno maestro |
-| Clip, arrastrar o pegar una imagen | Adjunto para la sala, nunca en el proyecto |
-| `@madre, pregúntale al crew …` | Mesa redonda: un paso por agente en línea, cierre citado |
+Hoy eso son cuatro ventanas, cuatro contextos y tú copiando y pegando entre ellas. MADRE lo vuelve un hilo.
 
-Un segundo clic en la esfera elegida, o el chip `default model ▾`, elige el modelo de esa petición: Codex, Claude, Gemini y OpenCode con sus listas reales, o un nombre libre. Se recuerda por agente.
+## Una memoria que sobrevive a la sesión
 
-**Archivos.** El icono de la derecha abre el árbol del proyecto en solo lectura. El visor numera líneas; clic y Shift+clic seleccionan un rango y `REVIEW WITH` lo manda a un agente. Con **RIPLEY** encendido en `MODULES`, HTML, SVG y Markdown se renderizan en un marco sellado en lugar de mostrar su código, con barra atrás/recargar y recarga automática cuando un agente cambia el archivo.
+Todo lo que se dice queda indexado. Cuando la conversación pasa de la ventana de contexto, cada agente recibe de vuelta lo que hace falta, citado. Cada diez intercambios, la sala destila lo dicho en notas con tipo: una decisión, un hecho, una preferencia, una pregunta abierta.
 
-**Tema.** Sol/luna en la barra: automático, claro u oscuro. El claro no brilla; la pantalla de MU/TH/UR sigue siendo fósforo.
+Preguntas *«¿por qué elegimos Postgres?»* tres semanas después y la sala contesta, aunque esa decisión la tomara otro agente en otra sesión.
 
----
+Con [Ollama](https://ollama.com) corriendo, esa memoria además **habla**: `@madre` es un quinto agente, local, gratis, que responde desde todo el archivo con citas y no escribe nada.
 
-## MODOS DE PERMISO
+## Leen por defecto. Escriben cuando tú lo dices.
 
-Cada mensaje sale con un modo. Tu modo es el techo de cualquier plan que ese mensaje arranque.
+Cada mensaje sale con un modo de permiso, y tu modo es el techo de todo lo que ese mensaje arranque.
 
-| Modo | Nombre | Qué permite |
+| | | |
 |---|---|---|
-| `#0` | **GHOST** | Fuera del registro. No se escribe en el ledger, nadie lo recuerda, desaparece al recargar. Los tokens sí cuentan. |
-| `#1` | **EXCHANGE** | Leer el proyecto y coordinar. El predeterminado. |
-| `#2` | **CREATE** | Añadir archivos y carpetas nuevos donde corresponda en el proyecto. Lo que ya existía no cambia: si un agente lo toca, MADRE lo restaura al terminar y lo dice. |
-| `#3` | **CONTROL** | Editar el proyecto real sin aprobación por acción. Un titular por sala, checkpoint antes, lista de cambios y `UNDO` después. |
-| `#4` | **AIRLOCK** | Todo lo de CONTROL más ejecutar comandos: pruebas, builds, `git push`, deploys con las CLIs y sesiones que ya hay en la máquina. Los archivos vuelven con `UNDO`; lo que sale de la nave, no. La anulación pide dos llaves: la designación y la palabra `AIRLOCK`. |
+| `#1` | **EXCHANGE** | Leer y coordinar. El predeterminado. |
+| `#2` | **CREATE** | Añadir archivos nuevos. Lo que ya existía se restaura al terminar. |
+| `#3` | **CONTROL** | Editar el proyecto. Checkpoint antes, lista de cambios y `UNDO` después. |
+| `#4` | **AIRLOCK** | Comandos, `git push`, deploys. Pide dos llaves. |
 
-**CREATE por dentro.** El agente decide dónde va lo nuevo según las convenciones del proyecto, y crea carpetas si hace falta; `.pulse/out/<turno>/` queda como borrador para lo que no tiene sitio. MADRE toma un checkpoint antes del turno y, al terminar, conserva lo que apareció, lo muestra bajo la respuesta como artefactos, y restaura cualquier archivo previo que se haya modificado, renombrado o borrado, avisando en la sala. Las CLIs reciben sus herramientas de escritura sobre el proyecto y la instrucción de no tocar lo existente; la garantía la da la restauración de MADRE al terminar, no la regla previa.
+También hay `#0 GHOST`, para lo que no debe quedar en ninguna parte.
 
-**CONTROL por dentro.** Antes del turno, un commit real bajo `refs/madre/checkpoints/` que no toca tu rama, tu índice ni tu stash. Durante el turno, `.git/`, `.pulse/`, `.madre/`, los `.env` y `.claude/settings.local.json` quedan en solo lectura a nivel de sistema de archivos y recuperan sus permisos al terminar. Después, la lista de archivos añadidos, modificados y borrados, y `UNDO` restaura el checkpoint. Armar `#3` pide la designación del proyecto; armar `#4` pide además la palabra `AIRLOCK`. En `#4` cada CLI recibe su herramienta de comandos (Codex sin sandbox de red, Claude `Bash`, Gemini `run_shell_command`, OpenCode `bash`) y la instrucción de decir en una línea qué va a salir y adónde antes de que salga.
+Subir a `#3` o `#4` es una ceremonia deliberada: MADRE te pide el nombre de la carpeta del proyecto, escrito por ti. Ningún agente puede concederse un permiso escribiéndolo en su respuesta.
 
-**Escalación.** Si un plan en `#1` llega a un paso que pide crear algo, la sala se detiene y pregunta: `GRANT ONCE · GRANT FOR PLAN · DENY`, con cronómetro de tres minutos. Solo el humano concede; un permiso escrito por un agente dentro de la conversación no cuenta.
-
-**Modo por paso.** Un orquestador puede pedir el modo de cada paso: `@codex #2: crea la página`, `@claude #3: arregla el router`. MADRE lo acota al modo de tu mensaje y al `MAX MODE` de ese agente. Con tu mensaje en `#3`, la palabra del orquestador basta; con tu mensaje en `#1`, un paso `#2` pasa por la escalación.
-
-**Dos controles por agente.** En `⚙ CONNECTIONS` cada agente tiene `MAX MODE`, hasta dónde puede llegar un mensaje dirigido a él, y `DEFAULT MODE`, dónde empieza: `#1` solo lectura hasta que armes CREATE, o `#2` para que cada turno pueda añadir archivos sin pedirlo. Aparte, dos habilidades: generar imágenes y web.
+<br>
 
 ---
 
-## QUÉ PUEDE CADA AGENTE
+<br>
 
-| | Lee el proyecto | Recibe imágenes | Crea archivos acotado | Genera imágenes | Web |
-|---|---|---|---|---|---|
-| **Codex** | sí | `-i` | sandbox de escritura | sí, nativo, con su cuenta de ChatGPT | `web_search` |
-| **Claude Code** | sí | lectura de la ruta | reglas de permiso por ruta | sí, con **Image Studio** | WebFetch / WebSearch |
-| **Gemini CLI** | sí | `read_file` | política por patrón | sí, con **Image Studio** | `google_web_search` |
-| **OpenCode** | sí | `-f` | permisos `edit` por patrón | sí, con **Image Studio** | webfetch / websearch |
-| **@madre** | la memoria | no | no | no | no |
+## Lo que MADRE no es
 
-**Image Studio** es un módulo de MADRE: un servidor MCP propio que expone `generate_image` sobre los modelos de imagen de la API de Gemini, con tu propia key y tus créditos. Se conecta a Claude, Gemini y OpenCode solo dentro de un permiso CREATE con el alcance de imágenes encendido, en sus homes aislados, y la imagen cae en la carpeta del turno como cualquier artefacto. `/image <petición>` arma el permiso y enruta al agente que puede generar. Con los cuatro agentes puedes pedir una imagen; Codex la hace con lo suyo, los demás con Image Studio.
+Esto importa más que cualquier función.
 
-El acceso web es un permiso permanente por agente, apagado por defecto, que se enciende en `⚙ CONNECTIONS`.
+**No hay nube.** MADRE no tiene servidor, ni cuenta, ni backend. Corre en `127.0.0.1` y se muere cuando cierras la terminal.
 
----
+**No guarda tus credenciales.** Cuando das una llave, MADRE la escribe en el archivo donde ese CLI la busca, cerrada a tu usuario, y no conserva copia. Nunca en su config, ni en su registro, ni en sus logs.
 
-## DELEGACIÓN
+**Nada sale por su cuenta.** Lo que un agente lee viaja a *su* proveedor, con tu cuenta y tus límites — como si lo hubieras corrido en tu terminal, porque eso es exactamente lo que MADRE hace. Los dos únicos envíos propios están bajo tu interruptor: una consulta diaria a npm por si hay versión nueva, y los reportes de fallos, apagados por defecto.
 
-Un agente puede poner a trabajar a los demás. Si le pides coordinar, termina su respuesta con un bloque `pulse`, un paso por línea:
+**Y te deja leerlo.** Dentro de la sala puedes abrir el documento exacto que MADRE escribe en tu nombre cada turno, el comando exacto con el que lo entrega, y el registro de cada llamada que salió de esta máquina. No es una promesa: es una pantalla.
 
-```
-@gemini: Sintetiza en un párrafo quién es el autor, separando hechos de inferencias.
-@codex: Misma pregunta; señala la afirmación menos sustentada.
-@claude: Compara ambas síntesis y marca dónde divergen.
-```
-
-MADRE ejecuta los pasos como turnos normales: cada uno queda en el ledger, pasa por handoff, presupuesto y timeout. El paso dirigido al orquestador es su turno de cierre. Los delegados no delegan, así que todo plan termina. Máximo cuatro pasos más el cierre.
+**Cero dependencias.** Node y nada más.
 
-**STOP ALL.** El botón de la barra, `STOPALL` en el compositor o `curl -X POST http://127.0.0.1:4317/api/stop-all` detienen todos los planes y matan todos los procesos de agente. MU/TH/UR avisa en rojo cuando la sala se escapa: tres agentes a la vez, un agente con dos turnos cruzados, un plan de más de cinco minutos.
+<br>
 
 ---
 
-## MEMORIA
-
-Todo lo dicho fuera de GHOST queda indexado junto al ledger, en `~/.pulse/rooms/<sala>/memory.sqlite`. Nada de esto requiere un comando: ocurre solo.
-
-**Recall.** Cuando la conversación excede la ventana de contexto, cada turno recibe los intercambios anteriores que coinciden con la petición, citados con su número de secuencia, para cualquier agente.
-
-**Notas destiladas.** Cada diez intercambios o tras diez minutos de reposo, el archivista lee lo no destilado y guarda hasta cinco notas tipadas: decisión, hecho, preferencia, pregunta abierta. El archivista es el agente más barato permitido; con Ollama es el modelo local y no cuesta nada.
-
-**Por significado.** Con Ollama (`nomic-embed-text`) o con una key de Gemini, intercambios y notas se embeben en segundo plano; una pregunta en español encuentra una decisión escrita en inglés.
-
-**Herramientas.** Cada turno lleva adjunto el servidor MCP `pulse-memory`: `memory_search`, `memory_recall`, `memory_notes`, `memory_timeline`, `project_state` y `memory_note`, que guarda una nota cuando tú pides explícitamente recordar algo. La burbuja muestra `◉ memory saved`.
-
-**NOSTROMO.** El mapa de la memoria, detrás de la designación del proyecto: MADRE es un sol rojo que late, cada memoria un planeta en el color de su tipo, unidos por venas que pulsan. Se navega, se lee y solo se puede borrar, con doble confirmación. Ocho toques al corazón activan CODE000 y sellan el archivo diez minutos.
-
-**@madre.** Con Ollama y un modelo de chat, la memoria habla: `@madre` responde desde todo el archivo con citas `[#n]`, dice cuando la sala nunca discutió algo, no escribe ni ejecuta, y convoca al crew si se lo pides. Sus tokens son locales y no cuentan. Cuando existe un modelo entrenado con la sala, lo usa.
-
-**Ajustes.** `⚙ CONNECTIONS → MEMORY`: quién destila, quiénes pueden, cada cuánto, dónde se embebe, cuánto contexto puede ocupar el recall. Todo en `~/.pulse/config.json`, sin reiniciar.
+<br>
 
-**Privacidad.** Una CLI corre con su propio contexto privado y puede escribirlo en una respuesta. En `⚙ CONNECTIONS → PRIVACY` nombras los términos que no deben viajar por la sala: MADRE los sustituye por `[ENTIDAD-ORG]` antes de que lleguen al ledger, al archivista, a los demás agentes o al dataset, y `PURGE ROOM` limpia lo que la sala ya tenía. Los términos viven en `config.json`; la sala solo registra cuántos.
+## Empezar
 
----
-
-## MADRE AI · TU PROPIO MODELO
+Necesitas **Node 22.5** o superior y al menos una de estas CLIs con sesión iniciada: Codex, Claude Code, Gemini CLI u OpenCode.
 
-La sala acumula material de entrenamiento mientras trabajas. `MEMORY` muestra en vivo cuántos pares limpios lleva hacia un LoRA, con 300 como objetivo: turnos humano→agente, pasos delegados y notas destiladas; fuera quedan las respuestas de `@madre`, las enlatadas y lo que marques como mala respuesta con el pulgar de cada burbuja.
+```
+cd tu-proyecto
+npx @jossuealcala/madre start
+```
 
-`EXPORT DATASET` escribe `train.jsonl` y `valid.jsonl` junto al ledger, redactados. La tarjeta `TRAIN` trae los comandos ya rellenados con tu carpeta de sala y el modelo base que cabe en tu máquina. El entrenamiento corre fuera de MADRE, con mlx en Apple Silicon; la receta vive en [`docs/training/`](https://github.com/jossuealcacao-exe/madre/blob/main/docs/training/README.md). En cuanto Ollama tiene un modelo `madre-<proyecto>`, `@madre` responde con él y las demás CLIs reciben la indicación de preguntarle primero: la memoria del proyecto deja de costar tokens.
+La sala abre en `http://127.0.0.1:4317`. **Si no tienes ninguna CLI, ábrela igual**: lo primero que ves es el puente, con un botón para instalar y firmar cada agente ahí mismo. MADRE enseña el comando antes de correrlo y transmite cada línea a la pantalla.
 
-**Ollama.** Si corre en la máquina, MADRE lo usa sin configurar nada: embeddings locales, archivista local, `@madre`. `MODULES → OLLAMA` muestra servidor, modelos y roles, descarga los recomendados con `PULL` y deja apagar cada rol. `qwen2.5:7b` en 16 GB, `qwen2.5:3b` en 8 GB; MADRE prefiere modelos de chat general sobre los `-coder`.
+```
+npx @jossuealcala/madre doctor    # qué hay instalado, quién tiene sesión
+```
 
----
+La sala habla **español**. El botón `EN` la pasa a inglés.
 
-## MU/TH/UR
+<br>
 
-El botón de la barra abre la pantalla de diagnóstico. Escribe un síntoma, un agente o una palabra y MU/TH/UR clasifica las condiciones registradas en esta sala contra su catálogo, con el remedio para tu sistema operativo. El mismo catálogo en terminal: `madre doctor --catalog [texto]`.
+**Cómo funciona cada cosa, con los números exactos:** [docs/REFERENCE.md](docs/REFERENCE.md)
+**Cómo funciona por dentro:** [docs/INTERNALS.md](docs/INTERNALS.md) · **Escribir un módulo:** [docs/SDK.md](docs/SDK.md)
 
-| Sección | Qué hace |
-|---|---|
-| `⚙ CONNECTIONS` | Sesión, versión y ruta de cada CLI; `SIGN IN` y `RECHECK`; `MAX MODE`, `DEFAULT MODE` y habilidades; timeouts, presupuesto, delegación, modelo de OpenCode; MEMORY y PRIVACY |
-| `◉ NOSTROMO` | El mapa de la memoria |
-| `SENTINEL` | Fallos que ninguna condición explica y caídas del proceso, con rutas, usuarios, correos y claves eliminados. Cada reporte tiene `REPORT ON GITHUB ↗` para leerlo antes de publicarlo; `AUTO-REPORT`, apagado por defecto, envía los nuevos al colector del proyecto |
-| `RELEASE CHANNEL` | Una consulta a npm al día. Si hay versión nueva, una alerta en la barra y aquí `RESTART WITH x.y.z`: la sala cierra, instala y vuelve en la misma dirección; o el comando para hacerlo tú. Nunca mientras los agentes trabajan |
-| `✎ FEEDBACK` | Un issue en blanco con tu entorno ya escrito |
+<br>
 
 ---
 
-## MÓDULOS
-
-`MODULES` en la barra lista los disponibles y su estado. Ninguno escribe en el proyecto salvo la instalación de AHP+, que muestra el comando y pide confirmación.
+<br>
 
-| Módulo | Qué añade |
-|---|---|
-| **Git Pulse** | `/git status`, `/git log [n]`, `/git diff`, `/git branches`: hechos del repositorio como tarjeta en el hilo, que los agentes también leen. `/git commit "mensaje"` y `/git push confirm`: tu mano sobre el repositorio, con vista previa de lo que saldría |
-| **Image Studio** | `generate_image` para Claude, Gemini y OpenCode, con tu key de Gemini, dentro de CREATE |
-| **RIPLEY** | El visor renderiza HTML, SVG y Markdown en un marco sellado, con recarga automática |
-| **OLLAMA** | Embeddings, archivista y `@madre` en local |
-| **PLAYWRIGHT** | Un navegador headless por turno que solo alcanza esta MADRE: abrir la vista previa de RIPLEY, hacer clic, leer consola, capturas al borrador del turno. Requiere `@playwright/mcp` |
-| **AshCode** (beta) | `$ ash_code`: abrevia mensajes localmente antes de enviarlos y pide respuestas concisas. Puede cambiar el significado; el original siempre queda |
-| **AHP+** | Integración externa opcional: estado verificado del proyecto, checkpoints y handoffs en `.ahp/`; `/ahp status`, `/ahp check`, `/ahp context` |
+## Estado
 
-Cada módulo es un archivo en `src/modules/` declarado con `defineModule`; un módulo puede entregar herramientas MCP a cada turno con `toolsForTurn`, como hace PLAYWRIGHT. Cómo escribir uno, en [CONTRIBUTING.md](https://github.com/jossuealcacao-exe/madre/blob/main/CONTRIBUTING.md#writing-a-module).
+Beta pública. El núcleo está probado y bajo CI en macOS y Linux con Node 22 y 24; la superficie sigue cambiando. Las decisiones que todavía duelen están escritas, sin adornos, en [*Lo que sale de la máquina*](docs/REFERENCE.md#lo-que-sale-de-la-máquina).
 
----
-
-## LO QUE SALE DE LA MÁQUINA
+Una versión se cierra cuando está en npm. El detalle de cada una en [CHANGELOG.md](CHANGELOG.md); lo que viene, en el [roadmap](https://github.com/jossuealcacao-exe/madre/blob/main/docs/ROADMAP.md).
 
-- **Nada por sí solo.** MADRE no tiene nube, cuenta ni backend. No guarda credenciales.
-- **Lo que un agente lee, viaja a su proveedor.** Codex a OpenAI, Claude Code a Anthropic, Gemini CLI a Google, OpenCode a quien tenga configurado. Aplican su cuenta, sus límites y sus términos. `@madre` y el archivista con Ollama no salen de la máquina.
-- **Dos envíos propios, ambos bajo tu interruptor.** El sentinel, apagado por defecto, envía reportes redactados al colector del proyecto. El canal de liberación, encendido por defecto, pregunta a npm por la última versión: viaja el nombre del paquete, nada más, la misma petición que hace `npx`. `PULSE_UPDATE_CHECK=0` lo apaga.
-- **Escritura.** En `#1` nadie escribe. En `#2` solo se añade: lo que existía se restaura al terminar el turno. En `#3` todo el proyecto salvo las zonas prohibidas, con checkpoint y `UNDO`. En un proyecto sin git, MADRE guarda sus fotografías en un repositorio sombra fuera del proyecto.
-- **Memoria.** Todo lo dicho fuera de GHOST queda en `~/.pulse/rooms/<sala>/` y vuelve a los prompts de todos los agentes de esa sala. GHOST es la salida para lo que no debe recordarse; PRIVACY, para los nombres que nunca deben aparecer.
+Problemas: desde MU/TH/UR (`✎ FEEDBACK`) o en [issues](https://github.com/jossuealcacao-exe/madre/issues).
+Seguridad: [SECURITY.md](SECURITY.md) · Contribuir: [CONTRIBUTING.md](CONTRIBUTING.md)
 
----
+Apache-2.0 · [Jossué Alcalá](https://jossuealcala.com/en/)
 
-## REFERENCIA
+<br>
 
-**`~/.pulse/config.json`**, o `PULSE_HOME/config.json`. Lo escribe MU/TH/UR; las variables de entorno mandan al siguiente arranque.
-
-```json
-{
-  "opencode": { "model": "openai/gpt-5.6-sol" },
-  "timeouts": { "default": 300000, "claude": 600000 },
-  "room": { "softTokenBudget": 500000, "delegation": true, "maxPlanSteps": 4 },
-  "memory": { "archivist": "auto", "every": 10, "idleMinutes": 10, "embedProvider": "auto", "recallShare": 0.3 },
-  "privacy": { "terms": [], "marker": "[ENTIDAD-ORG]" },
-  "updates": { "check": true },
-  "telemetry": { "autoReport": false }
-}
 ```
-
-**Variables de entorno**
-
-| Variable | Predeterminado | Efecto |
-|---|---|---|
-| `PULSE_HOME` | `~/.pulse` | Raíz de las salas y del config |
-| `PULSE_SOFT_TOKEN_BUDGET` | `500000` | Presupuesto local de tokens por agente, ventana rodante de 5 h |
-| `PULSE_CONTEXT_MAX_CHARS` | `16000` | Ventana de transcript inyectada |
-| `PULSE_RECALL_SHARE` | `0.3` | Parte de la ventana para la memoria recordada (`0` la apaga) |
-| `PULSE_DISTILL` · `_EVERY` · `_IDLE_MS` · `_MAX_CHARS` · `_AGENT` · `_MODEL` | `1` · `10` · `600000` · `6000` · — · — | Destilación de notas |
-| `PULSE_EMBED` · `PULSE_EMBED_PROVIDER` | `1` · `auto` | Embeddings; `ollama`, `gemini`, `auto` |
-| `PULSE_OLLAMA` · `_HOST` · `_MODEL` · `_EMBED_MODEL` | `1` · `http://127.0.0.1:11434` · el mejor · el mejor | Ollama |
-| `PULSE_MEMORY_TOOLS` | `1` | Servidor MCP `pulse-memory` en cada turno |
-| `PULSE_PRIVATE_TERMS` · `PULSE_PRIVATE_MARKER` | — · `[ENTIDAD-ORG]` | Términos privados extra y su marcador |
-| `PULSE_UPDATE_CHECK` | `1` | `0` apaga la consulta diaria a npm |
-| `PULSE_REPORT_URL` · `PULSE_AUTO_REPORT` | colector del proyecto · `0` | Sentinel |
-| `PULSE_AGENT_TIMEOUT_MS` · `PULSE_<AGENTE>_TIMEOUT_MS` | `180000` · — | Timeouts |
-| `PULSE_MAX_MESSAGE_CHARS` | `20000` | Tamaño máximo de un mensaje |
-| `PULSE_DELEGATION` · `PULSE_MAX_PLAN_STEPS` | `1` · `4` | Delegación |
-| `PULSE_ESCALATION_MS` | `180000` | Cronómetro de la escalación |
-| `PULSE_OPENCODE_MODEL` | del config | `proveedor/modelo` para OpenCode |
-| `PULSE_CLAUDE_USAGE` · `PULSE_OFFICIAL_QUOTA` | `0` · `1` | Cuota oficial de Claude (lee el llavero); `0` apaga todas las lecturas de proveedor |
-| `PULSE_GEMINI_IDLE_MS` · `PULSE_GEMINI_RETRIES` · `PULSE_GEMINI_FALLBACK_MODEL` | `90000` · `1` · `gemini-2.5-flash` | Gemini bajo carga |
-
-Cómo funcionan por dentro el ledger, el stream, la memoria, los adaptadores y la recuperación: [`docs/INTERNALS.md`](https://github.com/jossuealcacao-exe/madre/blob/main/docs/INTERNALS.md).
-
----
-
-## ESTADO
-
-Beta pública. El núcleo está probado y bajo CI en macOS y Linux con Node 22 y 24; la superficie sigue cambiando y las decisiones que aún duelen están escritas arriba, en *Lo que sale de la máquina*. Una versión se cierra cuando está en npm; el detalle de cada una, en [CHANGELOG.md](https://github.com/jossuealcacao-exe/madre/blob/main/CHANGELOG.md), y lo que viene, en el [roadmap](https://github.com/jossuealcacao-exe/madre/blob/main/docs/ROADMAP.md).
-
-Problemas: desde MU/TH/UR (`✎ FEEDBACK` o el sentinel) o en [issues](https://github.com/jossuealcacao-exe/madre/issues). Seguridad: [SECURITY.md](https://github.com/jossuealcacao-exe/madre/blob/main/SECURITY.md). Contribuir: [CONTRIBUTING.md](https://github.com/jossuealcacao-exe/madre/blob/main/CONTRIBUTING.md).
-
-Apache-2.0. Ver `LICENSE` y `NOTICE`.
+NOBODY DELETES MOTHER'S MEMORY.
+```

package/SECURITY.md

@@ -1,6 +1,6 @@
 # Security · MU/TH/UR 6000 · PRIORITY ONE
 
-MADRE runs on your machine, talks to no cloud of its own and stores no credentials. Its agents are CLIs you installed; they talk to their providers. The short threat model lives in the README under *Modelo de amenazas, en corto*.
+MADRE runs on your machine, talks to no cloud of its own and stores no credentials. Its agents are CLIs you installed; they talk to their providers. What leaves the machine, and what never does, is written out in [`docs/REFERENCE.md`](docs/REFERENCE.md#lo-que-sale-de-la-máquina).
 
 ## Reporting
 
@@ -14,6 +14,7 @@ Please include the MADRE version (`madre doctor --json`), the platform, which ag
 ## Known, accepted for the beta
 
 - In `#3 CONTROL`, `.env` files, `.pulse/`, `.madre/` and `.claude/settings.local.json` are made read-only for the length of the turn and restored from the checkpoint afterwards; `.git/` stays writable because the CLIs need it and is only restored after the turn. An agent that changes permissions on purpose is caught by that restoration, not prevented.
+- `#4 AIRLOCK` runs commands with the CLIs and sessions already on the machine: tests, builds, `git push`, deploys. Files come back with `UNDO`; **what leaves the machine does not**. Arming it asks for two keys — the project designation and the word `AIRLOCK` — and the agent's `MAX MODE` in CONNECTIONS must already reach it, which is a separate deliberate act. No agent can raise its own ceiling, and a permission an agent writes into its own answer is not a permission. Treat `#4` as handing that agent your shell.
 - Everything said outside `#0 GHOST` is kept in the room's memory and reaches every agent of that room. Use GHOST for what must not be remembered.
 
 NOBODY DELETES MOTHER'S MEMORY. EVERYTHING ELSE IS FAIR GAME.

package/bin/madre.mjs

@@ -3,27 +3,67 @@
 import { resolve } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { readFile, stat } from 'node:fs/promises';
-import { startPulse } from '../src/server.mjs';
+import { openUrl, startPulse } from '../src/server.mjs';
+import { realpath } from 'node:fs/promises';
 import { detectAgents } from '../src/runtime-detection.mjs';
 import { probeAll } from '../src/auth-probe.mjs';
 import { applyConfigToEnv, loadConfig } from '../src/config.mjs';
 import { isOnline, runSetup } from '../src/setup.mjs';
 import { parseArgs } from '../src/cli-args.mjs';
+import { createServer } from 'node:net';
 
 const cli = parseArgs(process.argv.slice(2));
 const { command } = cli;
 const option = (name, fallback) => cli.option(name.replace(/^--/, ''), fallback);
+
+// Is a MADRE already serving this very project nearby? `start` walks ports, so look along the
+// same short stretch and compare the project each one reports.
+async function roomAlreadyOpen(port, projectRoot, span = 8) {
+  const mine = await realpath(projectRoot).catch(() => resolve(projectRoot));
+  for (let candidate = port; candidate < port + span; candidate += 1) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${candidate}/api/version`, { signal: AbortSignal.timeout(500) });
+      if (!response.ok) continue;
+      const info = await response.json();
+      const theirs = info?.project ? await realpath(info.project).catch(() => info.project) : null;
+      if (theirs && theirs === mine) return { url: `http://127.0.0.1:${candidate}`, version: info.current ?? null };
+    } catch {
+      // nothing listening there, or not a MADRE: keep looking.
+    }
+  }
+  return null;
+}
+
+
 const has = (name) => cli.has(name.replace(/^--/, ''));
 
+// Is somebody already on that port? Asked before anything is started, because opening a room
+// means finding the agents, opening the archive and waking the memory, and doing all of that only
+// to then refuse is a wait nobody needed. The real bind below stays the authority: this only
+// saves the waiting.
+function portTaken(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const probe = createServer();
+    probe.once('error', (error) => resolve(error.code === 'EADDRINUSE'));
+    probe.listen(port, host, () => probe.close(() => resolve(false)));
+  });
+}
+
 // With an explicit --port a busy port is an error the user asked for. Without
 // one, MOTHER walks up to the next free port so a second room just opens.
 async function openRoom(options) {
   const explicit = cli.explicit('port');
   let port = options.port;
+  if (explicit && await portTaken(port)) {
+    console.error(`\n  MOTHER › port ${port} is already in use. Another MADRE may be open there; try --port ${port + 1} or omit --port to pick one automatically.\n`);
+    process.exit(2);
+  }
   for (let attempt = 0; attempt < 20; attempt += 1) {
     try {
       return await startPulse({ ...options, port });
     } catch (error) {
+      // The room itself says it is taken, whatever port this attempt used.
+      if (error.code === 'ROOM_IN_USE') { console.error(`\n  MOTHER › ${error.message}\n`); process.exit(2); }
       if (error.code !== 'EADDRINUSE') throw error;
       if (explicit) {
         console.error(`\n  MOTHER › port ${port} is already in use. Another MADRE may be open there; try --port ${port + 1} or omit --port to pick one automatically.\n`);
@@ -132,7 +172,7 @@ if (command === 'doctor' && (has('--catalog') || has('--conditions'))) {
     console.log(`  ${'Ollama'.padEnd(10)} ${ollama.disabled ? 'ignored (PULSE_OLLAMA=0)' : ollama.running ? `running${ollama.chatModel ? ` · @madre with ${ollama.chatModel}` : ' · no chat model yet'}${ollama.embedModel ? ` · embeddings ${ollama.embedModel}` : ''}` : 'not running · optional'}`);
     console.log(`  ${'MADRE'.padEnd(10)} ${update.current}${update.available ? ` · ${update.latest} available · ${update.command}` : update.latest ? ' · up to date' : update.enabled ? ' · npm not reachable' : ' · update check off (PULSE_UPDATE_CHECK=0)'}`);
     console.log(`\n  Project    ${result.project}`);
-    console.log(result.ok ? '\nReady to start. Known conditions and fixes: `madre doctor --catalog [query]`.\n' : '\nNo agent is online. Run `madre setup`. Known conditions and fixes: `madre doctor --catalog`.\n');
+    console.log(result.ok ? '\nReady to start. Known conditions and fixes: `madre doctor --catalog [query]`.\n' : '\nNo agent is online yet. Run `madre start`: the room opens anyway and walks you through installing and signing one in. Known conditions and fixes: `madre doctor --catalog`.\n');
   }
   process.exitCode = result.ok ? 0 : 1;
 } else if (command === 'setup') {
@@ -145,22 +185,25 @@ if (command === 'doctor' && (has('--catalog') || has('--conditions'))) {
 } else if (command === 'start') {
   const port = Number(option('--port', '4317'));
   const noOpen = has('--no-open');
-  // First contact: in a terminal with nobody online, MOTHER walks the user
-  // through configuring an agent before the room opens.
-  if (process.stdin.isTTY && process.stdout.isTTY && !has('--no-setup')) {
-    const agents = await detectAgents();
-    const probes = await probeAll(agents);
-    const { localIntelligence, madreOnline } = await import('../src/setup.mjs');
-    if (!agents.some((agent) => isOnline(agent, probes[agent.id])) && !madreOnline(await localIntelligence())) {
-      const { action } = await runSetup({ projectRoot, stateRoot });
-      if (action !== 'start') process.exit(0);
-    }
+  // First contact happens in the room, not here: MADRE opens even with nobody online and the
+  // bridge walks the human through installing and signing in. `madre setup` keeps the terminal
+  // wizard for whoever prefers it, and `--setup` asks for it explicitly.
+  if (has('--setup')) {
+    const { action } = await runSetup({ projectRoot, stateRoot });
+    if (action !== 'start') process.exit(0);
+  }
+  // A room for this project may already be open. Show that one instead of starting a second.
+  const running = await roomAlreadyOpen(port, projectRoot);
+  if (running) {
+    console.log(`\nMADRE is already open for this project\n\n  ${running.url}\n  Project: ${projectRoot}\n  Close that room first if you want a fresh one.\n`);
+    if (!noOpen) openUrl(running.url);
+    process.exit(0);
   }
   await openRoom({ port, projectRoot, openBrowser: !noOpen });
 } else if (command === 'help') {
   console.log(`MADRE
 
-  madre start [--project PATH] [--port 4317] [--no-open] [--no-setup]
+  madre start [--project PATH] [--port 4317] [--no-open] [--setup]
               Without --port, a busy 4317 falls through to the next free port.
   madre setup [--project PATH] [--port 4317] [--no-open]
   madre doctor [--project PATH] [--json]

package/docs/INTERNALS.md

@@ -26,8 +26,24 @@ La ventana de contexto que recibe un agente es de 16 000 caracteres (`PULSE_CONT
 - `memories` con FTS5: las notas destiladas, tipadas (`decision`, `fact`, `preference`, `question`), con las secuencias que las sustentan, quién las escribió y su origen (`distilled` o `noted`).
 - `entry_vectors` y `memory_vectors`: embeddings de 768 dimensiones, calculados en segundo plano y nunca en el camino crítico de un turno.
 
+**Conversaciones.** Un proyecto tiene una memoria y muchas conversaciones. El archivo, la tripulación, los módulos y la lista de privacidad son del proyecto; una conversación es solo el registro de una línea de trabajo. La primera es el `events.jsonl` que siempre estuvo ahí —no se mueve ningún archivo para añadir esto—, las demás viven en `<sala>/chats/<id>/events.jsonl`, y `<sala>/chats.json` guarda sus nombres y cuál está abierta. La numeración es del proyecto, no de la conversación: al abrir una se arranca desde la secuencia más alta que alcanzó cualquier otra, así que `#1411` significa un intercambio de este proyecto y el índice de memoria, las citas y NOSTROMO siguen valiendo. Hay hueco en un ledger y eso está bien: las secuencias son un orden, no un conteo.
+
+Una conversación a la vez maneja a la tripulación —dos hilos editando el mismo árbol de trabajo no es una función, es una forma de perder trabajo—, así que abrir otra se niega mientras haya un turno corriendo. Y una sala por proyecto: `<sala>/open.json` lleva el pid y el puerto del servidor que la tiene, y otro arranque sobre el mismo proyecto se niega con la dirección de la sala abierta. Sin eso, dos servidores escribiendo conversaciones distintas del mismo proyecto repartirían la misma secuencia dos veces y el archivo se quedaría callado con una de ellas.
+
 **Recall.** Cuando el transcript excede la ventana, cada turno recibe además, dentro del mismo presupuesto (`PULSE_RECALL_SHARE`, 30 % por defecto), las notas y los intercambios anteriores que coinciden con la petición. La búsqueda léxica pondera cada término por su rareza en la sala: una ruta o un nombre pesan más que una palabra común. Con vectores, se fusiona con la similitud de coseno.
 
+**Activación en cascada.** Cada recuerdo que entra a un turno deja un renglón con el lote que compartió, así que la sala sabe qué notas llegan juntas. De ahí sale una asociación —Jaccard sobre los turnos donde cada una fue encontrada por la búsqueda misma— y el recall guarda dos huecos para ella: al traer una nota, trae también la que la acompaña, aunque no compartan una sola palabra. Solo votan los turnos donde la búsqueda las encontró por mérito propio, nunca los que la cascada creó, o la red se cerraría sobre sí misma en unos días. La fuerza es un cociente: una pareja que deja de coincidir se apaga sola. Umbral 0.34, mínimo dos coincidencias, y la búsqueda nunca pierde un hueco a manos de la asociación. `PULSE_RECALL_CASCADE=0` o el interruptor en MU/TH/UR la apagan.
+
+**Zonas frías.** Un recuerdo está frío cuando se cumplen tres cosas a la vez: ningún turno lo ha llevado nunca, no comparte tema con ningún otro —así que tampoco se le puede llegar de lado— y el archivo se abrió al menos doce veces desde que se escribió. La tercera es la que importa: nunca-recordado es lo que toda nota es el día que nace; frío es la oportunidad que pasó de largo. Las oportunidades se cuentan en turnos que de verdad entraron al archivo, y solo desde el día en que la sala empezó a llevar el rastro. NOSTROMO los cuenta en su cabecera y los rodea de un anillo tenue cuando se le pide.
+
+**Qué preguntar.** La sala escribe las preguntas cuya respuesta le falta, siempre con las palabras que ya tiene y nunca inventando un tema que nadie levantó. Tres pozos: las preguntas que el archivista registró como abiertas y nadie contestó, los recuerdos fríos —preguntar es la alternativa honesta a tirar algo que nunca tuvo su oportunidad— y la clase de nota de la que el archivo anda corto (decisiones, preferencias, hechos; preguntas no, porque un archivo corto de preguntas no se arregla pidiendo más). Se toman por turnos para que un pozo lleno no sea la lista entera, y dos formas de preguntar lo mismo cuentan como una. Nada se envía: la pregunta va al compositor y la humana decide quién responde.
+
+**El veredicto.** `GET /api/maturity` junta las seis lecturas, las tres pruebas, las zonas frías y las preguntas pendientes, y devuelve una frase y una instrucción. El orden no lo decide el puntaje: primero lo falso (contradicciones abiertas), luego lo que el archivo no puede contestar —y ahí manda a las preguntas que la sala ya escribió—, luego la lectura más floja citando su propio consejo, y al final la prueba que nadie ha corrido. La consistencia se calcula al leer; la cobertura se refresca sola una vez al día, en segundo plano y solo con embeddings locales.
+
+**Las tres pruebas.** La lectura de madurez cuenta de qué está hecho el archivo; no dice si funciona. Eso lo dice una prueba, y una prueba solo vale si puede fallar. `COVERAGE` toma preguntas reales del historial, corre el recall en el punto exacto en que cada una se hizo y lo compara con la respuesta que de verdad se dio. `CONSISTENCY` mira las contradicciones que EYECAT sigue sosteniendo, lo que quedó fuera de circulación y si las aberraciones se archivan más seguido últimamente o menos. `MATCH` vuelve a hacerle al modelo local preguntas que contestó una CLI de frontera y compara. Ninguna se gasta un turno de proveedor; la tercera corre en segundo plano y se puede detener.
+
+Las tres se miden **contra un control**: dentro de una sala todo habla de los mismos temas, así que a un embedder cualquier par de textos le parece cercano —la primera corrida de COVERAGE dio treinta de treinta—. Para contar, lo que el archivo entregó tiene que ganarle a lo que habría entregado para otra pregunta, por un margen. Cada resultado dice cuántos casos tuvo, con qué midió (significado o palabras), la barra y la media contra el control.
+
 **Destilación.** Cada `PULSE_DISTILL_EVERY` intercambios sin destilar, o tras `PULSE_DISTILL_IDLE_MS` de reposo, el archivista lee un lote acotado por `PULSE_DISTILL_MAX_CHARS`, del más reciente hacia atrás, y escribe hasta cinco notas. El archivista es el más barato permitido en el orden Ollama, Gemini, OpenCode, Codex, Claude; el que falla queda en banca treinta minutos y pasa el siguiente. Una sola llamada por lote, nunca durante un turno. Para los modelos locales se pide JSON estricto.
 
 **Embeddings.** `PULSE_EMBED_PROVIDER=auto` usa Ollama si corre con un modelo de embeddings (`nomic-embed-text`), si no la key de Gemini (`gemini-embedding-001`, la misma key que usa el Gemini CLI, incluida la del llavero de macOS). Lotes de hasta 100 textos por llamada. `PULSE_EMBED=0` deja el recall léxico.