@jossuealcala/madre 1.0.2 → 1.0.3

package/docs/en/REFERENCE.md

@@ -15,7 +15,7 @@ You need Node 22.5 or later and at least one of these CLIs with a signed-in sess
 
 1. Run `npx @jossuealcala/madre` from any folder: it opens Home, with all your projects and the Coordinator at the top. The first time, a three-step assistant walks you through it: connect the agents (each with its own button to install it and sign in, right there; once for all projects), add the projects (you choose folders inside your user folder; adding does not open them) and open the ones you are going to use. `npx @jossuealcala/madre start` inside a folder still opens that project directly; if there are no agents, the project opens anyway on Connect your agents so you can install them and sign in.
 2. The project opens at `http://127.0.0.1:4317`. Pick an agent in the selector or type `@claude …`. The chip next to `to @agente` says which mode the message goes out in; `#1 CHAT ONLY`, read-only, is the default.
-3. To add or reconnect an AI later: Settings → Agents (the settings button in the bar, or ⌘, / Ctrl+,), where the agents live alongside the rest of the settings. Codex and Claude Code sign in with one click; Gemini and OpenCode accept their key right there. MADRE does not store provider credentials: each key goes to its own CLI's file.
+3. To add or reconnect an AI later: Settings → Agents (the settings button in the bar, or ⌘, / Ctrl+,), where the agents live alongside the rest of the settings. Codex, Claude Code, Gemini (with your Google account) and OpenCode (with GitHub Copilot) sign in with one click; Gemini and OpenCode also accept their key right there. Under each agent, "Prefer your terminal?" unfolds the same step written as a command, for whoever prefers to do it by hand. MADRE does not store provider credentials: each session and each key goes to its own CLI's file.
 4. With Ollama, the Local AI module (Modules, in the bar) is already on: memory is embedded locally and `@madre` appears in the row.
 5. Settings → Memory decides who distills the memory and how often. The Memory map, from the Diagnostics header, shows what the project remembers.
 
@@ -25,13 +25,24 @@ npx @jossuealcala/madre setup       # the same setup, from the terminal, if you
 npx @jossuealcala/madre start --no-open --project RUTA
 ```
 
+**On a server, with no screen.** MADRE listens only on `127.0.0.1` of the machine it runs on, and on purpose: it has no password, and whoever reached it could set the agents to work there. Do not open its ports to the network. To use it on a server, open it through an SSH tunnel from your computer. Home uses 4317 and every project you open takes the next free port (4318, 4319…), so the tunnel carries several; if you open more projects, add more `-L`.
+
+```bash
+# on your computer: reach the server with the tunnel
+ssh -L 4317:127.0.0.1:4317 -L 4318:127.0.0.1:4318 -L 4319:127.0.0.1:4319 -L 4320:127.0.0.1:4320 user@server
+# now on the server
+npx @jossuealcala/madre --no-open
+```
+
+Then open `http://127.0.0.1:4317/salas` in your computer's browser. The agents are installed on the server and connected from Settings › Agents: Claude gives you a link and a code you paste right there, and Gemini and OpenCode take their key. Use your own user, not root: the agents work with the permissions of whoever runs MADRE.
+
 **Three names.** **MADRE** is the product. **Diagnostics** is its operational voice: failures, connections, settings. **Log** is the channel the project runs on: the event record, the plan block, the `.pulse/` folder where artifacts land; those identifiers keep their old name, PULSE.
 
 ---
 
 ## THE PROJECT
 
