ratacode 0.2.5

package/apreton/mcp.md

@@ -0,0 +1,221 @@
+# MCP: cómo conectar tu app a RATACODE
+
+RATACODE es una terminal de trabajo con IA con la cara de RATACODE, montada sobre un motor libre que no se toca. El MCP (Model Context Protocol) deja que cualquier app con MCP (Claude Code, Codex, OpenClaw, Rowboat, ChatGPT web con túnel) le mande trabajo a los modelos que ya tienes configurados en RATACODE —incluidos los locales, con Ollama o LM Studio—. Los modelos baratos hacen el trabajo; tú planificas, revisas y cierras.
+
+**Es la vía recomendada** para cualquier app que hable MCP: cuesta menos que mirar la pantalla (dos llamadas y texto, sin capturas), tiene estado explícito (`run_task` con `esperar_segundos` + `get_task_status`) y **cada tarea sale en la barra lateral del panel**, con su conversación.
+
+## Cómo darlo de alta (por app)
+
+El servidor es `ratacode mcp` (subcomando del mismo binario). Si `ratacode` no está en el PATH,
+usa `node <ruta>\bin\ratacode.js mcp`.
+
+**Las claves NO van por aquí.** Están en un solo sitio —RATACODE › Ajustes › Models— y el MCP las
+lee de ahí (preguntándole al motor). No hay que pasarle ninguna variable de entorno: su alta es
+`ratacode mcp` y nada más. `<casa>` es tu casa (`%USERPROFILE%\.ratacode` si no le has dicho otra
+cosa con `--home`).
+
+### Claude Code — COMPROBADO
+Documentación oficial: <https://code.claude.com/docs/en/mcp> (opción 3, servidor stdio local).
+Todo lo que va detrás de `--` es el comando del servidor, sin tocarlo.
+
+```sh
+claude mcp add --transport stdio ratacode -- ratacode mcp
+```
+
+Lo que NO hay que hacer es terminar el turno con la tarea en marcha: por stdio el servidor vive lo
+que vive el cliente (mira «La regla del tropiezo 17», abajo).
+
+### Codex — COMPROBADO
+Documentación oficial: <https://learn.chatgpt.com/docs/extend/mcp> (Codex CLI → *Configure with the CLI*).
+
+```toml
+[mcp_servers.ratacode]
+command = "ratacode"
+args = ["mcp"]
+```
+
+Ni `--env` ni `env_vars`: la clave no se le pasa al servidor, se lee de Ajustes › Models.
+
+**Codex y las aprobaciones.** Codex no ejecuta herramientas MCP con la política de aprobación en
+«never»: sale `MCP tool call requires approval, but approval policy is never`, y el encargo no llega
+a RATACODE. Se arregla aprobando: `codex exec --approve-for-me "…"` (comprobado el 26-sep), o
+aprobando la herramienta en la sesión interactiva. Sin una de las dos cosas, Codex se queda mirando.
+
+### OpenClaw — COMPROBADO
+Documentación oficial: <https://docs.openclaw.ai/cli/mcp/registry>. Aquí no hay `--`: cada cosa va
+con su bandera (`--command`, un `--arg` por argumento, `--cwd`).
+
+```sh
+openclaw mcp add ratacode --command ratacode --arg mcp
+```
+
+### Rowboat — SOSPECHA
+Lo único que dice la documentación oficial (<https://github.com/rowboatlabs/rowboat>, *Extend Rowboat
+with tools (MCP)*) es: **Settings → MCP Servers**, añadir la entrada al objeto `mcpServers` y *Save*.
+El ejemplo que publican es de un servidor HTTP (`url`), así que **no está comprobado que su editor
+acepte un servidor stdio** con `command`/`args`. Si lo acepta, la entrada sería:
+
+```json
+{
+  "mcpServers": {
+    "ratacode": {
+      "command": "ratacode",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+**SOSPECHA:** no he encontrado un `rowboat mcp add` por línea de órdenes ni un fichero de
+configuración documentado; compruébalo en tu versión de Rowboat.
+
+### Genérico (cualquier cliente MCP por stdio)
+Añade esto a la configuración MCP de tu app:
+
+```json
+{
+  "mcpServers": {
+    "ratacode": {
+      "command": "ratacode",
+      "args": [
+        "mcp",
+        "--home",
+        "C:\\Users\\tu-usuario\\.ratacode"
+      ]
+    }
+  }
+}
+```
+
+**Las claves están en la casa, no en tu entorno.** El servidor no mira las variables del cliente ni
+abre ficheros de claves: le pregunta al motor si la credencial de esa ruta está puesta. Si no lo
+está, se para y dice: `Falta la clave de B.AI. Pégala en RATACODE › Ajustes › Models.`
+
+## Lo que una tarea puede LEER (y por qué el HTTP pide permiso)
+
+Escríbelo en tu cabeza antes de abrir el túnel: **una tarea MCP lee y escribe solo dentro de las
+carpetas que tú autorizas** (`mcp.workspaces`). No es un descuido del motor: DSH no tiene ningún
+modo que acote la lectura —`read-only`, `workspace-write` y `danger-full-access` son ejes de
+ESCRITURA, y su propio código lo dice: «Reads pass through untouched: every mode permits
+reading»—, y su encierre de Windows restringe el token a la escritura («`WRITE_RESTRICTED`
+intersects only write accesses»). Por eso la lectura la encierra RATACODE, con el gancho
+`tools/pre-execute` del motor: cada herramienta que lleve una ruta fuera de tus carpetas se para
+y el agente ve una línea: «Fuera de la carpeta autorizada: `<ruta>`».
+
+Y no hay puertas por detrás: en una tarea del MCP no hay terminal, ni trabajos en segundo plano,
+ni red, ni subagentes, ni guiones.
+
+Consecuencias, claras:
+
+- Lo que la tarea lea **viaja al proveedor del modelo** que hayas elegido, así que la carpeta
+  autorizada es, de verdad, todo lo que ese chat puede ver. No pongas ahí claves de otros sitios.
+- `ratacode mcp --http` y `node mcp/tunel.mjs` **ya no piden nada**: antes exigían
+  `--acepto-lectura-total` porque la lectura no estaba encerrada; desde R25 sí lo está, y esa
+  bandera se acepta como no-op (para no romper los comandos viejos).
+- Por stdio, igual: la superficie la controlas tú (es tu propio cliente local el que arranca el
+  servidor).
+- Si además quieres aislarlo del sistema operativo (un usuario o una máquina virtual solo para
+  esto), mejor: son dos cierres, no uno.
+
+## ChatGPT web (y cualquier app que hable MCP por HTTP): el túnel
+
+ChatGPT web no arranca procesos: necesita una **URL** de MCP por HTTP. Por eso existe
+`mcp/tunel.mjs`: expone el MCP de tu PC a Internet con Cloudflare mientras corre.
+
+```sh
+# 1) el MCP por HTTP (local), con espacios declarados en `mcp.workspaces`
+ratacode mcp --http
+
+# 2) el túnel, en otra ventana
+node mcp/tunel.mjs --home <casa>
+```
+
+`tunel.mjs` te imprime la **URL pública completa** (dominio + `/mcp/<clave>`): esa es la que se
+pega en ChatGPT (modo desarrollador → conector MCP) o en la app que sea. Al abrirlo **estrena
+clave** (el servidor que ya corre la adopta sin reiniciar; con `--misma-clave` reutiliza la
+anterior). La clave vive en `<casa>\mcp\http-url.txt` y `<casa>\mcp\http-secret.txt`, con permisos
+de sólo-dueño; no se imprime en los registros. Con `Ctrl+C` se cierra el túnel y el puerto deja de
+estar expuesto.
+
+Si tienes dado de alta el túnel nombrado `mcp.mod-rat.com` en tu Cloudflare, lo usa con ese
+hostname fijo (por fichero de configuración, nunca pasando la URL por argumentos); si no, abre un
+quick tunnel con URL efímera.
+
+**Lo que implica abrirlo:** el túnel expone el MCP a Internet, así que quien tenga esa URL puede
+mandar tareas. Lo que **no** puede es salirse de tus carpetas: la tarea lee y escribe solo dentro
+de `mcp.workspaces` y no tiene terminal ni red (mira el apartado de arriba). No lo dejes abierto
+más de lo que dure el trabajo, y cámbiale la clave (basta con volver a lanzar `tunel.mjs`) cuando
+cierres.
+
+**Rowboat.** Su editor documenta servidores por `url`, no por `command`; con el túnel o con el MCP
+por HTTP puedes darle la URL con la clave y no depender de que acepte un servidor stdio (que es lo
+que sigue sin estar comprobado, ver arriba).
+
+## Cómo usarlo
+
+1. **`list_models`** — llama primero para ver qué modelos hay, con proveedor, id, contexto, capacidades y estado.
+2. **`run_task`** — lanza el encargo. Sin `esperar_segundos` devuelve `task_id` al momento y el trabajo sigue en segundo plano. **Con `esperar_segundos` (1-600), la llamada ESPERA y devuelve el resultado completo en esa misma respuesta**, sin llamar a nada más.
+3. **`get_task_status`** — consulta el estado: `queued`, `running`, `completed`, `failed`, `cancelled`.
+4. **`get_task_result`** — recoge la respuesta, modelo, proveedor, tokens, coste (si está declarado), duración y errores.
+
+**Si el usuario eligió un modelo, no lo cambies.** Si no eligió, se usa el modelo por defecto de la casa y se te dice cuál.
+
+### La regla del tropiezo 17: no dejes la tarea a medias
+
+Por stdio, **las tareas viven lo que vive el cliente**: si el cliente se cierra, el servidor se va y la
+tarea muere donde esté (así quedó un `hola.txt` con un «hola» y nada más: el cliente había terminado su
+turno con «despiertas en 60 s», y a los 60 s ya no había nadie). Con un cliente de una sola vuelta
+(`claude -p`, `codex exec`, una llamada suelta), haz UNA de estas dos cosas:
+
+- lanza `run_task` **con `esperar_segundos`** (p. ej. 300) y recoge el resultado de esa misma respuesta; o
+- **no termines tu turno hasta que `get_task_status` diga `completed` o `failed`**.
+
+Con `esperar_segundos`, si la tarea no acaba dentro del plazo, la respuesta lo dice (`espera.agotada:
+true`) y queda el `task_id` para seguir preguntando. El máximo son 600 s (10 minutos); si tu cliente
+corta las llamadas largas antes, usa un valor por debajo de ese corte.
+
+## Cómo escribir un encargo
+Usa esta plantilla (funcionó a la primera):
+
+```
+Soy [tu nombre], [tu rol]. Lee [fichero o carpeta].
+LÍMITES: escribe SOLO en [carpeta]. [Lo que NO toques]. No leas ficheros de credenciales. Sin git, sin publicar.
+TAREA:
+1) [Primer paso]
+2) [Segundo paso]
+3) ...
+Comprueba cada paso o marca SOSPECHA.
+ENTREGA: [fichero con tope de líneas].
+HAZLO sin pedir permiso.
+```
+
+## Cómo comprobar que llegó
+- Con `esperar_segundos`, la respuesta de `run_task` ya trae `estado` y el `resultado` completo: si `estado` es `completed`, no hay nada más que preguntar.
+- `get_task_status` pasa de `queued` a `running` a `completed`.
+- `get_task_result` devuelve la respuesta con tokens y duración.
+- Si falla, `get_task_result` devuelve el error.
+
+## Cómo vigilar sin capturas
+No mires la pantalla. Usa `get_task_status` y `get_task_result` directamente. Una captura gasta cuota; una llamada MCP no.
+
+## Trampas que ya costaron (tropiezos 2, 4, 6, 7, 11, 12, 13, 16, 17, 18)
+
+- **T2 · Espacio de trabajo:** el servidor arranca con `--home <casa>`; el espacio ya viene puesto.
+- **T4 · Capturas gastan cuota:** usa `get_task_result`, no capturas de pantalla.
+- **T6 · No aplica:** en MCP no hay caja de chat.
+- **T7 · No aplica:** en MCP no hay caja de chat.
+- **T11 · Credenciales:** nunca leas `.credentials.yaml`, `.env` ni bóvedas. Si falta una clave, el servidor se para y lo dice.
+- **T12 · Las claves NO van por el entorno:** están en RATACODE › Ajustes › Models, y el MCP las lee de ahí. Si falta una, la llamada sale con `Falta la clave de <proveedor>. Pégala en RATACODE › Ajustes › Models.` No hay que pasarle ninguna variable al servidor, y la clave NO se escribe en la configuración de tu app.
+- **T13 · Tutor equivocado:** si el tutor dice algo falso, corrígelo con la prueba (fichero:línea); no obedezcas una premisa falsa.
+- **T16 · No aplica:** el MCP no usa `url.txt` (eso es el panel). Aquí no hay URL que caduque.
+- **T17 · Cliente de una sola vuelta:** no termines el turno con la tarea en marcha. Usa `run_task` con `esperar_segundos`, o no pares hasta que `get_task_status` diga `completed`/`failed`. Por stdio la tarea vive lo que vive el cliente.
+- **T18 · Un encargo grande, en sesión nueva:** cada tarea del MCP es una sesión nueva del motor (no arrastra historial), pero TU chat acumula: con muchos turnos y pasos, el proveedor acaba devolviendo un 400 (`read body failed`). Encargos en fichero y chat nuevo cuando toque.
+
+## El ciclo (diagnóstico → revisión → arreglo → cierre)
+
+1. **Diagnóstico** (tu sesión MCP): solo mirar, sin tocar ficheros. Lee lo que te den, pasa pruebas, busca fallos y comprueba cada uno. Lo no comprobado, SOSPECHA.
+2. **Revisión** (tú): comprueba los fallos que más pesen. Marca falsos positivos.
+3. **Arreglo** (tu sesión MCP): de uno en uno, cambio mínimo, misma prueba antes/después. Sin commit.
+4. **Cierre** (tú): lee el diff, repite la prueba, abre la app y lo ve. Commit solo si toca.
+
+**No arranques servidores. No publiques. Si falta algo, dilo.**

package/apreton/navegador.md

@@ -0,0 +1,58 @@
+# Navegador: cómo manejar RATACODE desde tu chat
+
+RATACODE es una terminal de trabajo con IA con la cara de RATACODE, montada sobre un motor libre que no se toca. Se abre en el navegador (puerto 3777) y recibe encargos de cualquier agente. Los modelos baratos —o los tuyos, en local— hacen el trabajo; tú planificas, revisas y cierras.
+
+## Dónde está la URL
+Lee `<casa>\url.txt` y ábrela en tu navegador. La casa es la carpeta desde la que se arrancó `ratacode` (o `%USERPROFILE%\.ratacode` por defecto).
+
+`ratacode` borra ese fichero al empezar y sólo lo escribe cuando el puerto ya escucha de verdad, así
+que la URL que leas es la de ESTA vez (no la de la vez anterior). Si no carga, o el fichero todavía no
+está: espera 15 s, vuelve a leerlo y, si el puerto no escucha, arranca `ratacode` otra vez. El motivo
+de cada cierre del motor queda en `<casa>\ratacode.log` (código de salida y señal).
+
+## Cómo escribir un encargo
+Usa esta plantilla (funcionó a la primera):
+
+```
+Soy [tu nombre], [tu rol]. Lee [fichero o carpeta].
+LÍMITES: escribe SOLO en [carpeta]. [Lo que NO toques]. No leas ficheros de credenciales. Sin git, sin publicar.
+TAREA:
+1) [Primer paso]
+2) [Segundo paso]
+3) ...
+Comprueba cada paso o marca SOSPECHA.
+ENTREGA: [fichero con tope de líneas].
+HAZLO sin pedir permiso.
+```
+
+**Antes de escribir**, comprueba que la caja del chat está visible y es la del título correcto (el usuario puede tener ajustes abiertos, la caja puede estar fuera de pantalla).
+**Después de enviar**, comprueba que la sesión avanza (fichero de sesión o respuesta). Si no avanza, mira por qué antes de repetir.
+
+## Cómo comprobar que llegó
+- El fichero de sesión crece (cada turno añade líneas).
+- El encargo aparece en la lista de tareas de la web.
+- Si el modelo contesta, la respuesta sale en el panel.
+
+## Cómo vigilar sin capturas
+No mires la pantalla. Lee los ficheros de sesión directamente: estado, herramientas usadas, permisos pedidos, último mensaje. Una captura cada vez gasta cuota; un fichero no.
+
+## Trampas que ya costaron (tropiezos 2, 4, 6, 7, 11, 13, 16, 17, 18)
+
+- **T2 · Espacio de trabajo:** el diálogo nativo de Windows no lo ves. Arranca `ratacode` desde la carpeta de trabajo; el espacio ya viene puesto.
+- **T4 · Capturas gastan cuota:** pide la entrega en un fichero y vigila ese fichero, no la pantalla.
+- **T6 · La caja no recibe:** el usuario puede tener los Ajustes abiertos o la caja fuera de pantalla. Antes de escribir, comprueba que la caja es la correcta y está visible.
+- **T7 · Caja fuera de pantalla:** haz clic en la caja, escribe con el teclado y pulsa Enter. Si no llega, el div editable no cuenta como texto escrito; usa el teclado, no el formulario.
+- **T11 · Credenciales:** nunca leas `.credentials.yaml`, `.env` ni bóvedas. Si falta una clave, para y dilo.
+- **T13 · Tutor equivocado:** si el tutor dice algo falso, corrígelo con la prueba (fichero:línea); no obedezcas una premisa falsa.
+- **T16 · La URL a medias y el cierre sin rastro:** `url.txt` se borra al empezar y se escribe SÓLO cuando el puerto contesta, así que si lo lees y no carga, espera 15 s y vuelve a leerlo; si el puerto no escucha, arranca `ratacode` otra vez. Si el panel se cierra solo, el motivo está en `<casa>\ratacode.log` (código de salida y señal): no lo cierres tú antes de leerlo.
+- **T17 · El panel es el cliente:** aquí la tarea vive lo que viva el panel. Si cierras la ventana con una tarea en marcha, se queda sin quien la recoja. Pide la entrega en un fichero y no cierres hasta que esté.
+- **T18 · Un encargo grande, en chat nuevo:** un chat con 6 turnos y 519 pasos acumulados acaba con un 400 del proveedor (`read body failed`). Los encargos van en ficheros y no necesitan historial: abre chat nuevo para cada encargo grande.
+
+## El ciclo (diagnóstico → revisión → arreglo → cierre)
+
+1. **Diagnóstico** (tu chat): solo mirar, sin tocar ficheros. Lee lo que te den, pasa pruebas, busca fallos y comprueba cada uno. Lo no comprobado, SOSPECHA.
+2. **Revisión** (tú): comprueba los fallos que más pesen. Marca falsos positivos.
+3. **Arreglo** (tu chat): de uno en uno, cambio mínimo, misma prueba antes/después. Sin commit.
+4. **Cierre** (tú): lee el diff, repite la prueba, abre la app y lo ve. Commit solo si toca.
+
+**No arranques servidores. No publiques. Si falta algo, dilo.**

package/bin/instalacion.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * instalación de RATACODE · el paso que npm 11 deja «pendiente».
+ *
+ * ── QUÉ PASA (medido el 24-sep-2026, npm 11.16.0 / Node 24.18.0) ────────────
+ * npm 11 estrenó la política `allow-scripts` (RFC npm/rfcs#868). Al instalar,
+ * recorre el árbol y lista los paquetes con guiones de instalación que NO están
+ * cubiertos por `allowScripts`:
+ *
+ *   npm warn allow-scripts 5 packages have install scripts not yet covered by allowScripts:
+ *   npm warn allow-scripts   @deepseek-ai/dsh-subprocess-local@0.1.5-rc.3 (postinstall: …)
+ *   npm warn allow-scripts   koffi@3.3.1 (install: node ./cnoke.cjs …)
+ *   npm warn allow-scripts   node-pty@1.2.0-beta.15 (install: …; postinstall: …)
+ *
+ * Con la configuración por defecto (`strict-allow-scripts=false`) esos guiones
+ * SÍ se ejecutan: el aviso es una lista de «pendientes de aprobar», no un
+ * salto. Medido en una instalación global recién hecha y sin `--foreground-scripts`:
+ * `node-pty` arranca un PTY y `koffi` llama a kernel32 (trabajo\S1\comprobar-nativos.mjs).
+ *
+ * ── POR QUÉ HACE FALTA ESTE FICHERO ─────────────────────────────────────────
+ * La capa `package.json#allowScripts` se ignora en las instalaciones globales
+ * (`npm.global === true` ⇒ npm no mira el package.json del «proyecto»; medido:
+ * un paquete con `allowScripts` en su tarball sigue saliendo en el aviso). En
+ * cambio, los guiones del PAQUETE RAÍZ sí corren siempre en `npm i -g`.
+ *
+ * Así que aquí, en el postinstall de RATACODE, se comprueba cada uno de los
+ * tres y se ejecuta SU guion de instalación si le falta el fruto. Es
+ * idempotente (si ya está, no hace nada), best-effort (nunca tumba la
+ * instalación) y no imprime ningún valor de credencial.
+ *
+ * ── LO QUE SE COMPRUEBA, PAQUETE A PAQUETE ──────────────────────────────────
+ * · node-pty                → `build/Release/conpty/conpty.dll` (lo copia su
+ *                             postinstall desde `third_party/conpty`). Los
+ *                             `.node` viajan en `prebuilds/<plataforma>-<arch>/`.
+ * · koffi                   → `build/koffi/<toolchain>/koffi.node`, o el
+ *                             paquete de plataforma `@koromix/koffi-*` (que es
+ *                             lo normal: por eso su guion no construye nada).
+ * · dsh-subprocess-local    → `chmod 0755` sobre el `spawn-helper` de node-pty
+ *                             (sólo POSIX: en Windows no existe y es un no-op).
+ */
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Desde dónde se busca cada paquete. `koffi` y `node-pty` cuelgan de la raíz,
+ * pero `@deepseek-ai/dsh-subprocess-local` cuelga DENTRO de `@deepseek-ai/dsh`,
+ * así que hay que resolver también desde ahí o no se encuentra.
+ */
+const BASES = [require];
+try {
+  BASES.push(createRequire(require.resolve('@deepseek-ai/dsh/package.json')));
+} catch { /* sin motor instalado: las otras bases bastan */ }
+
+/**
+ * La carpeta de un paquete del árbol, resolviendo su entrada y subiendo hasta
+ * el `package.json` que lleva su nombre (algunos no exportan `./package.json`,
+ * como `koffi`). Devuelve null si no está.
+ */
+function carpetaDe(nombre) {
+  for (const base of BASES) {
+    let entrada = null;
+    try {
+      entrada = base.resolve(nombre);
+    } catch {
+      try { entrada = base.resolve(nombre + '/package.json'); } catch { continue; }
+    }
+    let dir = dirname(entrada);
+    for (let saltos = 0; saltos < 6; saltos += 1) {
+      const manifiesto = join(dir, 'package.json');
+      if (existsSync(manifiesto)) {
+        try {
+          if (JSON.parse(readFileSync(manifiesto, 'utf8')).name === nombre) return dir;
+        } catch { /* package.json ilegible: se sigue subiendo */ }
+      }
+      const padre = dirname(dir);
+      if (padre === dir) break;
+      dir = padre;
+    }
+  }
+  return null;
+}
+
+/** ¿Está ya el fruto del guion de instalación de este paquete? */
+function yaEsta(nombre, carpeta) {
+  if (carpeta === null) return false;
+  if (nombre === 'node-pty') {
+    return existsSync(join(carpeta, 'build', 'Release', 'conpty', 'conpty.dll'));
+  }
+  if (nombre === 'koffi') {
+    if (existsSync(join(carpeta, 'build'))) {
+      for (const toolchain of readdirSync(join(carpeta, 'build'))) {
+        if (existsSync(join(carpeta, 'build', toolchain, 'koffi.node'))) return true;
+      }
+    }
+    // El paquete de plataforma es la vía normal y suficiente.
+    for (const plataforma of ['win32', 'linux', 'darwin', 'freebsd', 'openbsd', 'android']) {
+      if (carpetaDe('@koromix/koffi-' + plataforma + '-' + process.arch)) return true;
+    }
+    return false;
+  }
+  // dsh-subprocess-local sólo repara permisos de un fichero POSIX.
+  return process.platform === 'win32';
+}
+
+const PENDIENTES = [
+  { nombre: 'node-pty', guion: 'install' },
+  { nombre: 'koffi', guion: 'install' },
+  { nombre: '@deepseek-ai/dsh-subprocess-local', guion: 'postinstall' },
+];
+
+const hechos = [];
+const fallos = [];
+
+for (const { nombre, guion } of PENDIENTES) {
+  const carpeta = carpetaDe(nombre);
+  if (carpeta === null) {
+    fallos.push(nombre + ': no está en el árbol (¿instalación incompleta?)');
+    continue;
+  }
+  if (yaEsta(nombre, carpeta)) {
+    hechos.push(nombre + ': ya estaba');
+    continue;
+  }
+  // `npm run <guion>` dentro de la carpeta del paquete: es exactamente lo que
+  // npm habría ejecutado, con su mismo entorno (npm_config_* incluidos).
+  const r = spawnSync('npm', ['run', guion], {
+    cwd: carpeta,
+    stdio: 'inherit',
+    shell: true,
+    windowsHide: true,
+  });
+  if (r.status === 0 && yaEsta(nombre, carpeta)) hechos.push(nombre + ': ejecutado ahora');
+  else if (r.status === 0) hechos.push(nombre + ': ejecutado (su guion no deja fruto en esta plataforma)');
+  else fallos.push(nombre + ': su guion «' + guion + '» salió con ' + r.status);
+}
+
+process.stdout.write('RATACODE · instalación: ' + hechos.join(' · ') + '\n');
+if (fallos.length > 0) {
+  process.stdout.write('RATACODE · instalación: AVISO, no pude completar: ' + fallos.join(' · ') + '\n');
+  process.stdout.write('RATACODE · instalación: RATACODE arranca igual; si la terminal falla, '
+    + 'ejecuta a mano «npm run install» en la carpeta de cada paquete.\n');
+}
+// Nunca se tumba la instalación por esto: el panel web no necesita estos guiones.
+process.exitCode = 0;