-**Connect your agents.** With no agents online, the project opens on Connect your agents: one card per agent with its real status and the one action that applies to it, `INSTALL` or `SIGN IN`. Everything runs on your machine, with the command in view, and the output streams to the same screen. Codex and Claude Code sign in with one click because their CLI opens the browser; Gemini and OpenCode accept their key right there, which MADRE writes where that CLI looks for it, with the file locked to your user and without keeping a copy anywhere, only from this computer. Each card also says which account that agent signs in with and whether there is a free entry, so choosing is not a blind guess. That screen folds away as soon as an agent is ready and does not come back: it is the first contact of a project with no one inside. From then on the agents live in `⚙ CONNECTIONS`, with the same buttons and, alongside, each agent's modes, permissions and keys.
+**Connect your agents.** With no agents online, the project opens on Connect your agents: one card per agent with its real status and the one action that applies to it, `INSTALL` or `SIGN IN`. Everything runs on your machine, with the command in view, and the output streams to the same screen. Codex, Claude Code and Gemini sign in with one click because their CLI opens the browser (Gemini has no sign-in command: MADRE selects "Login with Google" in its settings, answers for you the yes it asks before opening the browser and stops the run as soon as the CLI saves its session; if it does not finish, its files are left as they were). OpenCode signs in with GitHub Copilot: MADRE runs `opencode auth login -p github-copilot`, picks github.com in its menu and shows the page and the device code you type on GitHub. The room only offers providers that allow this kind of access to third-party tools: never a Claude subscription (Anthropic does not allow it) and, for now, not ChatGPT or GitLab either; those and GitHub Enterprise stay in `opencode auth login`, in your terminal. Gemini and OpenCode also accept their key right there, which MADRE writes where that CLI looks for it, with the file locked to your user and without keeping a copy anywhere, only from this computer. Each card also says which account that agent signs in with and whether there is a free entry, so choosing is not a blind guess. That screen folds away as soon as an agent is ready and does not come back: it is the first contact of a project with no one inside. From then on the agents live in `⚙ CONNECTIONS`, with the same buttons and, alongside, each agent's modes, permissions and keys.
 
 **The bar.** The brand with its heartbeat, the project root, the agents, `LIVE`, the alerts (`STOP ALL`, new version), `MODULES`, `Diagnostics`, theme and files panel. Each agent sphere carries its usage, what it has consumed: the provider's real limit when the CLI publishes it, otherwise MADRE's local window. One click expands it.
 
@@ -53,6 +64,8 @@ A second click on the chosen sphere, or the `default model ▾` chip, picks the
 
 **Files.** The icon on the right opens the project tree in read-only mode. The viewer numbers lines; click and Shift+click select a range and `REVIEW WITH` sends it to an agent. With **Preview** turned on in `MODULES`, HTML, SVG and Markdown are rendered in a sealed frame instead of showing their code, with a back/reload bar and automatic reload when an agent changes the file.
 
+**Code.** The `CODE` key in the bar opens the viewer beside the conversation as a code workspace: the project's files with their search, tabs (up to 12, still there after a reload) and, above the code, the path and the function the caret is in. ⌘P (Ctrl+P outside macOS) opens a file by its name. Switching tabs never loses what you wrote: the draft stays in its tab, marked with a dot, until you save or discard it. What an agent changed in its last `#3` EDIT turn is marked in its colour, with one card per change: **Keep** (it stops being marked), **Undo** (puts back what was there in those lines only; the rest of the turn stays) and **Ask why** (asks the agent in the conversation). A turn taken back with `UNDO`, or lines you rewrote yourself, are no longer marked. When you ask for a review of some lines, `REVIEW WITH` offers Explain, Improve, Write tests and Fix. **Side by side** puts the rendered Markdown next to the code as you write, or the HTML page reloaded when you save (the latter with Preview on). What you kept is stored in `code-reviewed.json`, next to the project's record (`GET /api/files/changes`, `POST /api/files/changes/review`).
+
 **Theme.** Sun/moon in the bar: automatic, light or dark. The light theme does not glare; the Diagnostics screen stays phosphor.
 
 **Language.** The project speaks **Spanish** by default. The `EN` button in the bar switches it to English and the browser remembers it; `PULSE_LANGUAGE=en` overrides the config on the next start. A language is only how things read: what was written in the ledger keeps the words it was written with, and when shown it is said again in the project's language.
@@ -139,6 +152,8 @@ Everything said outside INCOGNITO is indexed alongside the ledger, in `~/.pulse/
 
 **Memory map.** The memory as a map, behind the project name: MADRE is a beating red sun, each memory a planet in the color of its type, joined by pulsing veins. You can navigate it and read it, and the only thing you can do to it is delete, with double confirmation. Eight taps on the heart activate the Temporary lock and seal the archive for ten minutes.
 
+**Neural mode.** The **Neural** key in the header of the Memory map and the Project map draws the same network as the neurons of a brain: each memory is a point of light in the color of its type, the links are thin axons, and only the paths a pulse travels and the neuron it reaches light up. The core (and, in the Project map, the Coordinator) is the central bulb of that brain, with its stem, and it beats. Turning it on, the light runs out from the core and reaches every neuron in turn. It shows the same and costs a fraction: no surface shaded point by point, no nebula, no stars. When the computer does not give the map the frames it needs, the key invites you to try it, once a session; you choose when to use each mode. The choice is remembered for Home and every project (`pulse.neural` in `~/.pulse/looks.json`).
+
 **@madre.** With Ollama and a chat model, the memory speaks: `@madre` answers from the whole archive with `[#n]` citations, says when the project never discussed something, does not write or run anything, and summons the agents if you ask it to. Its tokens are local and do not count. When there is a model trained on the project, it uses it.
 
 **Settings.** Settings → Memory: who distills, who may, how often, where embedding happens, how much context recall can take up. All in `~/.pulse/config.json`, without restarting.
@@ -153,7 +168,7 @@ The project gathers training material while you work. `MEMORY` shows live how ma
 
 `EXPORT DATASET` writes `train.jsonl` and `valid.jsonl` next to the ledger, redacted. The `TRAIN` card brings the commands already filled in with your project folder and the base model that fits on your machine. Training runs outside MADRE, with mlx on Apple Silicon; the recipe lives in [`docs/training/`](training/README.md). As soon as Ollama has a `madre-<proyecto>` model, `@madre` answers with it and the other CLIs are told to ask it first: the project's memory stops costing tokens.
 
-**Ollama.** If it runs on the machine, MADRE uses it without any configuration: local smart search, local archivist, `@madre`. The Local AI module, in Modules, shows the server, models and roles, downloads the recommended ones and lets you turn off each role. `qwen2.5:7b` on 16 GB, `qwen2.5:3b` on 8 GB; MADRE prefers general chat models over the `-coder` ones.
+**Ollama.** If it runs on the machine, MADRE uses it without any configuration: local smart search, local archivist, `@madre`. The Local AI module, in Modules, shows the server, models and roles, downloads the recommended ones and lets you turn off each role. The model it offers comes from your hardware, not from a fixed rule: the "Your computer" block reads the Apple chip and its shared memory, the NVIDIA card and its video memory, or the processor alone, and shows each Qwen2.5 size (0.5B to 72B) with its minimum to run and to train (for example, `qwen2.5:7b` from 12 GB and `qwen2.5:3b` from 8 GB). With several downloaded, it uses the largest; it prefers general chat models over the `-coder` ones.
 
 ---
 
@@ -233,6 +248,7 @@ In a project, the key next to the house **switches project**: its indicator says
 | `POST /api/salas/forget` | Remove a project from MADRE: closes it if it is open, revokes its connections and sets its `project.json` aside as `project.forgotten.json`. Never the Coordinator's | The Home page with its `Origin`, never a process |
 | `GET /api/tour` · `POST /api/tour` | The 1.0 tour: whether the bonjour is due, whether the person comes from 0.7.2, chapters read, where they left off, hints seen. Saved in `~/.pulse/tour.json`, one per person, not one per port | The pages on this Mac |
 | `GET /api/looks` · `POST /api/looks` | The appearance that Home and all projects share: theme, accent, background and its two dials, bubbles and text. Saved in `~/.pulse/looks.json`, one per person; each page reads it when it opens and when it becomes visible again, and writes it when it changes. What Home chooses for its cards stays in its browser | The pages on this Mac |
+| `GET /api/looks/wallpaper` · `PUT /api/looks/wallpaper` · `POST /api/looks/wallpaper/frame` · `DELETE /api/looks/wallpaper` | Your own wallpaper (1.0.3): one for every page, in `~/.pulse/wallpaper/`. The page fits it (2880 px on its longest side), encodes it and takes its colours for the veil, the mesh and the tint; the server keeps only a WebP, JPEG or PNG picture of up to 8 MB, recognised by its first bytes (never SVG), and serves it with its type and `nosniff`. `GET /api/looks` includes it as `custom`; each page still chooses it or not (`pulse.wallpaper` = `custom`) | The pages on this Mac |
 | `GET /api/tour/projects` · `POST /api/tour/projects` | The 0.7.2 projects that Home cannot list (without `project.json`) and bringing one in: its folder is looked up by name in the usual folders and confirmed by the hash of its id. Projects removed on purpose do not come back | The pages on this Mac |
 | `POST /api/override/arm` | The #3 and #4 key, checked by the project (`src/override.mjs`): what was typed, once or twice, and a pass for that agent and that mode. A message at #3 or #4 goes out only with its pass; without a remembered permission it opens one message, with it, as many as fit in its minutes. STOP ALL and a restart revoke them. Eight wrong keys in one minute return 429. The phrase's fingerprint never goes out through `GET /api/settings` or `/api/state` | The pages on this Mac |
 | `GET /api/copilot` · `POST /api/copilot` · `POST /api/copilot/off` | The copilot: whether it is on and until when; turning it on with the `#3` key (`{ minutes, words }`, 30 to 1440 min) and turning it off. A message with `copilot: true` in `#3` goes without a pass while it lasts; when off it returns 409 with `copilotOff`. Never from a phone | The pages on this Mac |
@@ -241,6 +257,16 @@ In a project, the key next to the house **switches project**: its indicator says
 | `GET /api/enlace/memories` | What this project delivers under a contract: only `travels()` and the contract's types, redacted; 404 if the contract does not serve whoever asks, 423 sealed, 429 over the cap | Another MADRE process with the channel key (`~/.pulse/credentials/enlaces.json`), without `Origin` |
 | `POST /api/enlace/ask` | What this project asks of another; only for a turn running here (409 if not); records `enlace.received` with agent and turn | A turn's `pulse-enlaces` server, with the key |
 | `POST /api/salas/enlaces/recall` | Check or uncheck "Always include" on a connection | The Home page, never a process |
+| `GET /api/enlace/corpus` | (D-S15) Everything this project lets the Coordinator learn under a contract with `train`: the notes that travel, of the contract's types, up to 5,000, redacted; 404 if the contract does not allow it, 423 sealed, 429 over its cap of 6 an hour | The Coordinator's room, with the channel key, without `Origin` |
+| `POST /api/salas/enlaces/train` | Check or uncheck "The Coordinator learns from it"; unchecking it deletes the copy Salas kept | The Home page, never a process |
+| `GET /api/enlace/state` | (D-S16) This project's canonical Continuity (AHP+) state under a contract with `state`: objective, phase, next step, blockers, last handoff, accepted decisions and what is open, redacted; `state: null` without `.ahp/`; 404 if the contract does not allow it, 423 sealed, 429 over `perHour` | The reading room, with the channel key, without `Origin` |
+| `POST /api/enlace/deliver` | (D-S17) Notes the reading room delivers under a contract with `deliver` (1 to 5, of the standing kinds, 600 characters); they wait in the inbox; 429 over `perHour` or with 50 waiting | The reading room, with the channel key, without `Origin` |
+| `POST /api/enlace/ask-state`, `POST /api/enlace/send` | The asking side of the above, for the `enlace_state` and `enlace_deliver` tools of a turn running here | A process of this Mac with the key and a live turn |
+| `GET /api/enlace/inbox` · `POST /api/enlace/inbox/decide` | (D-S17) The notes delivered to this project, and accepting or declining one; accepted, it enters the memory (`origin: 'delivered'`) | The project's page, or one of its agents in #3/#4 with the key |
+| `POST /api/salas/enlaces/allow` | (D-S16, D-S17) Check or uncheck "It shares its state" (`state`) or "It receives delivered notes" (`deliver`) | The Home page, never a process |
+| `POST /api/madre/shutdown` | Turn MADRE off: asks every open project to close the way Home closes one, waits up to 15 s and closes itself; answers `closed` and `stuck` | Only MADRE's own page on this computer (its own `Origin`), never a process or the phone |
+| `GET /api/home-layout` · `POST /api/home-layout` | Home's arrangement in `~/.pulse/home.json` (widgets, project order, pinned bar, cards), the same from any port | The Home page |
+| `GET /api/x/bishop/exam` · `POST /api/x/bishop/exam` | (D-S18) The last exam of the Coordinator's local model and whether it still holds for the model in use; starting it (it runs in the background) | The Home page |
 | `POST /api/enlace/notice` | The Diagnostics line when signing or revoking | The project that serves Home, with the key |
 
 Contracts live in `~/.pulse/config.json` under `enlaces` and the crossings in `enlaces.jsonl` next to each project's record.

package/docs/en/SDK.md

@@ -54,7 +54,7 @@ export default ({ defineModule }) => defineModule({
 
 ## What a module can declare
 
-This table is **the complete contract**: 36 fields, not one more. Any other field you write, MADRE
+This table is **the complete contract**: 38 fields, not one more. Any other field you write, MADRE
 tells you about at install time ("I didn't understand these fields") instead of silently ignoring it. A test in
 the suite compares this table against the code, so if they ever drift apart, it's a failure.
 
@@ -66,11 +66,13 @@ the suite compares this table against the code, so if they ever drift apart, it'
 | `tracks` | If your module wraps something from outside, its version isn't yours: it's that thing's. Declare `{ name, npm }` or `{ name, github }` and return the version found in `status(ctx)` as `runs: [{ name, version }]`. MADRE shows that version and looks for a newer one on its own, once a day, with the page's ↻ button to check now |
 | `updatePlan(ctx, { latest })` | How that new version is brought to this computer: `{ command, args, display, note, after }`. MADRE shows `display` and runs nothing until the human has read it; the output lands in the room line by line. With no command, return `{ command: null, note, download }` and the page sends you to download it |
 | `updates` | An https `{ url }` where you publish **your own module**. With that, its page gets a button that fetches the file, verifies it the same way as an installation, and replaces it if it passes. If you installed it from a file, MADRE remembers which one and you don't need to declare anything: edit it and ask for a new copy |
-| `settings` | Default values. They live in `~/.pulse/config.json` under `modules.<idEnCamelCase>`; `enabled` is the switch |
+| `settings` | Default values. They live in `~/.pulse/config.json` under `modules.<idEnCamelCase>`; `enabled` is the switch for every project, and `rooms` keeps what each project said, which wins. MADRE works it out for you: `ctx.settings.enabled` is already this project's |
 | `status(ctx)` | What the card shows: `{ status: { installed, detail }, preflight: { ok, problems }, install: { display } }`. `install` is returned from here; it is not a top-level field of the module |
 | `status(ctx)` → `runs` | What your module manages that isn't MADRE: `[{ name, version, target }]`. `version` is what you found on this computer (`null` if it isn't there), `target` is what you would install. If it matches `tracks.name`, that is the page's version |
 | `toggle(ctx, payload)` | Replaces the default switch; `confirm: 'texto'` asks for confirmation before turning on |
 | `onToggle(ctx, enabled)` | Reacts to the switch |
+| `ready(ctx)` | What you ask before turning on, in one project or in all (from the Market too): `null` when ready, `{ status, body: { error } }` when not. Turning off never asks it |
+| `footer` | Up to two keys beside MADRE's version, bottom right, while your module is on: `[{ icon: 'heart' \| 'star' \| 'link', label, text, action, url }]`. Words can be one sentence or `{ en, es }`; `url` must be https and opens in a new tab. MADRE draws it: on hover it shows `text` and a button with `action` |
 | `slash` | `/name` commands that run on the server with your `ctx` and return `{ ok, title, text }`. The room shows them as a card and the agents read them |
 | `toolsForTurn(ctx, turn)` | MCP servers for an agent's turn: `[{ name, command, args, env, tools, sends, brief }]`. MADRE attaches them to the CLI in its isolated run and describes `brief` to the agent. `turn` carries the agent, the mode, the lease, the folder, the port, and `turn.turn`: the id of the reply that turn will write. If your server calls back to the room on behalf of the turn, send that id; `ctx.room.runningTurn(id)` tells you whether it is still running and for which agent |
 | `toolsForTurn` → `sends` | Which of your tools **send something outside**. The core withdraws them below `#4` AIRLOCK: the model isn't even told they exist. See below |

package/docs/training/README.md

@@ -36,7 +36,27 @@ python3 -c "import mlx.core as mx; print('CUDA:', mx.cuda.is_available())"   # d
 
 Si dice `True`, los comandos de entrenamiento de arriba (desde `cd ~/.pulse/rooms/<proyecto>`) y los pasos 3 y 4 son los mismos. Si no, no hay ruta probada en Linux todavía.
 
-`train.sh` en esta carpeta hace lo mismo con comprobaciones. En 16 GB usa el 1.5B; con 32 GB o más, `Qwen/Qwen2.5-3B-Instruct` o `Qwen/Qwen2.5-Coder-7B-Instruct` con `--batch-size 1`. Una ronda de 600 iteraciones tarda de 10 a 40 minutos.
+`train.sh` en esta carpeta hace lo mismo con comprobaciones (`bash train.sh <carpeta del proyecto> <base>`).
+
+### Qué tamaño entrenar
+
+No depende de una máquina en particular, sino de la memoria de la tuya. MADRE la mide (Módulos › IA local › Tu equipo) y propone el tamaño más grande que tu computadora entrena y luego corre. Los mínimos son para la computadora completa, con el sistema y el navegador abiertos:
+
+| Modelo | Base para entrenar | Para correrlo | Para entrenarlo |
+|---|---|---|---|
+| Qwen2.5 0.5B | `Qwen/Qwen2.5-0.5B-Instruct` | 4 GB | 8 GB |
+| Qwen2.5 1.5B | `Qwen/Qwen2.5-1.5B-Instruct` | 6 GB | 12 GB |
+| Qwen2.5 3B | `mlx-community/Qwen2.5-3B-Instruct-4bit` | 8 GB | 16 GB |
+| Qwen2.5 7B | `mlx-community/Qwen2.5-7B-Instruct-4bit` | 12 GB | 24 GB |
+| Qwen2.5 14B | `mlx-community/Qwen2.5-14B-Instruct-4bit` | 20 GB | 36 GB |
+| Qwen2.5 32B | `mlx-community/Qwen2.5-32B-Instruct-4bit` | 36 GB | 64 GB |
+| Qwen2.5 72B | `mlx-community/Qwen2.5-72B-Instruct-4bit` | 64 GB | 128 GB |
+
+- En una Mac con chip Apple la memoria es compartida: cuenta toda.
+- Con una tarjeta NVIDIA cuenta la memoria de la tarjeta (VRAM), que rinde un tercio más porque el modelo la tiene para él solo.
+- Sin ninguna de las dos, un modelo corre en el procesador, más lento, y no se entrena: un LoRA en procesador tarda días.
+
+Desde 3B la base viene en 4 bits (QLoRA), y desde 7B `train.sh` agrega `--grad-checkpoint`. Una ronda de 600 iteraciones tarda de 10 a 40 minutos hasta 3B, y una hora o más por encima. El disco libre que hace falta ronda 5.5 GB por cada mil millones de parámetros, más 2 GB.
 
 ## 3 · Servir en Ollama
 
@@ -52,6 +72,13 @@ python3 llama.cpp/convert_hf_to_gguf.py fused --outfile madre.gguf --outtype q8_
 cp <carpeta de MADRE>/docs/training/Modelfile . && ollama create madre-<proyecto> -f Modelfile
 ```
 
+Con una base en 4 bits (3B en adelante) el paso cambia en tres puntos:
+1. `mlx_lm.fuse` lleva `--de-quantize`, para que llama.cpp pueda leer el resultado.
+2. La conversión usa `--outtype f16`.
+3. `ollama create` lleva `--quantize q4_K_M`, que lo deja en 4 bits, el tamaño que cuenta la tabla.
+
+La pantalla de entrenamiento de MADRE ya escribe así los comandos para el tamaño que elijas.
+
 El nombre importa: `madre-<proyecto>` en minúsculas, con guiones. Al siguiente **REVISAR OTRA VEZ** en Módulos › IA local, `@madre` cambia a ese modelo y Lo que recuerda lo dice. El `Modelfile` viene en `docs/training/` del repositorio de MADRE y del paquete de npm.
 
 ## 4 · Evaluar antes de confiar

package/docs/training/train.sh

@@ -11,8 +11,12 @@ PAIRS=$(wc -l < "$ROOM/dataset/train.jsonl")
 [ "$PAIRS" -ge 50 ] || { echo "only $PAIRS training pairs; let the room grow (aim for a few hundred)"; exit 3; }
 python3 -c "import mlx_lm" 2>/dev/null || { echo "pip install mlx-lm (inside a venv) first"; exit 4; }
 cd "$ROOM"
+# From 7B up, recompute instead of keeping every activation: slower, and it fits the memory the
+# room's table promises for that size (src/modules/local-models.mjs).
+EXTRA=()
+if [[ "$BASE" =~ -([0-9]+)B- ]] && [ "${BASH_REMATCH[1]}" -ge 7 ]; then EXTRA+=(--grad-checkpoint); fi
 echo "training LoRA on $PAIRS pairs · base $BASE · $ITERS iterations"
-mlx_lm.lora --model "$BASE" --train --data dataset --iters "$ITERS" --batch-size 2 --learning-rate 1e-5 --adapter-path adapters
+mlx_lm.lora --model "$BASE" --train --data dataset --iters "$ITERS" --batch-size 2 --learning-rate 1e-5 --adapter-path adapters ${EXTRA[@]+"${EXTRA[@]}"}
 mlx_lm.lora --model "$BASE" --adapter-path adapters --data dataset --test
 echo
 echo "adapters in $ROOM/adapters · next: mlx_lm.fuse, convert to GGUF, ollama create madre-<project> (see README.md)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jossuealcala/madre",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MADRE · one local room where the AI coding agents already on your machine (Codex, Claude Code, Gemini CLI, OpenCode) work on your project together, share one memory you can see and explore, and answer to you. Read-only by default, with per-message permission modes and checkpoints you can undo. Nothing leaves your machine on its own.",
   "keywords": [
     "ai-agents",
@@ -65,8 +65,8 @@
     "docs/en/training"
   ],
   "bin": {
-    "madre": "./bin/madre.mjs",
-    "pulse": "./bin/madre.mjs"
+    "madre": "./bin/madre.cjs",
+    "pulse": "./bin/madre.cjs"
   },
   "engines": {
     "node": ">=22.5.0"