ratacode 0.2.5 → 0.2.6

package/README.md

@@ -168,11 +168,13 @@ motor**; el de por defecto es **MODO-RATA**:
 2. **Headless** — `ratacode headless "encargo"`: mandas el encargo por terminal, sin
    pantalla, y la entrega queda en un fichero.
 3. **MCP** — `ratacode mcp` (o `node mcp/bin/ratacode-mcp.js --home <casa>`): servidor MCP
-   por stdio para Claude Code, Codex, ChatGPT web, Rowboat u OpenClaw. Siete herramientas:
+   por stdio para Claude Code, Codex, ChatGPT web, Rowboat u OpenClaw. Nueve herramientas:
    `list_providers` → `list_models` → `run_task` → `get_task_status` → `get_task_result` →
-   `cancel_task` y `ratacode_status`. Por HTTP (para ChatGPT web) hace falta
-   `ratacode mcp --http` y `mcp.workspaces` declarado; el túnel es
-   `node mcp/tunel.mjs --home <casa>` (puerto por defecto del MCP: 3778).
+   `cancel_task` y `ratacode_status`, más **`list_files`** y **`read_file`** (sólo lectura, para
+   el conector de ChatGPT con cuenta propia: con un plan Pro el modo desarrollador sólo deja usar
+   herramientas que no cambian nada). Por HTTP (para ChatGPT web) hace falta `ratacode mcp --http`
+   y `mcp.workspaces` declarado; el túnel es `node mcp/tunel.mjs --home <casa>` (puerto por
+   defecto del MCP: 3778).
 
 > Los rótulos propios y las secciones **Conexiones**, **Modelos locales** y **Modos** están en
 > español, pero Ajustes → Models y los menús del motor siguen en inglés (los pone el motor, y

package/apreton/mcp.md

@@ -151,6 +151,44 @@ cierres.
 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).
 
+## ChatGPT web con TU cuenta (Pro): conector propio, sólo lectura (R26)
+
+Con la cuenta de ChatGPT (plan Pro) sí se puede tener el MCP propio: se llama **modo desarrollador**
+y se activa en ChatGPT › **Ajustes › Seguridad e inicio de sesión › Modo desarrollador** (en
+Enterprise/Edu lo concede un administrador; la política por plan está en el
+[artículo de ayuda de OpenAI](https://help.openai.com/en/articles/12584461-developer-mode-apps-and-full-mcp-connectors-in-chatgpt-beta)).
+Después se crea el conector en **ChatGPT › Plugins** (`https://chatgpt.com/plugins`) → **+** →
+nombre y descripción → en **Conexión**, la **URL pública** del MCP.
+
+Tres cosas que conviene saber antes de pelearse con la URL:
+
+- **ChatGPT no acepta claves propias.** No puede mandar `Authorization: Bearer <tu-clave>` ni una
+  cabecera inventada ([docs de autenticación](https://developers.openai.com/plugins/build/auth):
+  «ChatGPT does **not** support … custom API keys»). Por eso la clave va **dentro de la URL**, que
+  es una URL-capacidad: quien la tenga, entra. El MCP la admite en la ruta (`/mcp/<clave>`, la de
+  siempre), en la consulta (`/mcp?clave=<clave>`) o en la cabecera `Bearer`, por si un cliente no
+  traga con una de las tres.
+- **`localhost` no le sirve a ChatGPT**: hay que exponerlo. O con el túnel público de siempre
+  (`node mcp/tunel.mjs`, abajo), o con el **Secure MCP Tunnel** de OpenAI
+  ([guía](https://developers.openai.com/api/docs/guides/secure-mcp-tunnels)), que pide un
+  `tunnel_id` de la Platform y `tunnel-client`. **El túnel lo enciende el humano, no RATACODE.**
+- **Con Pro, sólo lectura.** El MCP publica ahora tres herramientas de sólo lectura, marcadas como
+  tales (`readOnlyHint: true`, que es la marca que documenta OpenAI): `ratacode_status` (estado,
+  versión, carpetas autorizadas, herramientas y sesiones), `list_files` (listar una carpeta
+  autorizada) y `read_file` (leer un fichero de dentro). No gastan claves ni tokens, y el cerco de
+  la ruta lo comprueba **el servidor**, con el mismo `lib/lectura.js` de las tareas.
+
+> **`CHATGPT_PRO_WRITE = NO DISPONIBLE POR PLAN`.** `run_task` y `cancel_task` siguen ahí y siguen
+> funcionando por stdio y por HTTP, pero un conector de ChatGPT Pro no puede usarlas: el plan sólo
+> habilita herramientas que no cambian nada. Para mandar trabajo, usa Codex, Claude Code o el propio
+> panel de RATACODE.
+
+Lo que se puede pedirle a ChatGPT, entonces: «consulta RATACODE y dime qué hay en la carpeta
+autorizada», «léeme `notas.md` de ahí». Y lo que NO puede: nada de fuera de `mcp.workspaces` —ni
+por `..`, ni por ruta absoluta, ni por una unión de Windows, ni por el nombre corto 8.3, ni por
+`\\?\`, ni con una variable de entorno—, ni traerse las instrucciones `AGENTS.md` o las habilidades
+de carpetas de arriba (eso se apaga en cada tarea desde R26; mira «Lo que una tarea puede LEER»).
+
 ## Cómo usarlo
 
 1. **`list_models`** — llama primero para ver qué modelos hay, con proveedor, id, contexto, capacidades y estado.

package/mcp/README.md

@@ -94,6 +94,36 @@ Y **ya no hay nada que aceptar**: cada tarea va encerrada en las carpetas de
 bandera `--acepto-lectura-total` de antes es un no-op: se acepta para no romper
 los comandos viejos, y no hace nada (más abajo, «La LECTURA, encerrada»).
 
+### ChatGPT web con tu cuenta (R26): conector propio y túnel
+
+ChatGPT **no acepta claves propias** ni cabeceras que le inventes
+([docs de autenticación](https://developers.openai.com/plugins/build/auth): no admite claves de API
+de cliente), así que la clave viaja **dentro de la URL**: es una URL-capacidad. El servidor la
+admite de tres formas —en la ruta `/mcp/<clave>`, en la consulta `/mcp?clave=<clave>` o en
+`Authorization: Bearer <clave>`— por si un cliente no traga con una de ellas; la que se le da a
+Patxi es la de la ruta. Y **el `Origin` de otra web se corta con un 403**: sólo se atiende desde
+loopback y desde OpenAI.
+
+Pasos (documentación oficial de hoy: [conectar y probar](https://developers.openai.com/plugins/deploy/connect-chatgpt)):
+
+1. En ChatGPT: **Ajustes › Seguridad e inicio de sesión › Modo desarrollador** (en ChatGPT Pro la
+   política del plan puede limitarlo; el artículo de ayuda de OpenAI lo detalla).
+2. En el PC: `ratacode mcp --http` (con `mcp.workspaces` declarado) y, en otra ventana,
+   `node mcp/tunel.mjs --home <casa>`. El túnel **público lo enciende el humano**, no RATACODE.
+3. En ChatGPT: **ChatGPT › Plugins** (`https://chatgpt.com/plugins`) → **+** → nombre y descripción
+   → en **Conexión**, pegar la URL pública completa (la que imprimió `tunel.mjs`).
+4. Crear y revisar las herramientas que descubre. Si el plan **no** permite las de escritura, el
+   conector funciona igual con las de sólo lectura: `ratacode_status`, `list_files` y `read_file`.
+
+> `CHATGPT_PRO_WRITE = NO DISPONIBLE POR PLAN`: con Pro, el conector propio (modo desarrollador) es
+> de sólo lectura. `run_task` y `cancel_task` siguen existiendo y funcionando por stdio y para los
+> clientes que sí pueden escribir; en ChatGPT Pro no aparecerán utilizables.
+
+Alternativa nativa (en vez de cloudflared): **Secure MCP Tunnel** de OpenAI
+([guía](https://developers.openai.com/api/docs/guides/secure-mcp-tunnels)), que necesita un
+`tunnel_id` de la Platform y `tunnel-client`; no sustituye a la URL pública si algún día se publica
+el conector.
+
 ## Las herramientas
 
 | Herramienta | Para qué |
@@ -104,7 +134,17 @@ los comandos viejos, y no hace nada (más abajo, «La LECTURA, encerrada»).
 | `get_task_status` | `queued` · `running` · `completed` · `failed` · `cancelled`. |
 | `get_task_result` | Respuesta, modelo, proveedor, tokens, coste (si está declarado), duración y errores. |
 | `cancel_task` | Detiene la tarea de inmediato (se mata el proceso que la ejecuta). |
-| `ratacode_status` | Estado del propio servidor: casa, motor, tareas vivas, clientes y últimas líneas del cuaderno. |
+| `ratacode_status` | Estado del servidor: si está vivo, versión, herramientas, **carpetas autorizadas**, sesiones (clientes) y topes. Ni la casa ni ninguna clave. |
+| `list_files` | **Sólo lectura (R26).** Lista una carpeta autorizada (entradas con tipo, tamaño y fecha). Fuera de las carpetas autorizadas, se para. |
+| `read_file` | **Sólo lectura (R26).** Devuelve el texto de un fichero de dentro (256 KB como mucho; si es binario, lo dice). Fuera, se para. |
+
+Las tres de sólo lectura (`ratacode_status`, `list_files`, `read_file`) van marcadas con
+`readOnlyHint: true`, `destructiveHint: false` y `openWorldHint: false`, que es lo que OpenAI
+documenta para que el cliente sepa que no cambian nada. **No gastan claves ni tokens**, y el cerco
+de la ruta se comprueba EN EL SERVIDOR con `lib/lectura.js` (el mismo de las tareas): `..`, rutas
+absolutas, uniones que apuntan fuera, nombres cortos 8.3, `\\?\`, UNC y variables de entorno caen
+todos del mismo lado. Por eso son las que puede usar un **ChatGPT Pro** en modo desarrollador
+(mira «ChatGPT web» más abajo).
 
 `run_task` acepta: `prompt`, `esperar_segundos`, `provider`, `model`,
 `working_directory`, `context`, `max_tokens`, `timeout`, `allow_dangerous`.
@@ -142,6 +182,14 @@ agente deciden el modelo; esta capa no elige por nadie.
   trabajos en segundo plano (`tool-jobs`), ni red (`tool-web`), ni subagentes
   (`tool-subagent*`), ni guiones (`tool-workflow`) ni bucles de agentes (`tool-ralph`).
   Se apagan una a una en el parche de cada tarea, con su motivo escrito al lado.
+- **Y las dos lecturas que no pasan por ninguna herramienta (R26).** El motor carga solo las
+  instrucciones `AGENTS.md` de la carpeta de trabajo **y de todas las de arriba** (y del
+  `<casa>\AGENTS.md`) y las habilidades (*skills*) de `<raíz>/.dsh/skills`, `<raíz>/.agents/skills`,
+  `<casa>\skills` y `~/.agents/skills`: eso NO lo ve el gancho, porque no es una llamada a
+  herramienta. Medido: sin apagarlas, un canario puesto en el `AGENTS.md` de la casa **y** una
+  habilidad de fuera **llegaban al modelo**. Se apagan con sus ajustes documentados
+  (`agent-instructions` → `maxBytes: 0`; `skill-filesystem` → `includeDefaultRoots: false`), y la
+  prueba `pruebas/mcp-lectura.test.mjs` mide el antes y el después con el mismo montaje.
 - **El sandbox lo impone el core.** Cada tarea arranca en `workspace-write` con su cwd
   como frontera de escritura, y el MCP le pasa al hijo un parche que **fija** el modo.
   Ojo con el detalle que costó una ronda: la casa de fábrica trae
@@ -241,7 +289,8 @@ y que `cancel_task` deja la tarea en `cancelled` de verdad.
 ## Lo que falta (a propósito)
 
 - **Del MCP:** nada de transporte. El stdio y el Streamable HTTP están hechos, y el túnel
-  (`mcp/tunel.mjs`) también; las siete herramientas y sus topes, en marcha.
+  (`mcp/tunel.mjs`) también; las nueve herramientas (siete de trabajo y estado, dos de sólo
+  lectura) y sus topes, en marcha.
 - **Del lanzador:** arranque/parada del MCP desde el panel con `MCP: ON/OFF`, la sección
   **Connections** en Ajustes (puerto, clientes, última actividad) y el botón que explique el MCP
   dentro de la web. Hoy eso se hace por línea de órdenes y se mira en `<casa>\mcp\`.

package/mcp/bin/ratacode-mcp.js

@@ -54,6 +54,14 @@ function uso() {
     'Sin opciones, habla MCP por stdio (lo que espera cualquier cliente MCP local).',
     'Con --http, habla por los dos a la vez; la clave de la URL se genera y se',
     'guarda en la casa (en <casa>\\mcp\\http-secret.txt), nunca en el repositorio.',
+    'La clave se puede presentar de tres formas: en la ruta (/mcp/<clave>, la de',
+    'siempre), en la consulta (/mcp?clave=<clave>) o en `Authorization: Bearer',
+    '<clave>`. Las dos últimas están ahí por si un cliente no admite la ruta.',
+    '',
+    'R26 · TRES HERRAMIENTAS DE SÓLO LECTURA, para ChatGPT (plan Pro sólo puede',
+    'usar las que no cambian nada): ratacode_status, list_files y read_file. Van',
+    'marcadas con readOnlyHint y leen sólo dentro de las carpetas autorizadas: el',
+    'cerco se comprueba en el servidor, con mcp/lib/lectura.js.',
     '',
     'CADA TAREA VA ENCERRADA en las carpetas de `mcp.workspaces`: lee y escribe',
     'sólo ahí, sin terminal, sin red, sin subagentes y sin guiones. Fuera de esas',
@@ -164,7 +172,7 @@ async function main() {
 
   aviso('en marcha · casa: ' + casa);
   aviso('en marcha · motor: ' + dshBin);
-  aviso('en marcha · herramientas: list_providers, list_models, run_task, get_task_status, get_task_result, cancel_task, ratacode_status');
+  aviso('en marcha · herramientas: list_providers, list_models, run_task, get_task_status, get_task_result, cancel_task, ratacode_status, list_files, read_file');
   aviso('en marcha · tope de tareas: ' + ordenes.tareasPorHora + '/h');
   tareas.resumir();
 
@@ -184,6 +192,9 @@ async function main() {
       clave,
       rutaClave,
       alRotar: guardarUrl,
+      // Quién llama, para el cuaderno y para `ratacode_status`: en modo sin
+      // estado el nombre sólo se puede leer de la petición `initialize`.
+      alPresentarse: (nombre) => tareas.verCliente(nombre),
       host: '127.0.0.1',
     });
     // La clave NO se escribe en stderr: los clientes MCP guardan ese stderr en

package/mcp/lib/carpeta.js

@@ -0,0 +1,152 @@
+/**
+ * carpeta — LAS DOS HERRAMIENTAS DE SOLO LECTURA DEL MCP (R26).
+ *
+ * Por qué existe este fichero: ChatGPT (plan Pro) sólo puede usar herramientas
+ * de SOLO LECTURA por un conector propio en modo desarrollador, y para que un
+ * chat pueda «consultar RATACODE y decir qué hay en la carpeta autorizada»
+ * hacen falta dos cosas que el motor no ofrece: listar una carpeta y leer un
+ * fichero. Las dos, ENCERRADAS y comprobadas AQUÍ, en el servidor.
+ *
+ * Tres reglas, y ninguna es adorno:
+ *
+ * 1 · EL CERCO ES EL MISMO QUE EL DE LAS TAREAS. Se usan las funciones puras de
+ *     `lib/lectura.js` (R25): `canonica()` resuelve rutas relativas, `..`,
+ *     mayúsculas de Windows, UNC, el prefijo `\\?\` y —importante— sigue los
+ *     enlaces del trozo que existe con `realpath`, así que un enlace o una
+ *     unión creada DENTRO que apunta FUERA se juzga por dónde acaba de verdad.
+ *     Y las raíces se calculan con las MISMAS reglas que `resolverEspacio`
+ *     (`raicesAutorizadas`), incluido el apretón del modo HTTP.
+ *
+ * 2 · LO QUE NO ESTÁ DENTRO, NO SE TOCA. Si la ruta se sale, se lanza el mismo
+ *     error de una línea que ve el agente: «Fuera de la carpeta autorizada:
+ *     <ruta>». No se dice qué hay fuera, ni si existe.
+ *
+ * 3 · NADA DE VOLCAR EL DISCO. La lista tiene tope de entradas y la lectura
+ *     tope de bytes (y no lee binarios). Un chat no necesita más.
+ */
+import { closeSync, existsSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { ajustesMcp } from './casa.js';
+import { canonica, dentroDeAlguna, motivoFuera } from './lectura.js';
+import { raicesAutorizadas } from './seguridad.js';
+
+/** Cuántas entradas se listan como mucho de una carpeta. */
+export const TOPE_ENTRADAS = 500;
+/** Cuántos bytes se leen como mucho de un fichero (256 KB: sobra para mirar). */
+export const TOPE_BYTES = 262_144;
+
+/**
+ * Las carpetas autorizadas de esta casa, con las reglas de las tareas (mismas
+ * raíces, mismo apretón en modo HTTP) pero SIN lanzar: `ratacode_status` tiene
+ * que poder decir cuáles son aunque la casa esté mal puesta.
+ * @param {{casa: string, cwdPorDefecto: string, http?: boolean}} opciones
+ * @returns {{raices: string[], raiz: string|null, avisos: string[]}}
+ */
+export function raicesDeLaCasa({ casa, cwdPorDefecto, http = false }) {
+  const ajustes = ajustesMcp(casa);
+  const { raices, avisos } = raicesAutorizadas({ ajustes, cwdPorDefecto, http });
+  return { raices, raiz: raices.length > 0 ? raices[0] : null, avisos };
+}
+
+/**
+ * La ruta canónica pedida, o el error de una línea si se sale del cerco. Una
+ * ruta vacía NO es «todo»: es que falta la ruta.
+ * @param {{ruta: string, raices: string[], cwd?: string}} opciones
+ * @returns {string} la ruta canónica.
+ */
+export function resolverDentro({ ruta, raices, cwd }) {
+  const pedida = String(ruta ?? '').trim();
+  if (pedida === '') throw new Error('falta la ruta (por ejemplo: "." para la carpeta autorizada)');
+  const juicio = dentroDeAlguna(pedida, raices ?? [], cwd);
+  if (!juicio.dentro) throw new Error(motivoFuera(juicio.canonica === '' ? pedida : juicio.canonica));
+  return juicio.canonica;
+}
+
+/**
+ * Listar una carpeta autorizada, sin salirse.
+ * @param {{ruta?: string, raices: string[], cwd?: string, tope?: number}} opciones
+ * @returns {{carpeta: string, raices: string[], total: number, devueltas: number, truncado: boolean, entradas: object[]}}
+ */
+export function listarCarpeta({ ruta, raices, cwd, tope = TOPE_ENTRADAS }) {
+  const lista = Array.isArray(raices) ? raices : [];
+  const carpeta = resolverDentro({ ruta, raices: lista, cwd });
+  if (!existsSync(carpeta)) throw new Error('no existe: ' + carpeta);
+  if (!statSync(carpeta).isDirectory()) throw new Error('no es una carpeta: ' + carpeta);
+
+  const todas = readdirSync(carpeta, { withFileTypes: true });
+  const entradas = [];
+  for (const entrada of todas) {
+    if (entradas.length >= tope) break;
+    entradas.push(describir(join(carpeta, entrada.name), entrada, lista, carpeta));
+  }
+  return {
+    carpeta,
+    raices: lista,
+    total: todas.length,
+    devueltas: entradas.length,
+    truncado: todas.length > entradas.length,
+    entradas,
+  };
+}
+
+/**
+ * Describir UNA entrada. Si es un enlace (o una unión de Windows) se mira a
+ * DÓNDE va de verdad: un enlace de dentro que apunta fuera se dice tal cual y
+ * no se toca.
+ * @param {string} completa - ruta completa de la entrada.
+ * @param {import('node:fs').Dirent} entrada - la entrada del directorio.
+ * @param {string[]} raices - carpetas autorizadas.
+ * @param {string} carpeta - la carpeta que se está listando.
+ * @returns {object}
+ */
+function describir(completa, entrada, raices, carpeta) {
+  const base = { nombre: entrada.name };
+  const destino = canonica(completa, carpeta);
+  const dentro = dentroDeAlguna(completa, raices, carpeta).dentro;
+  if (entrada.isSymbolicLink()) {
+    return { ...base, tipo: 'enlace', destino_dentro: dentro, ...(dentro ? {} : { aviso: 'el enlace apunta FUERA de la carpeta autorizada: no se sigue' }) };
+  }
+  if (!dentro) return { ...base, tipo: 'otro', aviso: 'sin resolver dentro de la carpeta autorizada' };
+  if (entrada.isDirectory()) return { ...base, tipo: 'carpeta' };
+  if (entrada.isFile()) {
+    try {
+      const info = statSync(destino);
+      return { ...base, tipo: 'fichero', bytes: info.size, modificado: info.mtime.toISOString() };
+    } catch {
+      return { ...base, tipo: 'fichero' };
+    }
+  }
+  return { ...base, tipo: 'otro' };
+}
+
+/**
+ * Leer un fichero autorizado, sin salirse y sin volcar un disco.
+ * @param {{ruta: string, raices: string[], cwd?: string, maxBytes?: number}} opciones
+ * @returns {{fichero: string, bytes: number, bytes_totales: number, truncado: boolean, texto: string}}
+ */
+export function leerFichero({ ruta, raices, cwd, maxBytes = TOPE_BYTES }) {
+  const lista = Array.isArray(raices) ? raices : [];
+  const fichero = resolverDentro({ ruta, raices: lista, cwd });
+  if (!existsSync(fichero)) throw new Error('no existe: ' + fichero);
+  const info = statSync(fichero);
+  if (info.isDirectory()) throw new Error('es una carpeta, no un fichero: ' + fichero + ' (usa list_files)');
+
+  const tope = Math.min(Math.max(1, Number(maxBytes) || TOPE_BYTES), TOPE_BYTES);
+  const trozo = Buffer.alloc(Math.min(tope, Math.max(1, info.size)));
+  const descriptor = openSync(fichero, 'r');
+  let leidos = 0;
+  try {
+    leidos = trozo.length === 0 ? 0 : readSync(descriptor, trozo, 0, trozo.length, 0);
+  } finally {
+    closeSync(descriptor);
+  }
+  const datos = trozo.subarray(0, leidos);
+  if (datos.includes(0)) throw new Error('es un fichero binario (no texto): ' + fichero);
+  return {
+    fichero,
+    bytes: leidos,
+    bytes_totales: info.size,
+    truncado: info.size > leidos,
+    texto: datos.toString('utf8'),
+  };
+}

package/mcp/lib/http.js

@@ -28,6 +28,17 @@
  * del fichero de la clave, este módulo la relee cada pocos segundos y adopta la
  * nueva. Así `tunel.mjs` puede estrenar clave al abrir el túnel y el servidor
  * que ya está en marcha la acepta.
+ *
+ * R26 · DOS COSAS MÁS, por ChatGPT:
+ *   · LA CLAVE SE PUEDE PRESENTAR DE TRES FORMAS: en la ruta (`/mcp/<clave>`,
+ *     lo de siempre), en la consulta (`/mcp?clave=<clave>`) o en la cabecera
+ *     `Authorization: Bearer <clave>`. Sin dato de si ChatGPT acepta la clave
+ *     dentro de la ruta, se dejan preparadas las otras dos: la ruta sigue
+ *     siendo la forma que se le da a Patxi.
+ *   · EL `Origin` DE OTRA WEB SE CORTA CON UN 403. Un navegador con una página
+ *     abierta no tiene por qué hablarle a este servidor. Se permite el origen
+ *     propio (loopback, cualquier puerto: el inspector de MCP vive en otro) y
+ *     los de OpenAI (por si su backend mandara `Origin` alguna vez).
  */
 import { timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
@@ -42,6 +53,35 @@ const SIMULTANEAS_DEFECTO = 8;
 /** Cada cuánto se mira si la clave del fichero ha cambiado. */
 const MS_REVISION_CLAVE = 2000;
 
+/** Los nombres del parámetro de la clave en la consulta, para los clientes que no puedan usar la ruta. */
+const CLAVES_EN_CONSULTA = ['clave', 'key'];
+
+/**
+ * ¿Este `Origin` es de casa (loopback) o de OpenAI? Cualquier otra web: no.
+ * @param {string|undefined} origen - la cabecera `Origin`.
+ * @returns {boolean} true si se admite.
+ */
+export function origenAdmitido(origen) {
+  if (typeof origen !== 'string' || origen.trim() === '') return true; // sin cabecera: un cliente, no un navegador
+  let anfitrion;
+  try {
+    anfitrion = new URL(origen).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (anfitrion === '127.0.0.1' || anfitrion === 'localhost' || anfitrion === '::1' || anfitrion === '[::1]') return true;
+  if (anfitrion === 'chatgpt.com' || anfitrion.endsWith('.chatgpt.com')) return true;
+  if (anfitrion === 'openai.com' || anfitrion.endsWith('.openai.com')) return true;
+  return false;
+}
+
+/** El valor de un `Authorization: Bearer <clave>`, si lo hay. */
+function portador(cabecera) {
+  if (typeof cabecera !== 'string') return null;
+  const trozos = cabecera.trim().split(/\s+/);
+  return trozos.length === 2 && trozos[0].toLowerCase() === 'bearer' ? trozos[1] : null;
+}
+
 /** Leer el cuerpo JSON de una petición, con tope. */
 function leerCuerpo(req) {
   return new Promise((listo, rechaza) => {
@@ -84,10 +124,10 @@ function claveValida(recibida, buena) {
 
 /**
  * Arrancar el servidor HTTP.
- * @param {{fabricaServidor: () => import('@modelcontextprotocol/sdk/server/mcp.js').McpServer, puerto: number, clave: string, rutaClave?: string, alRotar?: (nueva: string) => void, host?: string, simultaneas?: number}} opciones
+ * @param {{fabricaServidor: () => import('@modelcontextprotocol/sdk/server/mcp.js').McpServer, puerto: number, clave: string, rutaClave?: string, alRotar?: (nueva: string) => void, host?: string, simultaneas?: number, alPresentarse?: (nombre: string) => void}} opciones
  * @returns {Promise<{servidor: import('node:http').Server, claveActual: () => string, parar: () => void}>} ya escuchando.
  */
-export function iniciarServidorHttp({ fabricaServidor, puerto, clave, rutaClave, alRotar, host = '127.0.0.1', simultaneas = SIMULTANEAS_DEFECTO }) {
+export function iniciarServidorHttp({ fabricaServidor, puerto, clave, rutaClave, alRotar, host = '127.0.0.1', simultaneas = SIMULTANEAS_DEFECTO, alPresentarse }) {
   /** La clave viva: puede cambiar si `tunel.mjs` estrena una. */
   let claveViva = clave;
   let atendiendose = 0;
@@ -117,9 +157,21 @@ export function iniciarServidorHttp({ fabricaServidor, puerto, clave, rutaClave,
   });
 
   async function manejar(req, res) {
+    // El origen, lo PRIMERO: una web ajena no llega ni a probar la clave.
+    if (!origenAdmitido(req.headers.origin)) {
+      res.writeHead(403, { 'content-type': 'text/plain; charset=utf-8' })
+        .end('Origen no permitido: sólo se atiende desde esta máquina (o desde OpenAI).');
+      return;
+    }
+
     const url = new URL(req.url ?? '/', 'http://' + (req.headers.host ?? 'localhost'));
     const partes = url.pathname.split('/').filter(Boolean); // ['mcp', '<clave>']
-    if (partes[0] !== 'mcp' || !claveValida(partes[1], claveViva)) {
+    // La clave vale por la ruta (lo de siempre), por la consulta o por la
+    // cabecera `Authorization: Bearer`. Ninguna de las tres se registra.
+    const candidatas = [partes[1], ...CLAVES_EN_CONSULTA.map((n) => url.searchParams.get(n)), portador(req.headers.authorization)];
+    // Una sola pieza de ruta después de `/mcp`: si hay más (`/mcp/<clave>/otra`),
+    // es una URL equivocada y se dice, en vez de atenderla como si fuera la buena.
+    if (partes[0] !== 'mcp' || partes.length > 2 || !candidatas.some((c) => claveValida(c, claveViva))) {
       res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' }).end('Not found');
       return;
     }
@@ -144,6 +196,14 @@ export function iniciarServidorHttp({ fabricaServidor, puerto, clave, rutaClave,
       }
       atendiendose += 1;
       try {
+        // Quién llama, del propio `initialize`: sin estado, el servidor que
+        // atiende el `notifications/initialized` es OTRO distinto del que vio el
+        // `initialize`, así que allí no hay nombre que preguntar y el cuaderno se
+        // quedaba en «MCP». Se apunta aquí, de la petición que sí lo trae.
+        const nombre = cuerpo?.params?.clientInfo?.name;
+        if (cuerpo?.method === 'initialize' && typeof nombre === 'string' && nombre.trim() !== '' && typeof alPresentarse === 'function') {
+          alPresentarse(nombre.trim().slice(0, 80));
+        }
         const transporte = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
         const servidor = fabricaServidor();
         await servidor.connect(transporte);

package/mcp/lib/seguridad.js

@@ -101,6 +101,38 @@ export function esCarpetaDeUsuario(ruta) {
   return a === comparable(normalizarRuta(homedir())) || a === comparable(normalizarRuta(dirname(homedir())));
 }
 
+/**
+ * Las raíces autorizadas de una casa, con el apretón del modo HTTP. NO lanza:
+ * devuelve la lista (que puede quedar vacía) y los avisos. Se usa desde
+ * `resolverEspacio` (las tareas) y desde `lib/carpeta.js` (las dos herramientas
+ * de sólo lectura y `ratacode_status`), para que TODOS miren las mismas
+ * carpetas por las mismas reglas.
+ * @param {{ajustes: object, cwdPorDefecto: string, http?: boolean}} opciones
+ * @returns {{raices: string[], avisos: string[]}}
+ */
+export function raicesAutorizadas({ ajustes, cwdPorDefecto, http = false }) {
+  const avisos = [...ajustes.avisos];
+  let raices = ajustes.workspaces.length > 0
+    ? ajustes.workspaces.map(normalizarRuta)
+    : [normalizarRuta(ajustes.workspacePorDefecto ?? cwdPorDefecto)];
+  if (ajustes.workspaces.length === 0) {
+    avisos.push('la casa no tiene `mcp.workspaces`: sólo se permite ' + raices[0]);
+  }
+
+  // Ni la raíz de un disco ni la carpeta del usuario como espacio: se niegan en
+  // modo HTTP, que es el que se expone. (En local el humano arrancó el servidor
+  // en su propia carpeta a propósito, y ahí manda él.)
+  if (http) {
+    const permitidas = raices.filter((r) => !esRaizDeDisco(r) && !esCarpetaDeUsuario(r));
+    for (const fuera of raices.filter((r) => !permitidas.includes(r))) {
+      avisos.push('espacio demasiado ancho, lo ignoro: ' + fuera
+        + ' (ni la raíz de un disco ni tu carpeta de usuario valen como espacio de trabajo en modo HTTP)');
+    }
+    raices = permitidas;
+  }
+  return { raices, avisos };
+}
+
 /**
  * Resolver el espacio de una tarea, o negarse con un motivo útil.
  * @param {{casa: string, pedido?: string, cwdPorDefecto: string, http?: boolean}} opciones
@@ -108,7 +140,6 @@ export function esCarpetaDeUsuario(ruta) {
  */
 export function resolverEspacio({ casa, pedido, cwdPorDefecto, http = false }) {
   const ajustes = ajustesMcp(casa);
-  const avisos = [...ajustes.avisos];
 
   // En modo HTTP (el del túnel) el espacio se aprieta: sin `mcp.workspaces`
   // declarados no se trabaja. Si no, la única raíz sería la carpeta desde la que
@@ -123,30 +154,13 @@ export function resolverEspacio({ casa, pedido, cwdPorDefecto, http = false }) {
     );
   }
 
-  let raices = ajustes.workspaces.length > 0
-    ? ajustes.workspaces.map(normalizarRuta)
-    : [normalizarRuta(ajustes.workspacePorDefecto ?? cwdPorDefecto)];
-  if (ajustes.workspaces.length === 0) {
-    avisos.push('la casa no tiene `mcp.workspaces`: sólo se permite ' + raices[0]);
-  }
-
-  // Ni la raíz de un disco ni la carpeta del usuario como espacio: se niegan en
-  // modo HTTP, que es el que se expone. (En local el humano arrancó el servidor
-  // en su propia carpeta a propósito, y ahí manda él.)
-  if (http) {
-    const permitidas = raices.filter((r) => !esRaizDeDisco(r) && !esCarpetaDeUsuario(r));
-    for (const fuera of raices.filter((r) => !permitidas.includes(r))) {
-      avisos.push('espacio demasiado ancho, lo ignoro: ' + fuera
-        + ' (ni la raíz de un disco ni tu carpeta de usuario valen como espacio de trabajo en modo HTTP)');
-    }
-    if (permitidas.length === 0) {
-      throw new Error(
-        'no queda ningún espacio de trabajo admisible: ni la raíz de un disco ni tu carpeta de usuario ('
-        + homedir() + ' y ' + dirname(homedir()) + ') valen. Declara `mcp.workspaces` en '
-        + casa + '\\settings.yaml con carpetas de trabajo de verdad.',
-      );
-    }
-    raices = permitidas;
+  const { raices, avisos } = raicesAutorizadas({ ajustes, cwdPorDefecto, http });
+  if (http && raices.length === 0) {
+    throw new Error(
+      'no queda ningún espacio de trabajo admisible: ni la raíz de un disco ni tu carpeta de usuario ('
+      + homedir() + ' y ' + dirname(homedir()) + ') valen. Declara `mcp.workspaces` en '
+      + casa + '\\settings.yaml con carpetas de trabajo de verdad.',
+    );
   }
 
   const candidato = pedido === undefined || pedido === null || String(pedido).trim() === ''
@@ -217,7 +231,13 @@ function yamlSeguro(texto) {
  *      ({@link HERRAMIENTAS_QUE_SE_APAGAN});
  *   4. el cerco de la LECTURA: se inserta `./lectura.js` (el plugin que copia
  *      {@link copiarCerco}) con las carpetas autorizadas dentro;
- *   5. nada más: no se toca ni un fichero del motor.
+ *   5. las dos lecturas que NO pasan por herramienta ninguna (R26): las
+ *      instrucciones `AGENTS.md` de las carpetas de arriba y las habilidades de
+ *      `<raíz>/.dsh/skills`, `<raíz>/.agents/skills`, `<casa>\skills` y
+ *      `~/.agents/skills`. El gancho no las ve porque no son una llamada a
+ *      herramienta: se apagan con sus ajustes documentados (`maxBytes: 0` y
+ *      `includeDefaultRoots: false`).
+ *   6. nada más: no se toca ni un fichero del motor.
  *
  * El `insert` es la única forma de AÑADIR una fila (un parche con `id` sólo
  * retoca una que ya exista: `cordis-plugin-include/lib/index.js:67-89`), y el
@@ -247,6 +267,23 @@ export function parcheDePolitica({ modo, espacio, raices }) {
   for (const [id, motivo] of HERRAMIENTAS_QUE_SE_APAGAN) {
     lineas.push('', '# ' + id + ': ' + motivo, '- id: ' + id, '  disabled: true');
   }
+  lineas.push(
+    '',
+    '# Las INSTRUCCIONES (AGENTS.md) se leen del cwd Y de TODAS las carpetas de arriba',
+    '# (y de <casa>\\AGENTS.md), sin pasar por ninguna herramienta: el gancho no las ve.',
+    '# `maxBytes: 0` es la forma documentada de apagar su carga (`dsh-agent-instructions`:',
+    '# «non-positive or non-finite disables loading»).',
+    '- id: agent-instructions',
+    '  config:',
+    '    maxBytes: 0',
+    '',
+    '# Y las HABILIDADES (skills) se descubren en <raíz-del-proyecto>/.dsh/skills,',
+    '# <raíz>/.agents/skills, <casa>\\skills y ~/.agents/skills: también fuera del cerco.',
+    '# Sin raíces por defecto no se monta ninguna («project and user roots»).',
+    '- id: skill-filesystem',
+    '  config:',
+    '    includeDefaultRoots: false',
+  );
   lineas.push(
     '',
     '# El cerco de la LECTURA: un plugin de cordis que engancha `tools/pre-execute` y',

package/mcp/lib/servidor.js

@@ -1,5 +1,5 @@
 /**
- * servidor — las siete herramientas MCP de RATACODE.
+ * servidor — las herramientas MCP de RATACODE.
  *
  * Esto es una capa FINA: aquí no se decide qué modelo usar (salvo el que la
  * casa ya tiene por defecto, y se dice cuál), no se habla con ningún proveedor
@@ -10,6 +10,13 @@
  * nada de acciones peligrosas sin autorización, ni una clave en ninguna
  * respuesta, y un tope de tareas por hora para no gastar de más cuando el
  * servidor está expuesto (sobre todo por el túnel de Cloudflare).
+ *
+ * R26 · Y TRES HERRAMIENTAS DE SOLO LECTURA, porque ChatGPT (plan Pro) sólo
+ * puede usar las que no cambian nada: `ratacode_status`, `list_files` y
+ * `read_file`. Las tres van marcadas con `readOnlyHint: true` (es la marca que
+ * documenta OpenAI para que el cliente sepa que no cambian estado), no gastan
+ * tokens ni claves, y leen SÓLO dentro de las carpetas autorizadas, con el
+ * cerco de `lib/lectura.js` comprobado aquí, en el servidor.
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -20,11 +27,37 @@ import { catalogo, credencialDeProveedor, resolverRuta } from './modelos.js';
 import { faltaLaClave } from './claves.js';
 import { aviso } from './registro.js';
 import { resolverEspacio, resolverModo } from './seguridad.js';
+import { listarCarpeta, leerFichero, raicesDeLaCasa, TOPE_ENTRADAS } from './carpeta.js';
 import { Tareas } from './tareas.js';
+import { VERSION } from './version.js';
 
 /** La ventana del tope de tareas. */
 const VENTANA_MS = 3600_000;
 
+/**
+ * Las marcas de un herramienta de SOLO LECTURA, tal y como las documenta OpenAI
+ * (`developers.openai.com/plugins/build/mcp-server`): `readOnlyHint: true` sólo
+ * cuando la herramienta NO puede cambiar estado, `destructiveHint: false` y
+ * `openWorldHint: false` (lo que se mira es una carpeta acotada de esta
+ * máquina, no Internet).
+ */
+const SOLO_LECTURA = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+/** Y las de una que SÍ cambia cosas (lanza trabajo o lo cancela). */
+const ESCRIBE = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+
+/** Las herramientas que publica este servidor, con si son de sólo lectura. */
+const HERRAMIENTAS = [
+  ['list_providers', true],
+  ['list_models', true],
+  ['run_task', false],
+  ['get_task_status', true],
+  ['get_task_result', true],
+  ['cancel_task', false],
+  ['ratacode_status', true],
+  ['list_files', true],
+  ['read_file', true],
+];
+
 /** El envoltorio de toda respuesta: JSON legible para cualquier agente. */
 function comoTexto(dato) {
   return { content: [{ type: 'text', text: JSON.stringify(dato, null, 2) }] };
@@ -77,6 +110,8 @@ function instrucciones() {
   return [
     'RATACODE está disponible como servidor MCP: úsalo para delegar trabajos a los modelos configurados en esta máquina.',
     '',
+    'SI SÓLO PUEDES LEER (ChatGPT con conector propio en modo desarrollador: las herramientas de escritura no están disponibles en todos los planes), usa estas tres: `ratacode_status` (estado del servidor, versión, carpetas autorizadas y herramientas), `list_files` (lista una carpeta autorizada) y `read_file` (lee un fichero de una carpeta autorizada). Las tres están marcadas como de sólo lectura y no gastan tokens ni claves.',
+    '',
     'Antes de ejecutar una tarea:',
     '1. consulta list_models',
     '2. lanza run_task con el modelo que te hayan pedido',
@@ -125,6 +160,7 @@ export function registrarHerramientas(servidor, ctx) {
       title: 'Proveedores de RATACODE',
       description: 'Los proveedores configurados en RATACODE, con si tienen la credencial puesta en la casa (RATACODE › Ajustes › Models). Nunca devuelve ninguna clave.',
       inputSchema: {},
+      annotations: SOLO_LECTURA,
     },
     conRed(async () => {
       const { proveedores, porDefecto, avisos } = await catalogo(casa);
@@ -156,6 +192,7 @@ export function registrarHerramientas(servidor, ctx) {
       inputSchema: {
         provider: z.string().optional().describe('Filtra por proveedor (por ejemplo "b-ai").'),
       },
+      annotations: SOLO_LECTURA,
     },
     conRed(async ({ provider }) => {
       const { modelos, porDefecto, avisos } = await catalogo(casa);
@@ -189,6 +226,7 @@ export function registrarHerramientas(servidor, ctx) {
         timeout: z.number().int().positive().optional().describe('Tiempo máximo en milisegundos antes de cancelar la tarea. Por defecto ' + ajustes.timeoutPorDefectoMs + ' ms (' + Math.round(ajustes.timeoutPorDefectoMs / 60000) + ' min); máximo ' + ajustes.timeoutMaximoMs + ' ms.'),
         allow_dangerous: z.boolean().optional().describe('Pedir acceso total al disco. Requiere que el humano lo haya permitido en la casa; si no, se deniega.'),
       },
+      annotations: ESCRIBE,
     },
     conRed(async (args) => {
       // Tope del encargo: un prompt enorme es un gasto enorme y una espera peor.
@@ -308,6 +346,7 @@ export function registrarHerramientas(servidor, ctx) {
       title: 'Estado de una tarea',
       description: 'Estado de una tarea: queued, running, completed, failed o cancelled.',
       inputSchema: { task_id: z.string().min(1).describe('El task_id que devolvió run_task.') },
+      annotations: SOLO_LECTURA,
     },
     conRed(async ({ task_id }) => comoTexto(tareas.estado(task_id))),
   );
@@ -319,6 +358,7 @@ export function registrarHerramientas(servidor, ctx) {
       title: 'Resultado de una tarea',
       description: 'La respuesta de una tarea terminada, con modelo, proveedor, tokens, coste (si está declarado), duración y errores.',
       inputSchema: { task_id: z.string().min(1).describe('El task_id que devolvió run_task.') },
+      annotations: SOLO_LECTURA,
     },
     conRed(async ({ task_id }) => comoTexto(tareas.resultado(task_id))),
   );
@@ -330,6 +370,7 @@ export function registrarHerramientas(servidor, ctx) {
       title: 'Cancelar una tarea',
       description: 'Detiene una tarea en marcha de inmediato (se mata el proceso que la ejecuta).',
       inputSchema: { task_id: z.string().min(1).describe('El task_id que devolvió run_task.') },
+      annotations: ESCRIBE,
     },
     conRed(async ({ task_id }) => comoTexto(await tareas.cancelar(task_id))),
   );
@@ -339,19 +380,25 @@ export function registrarHerramientas(servidor, ctx) {
     'ratacode_status',
     {
       title: 'Estado de RATACODE MCP',
-      description: 'Estado del propio servidor: tareas vivas, tope por hora y espacios autorizados. No devuelve la casa ni la actividad de otros clientes.',
+      description: 'Estado del propio servidor: si está vivo, su versión, las herramientas que publica, las carpetas autorizadas, las sesiones (clientes) que han hablado con él y los topes. No devuelve la casa, ni las claves, ni la actividad de otros clientes. Úsalo al empezar, para saber con qué cuentas.',
       inputSchema: {},
+      annotations: SOLO_LECTURA,
     },
     conRed(async () => {
       const resumen = tareas.resumir();
+      const { raices, raiz, avisos } = raicesDeLaCasa({ casa, cwdPorDefecto, http: ctx.http === true });
       // Ni la casa (el dato que sirve en bandeja para ir a leer
-      // `.credentials.yaml`), ni el cuaderno de actividad (lleva los encargos de
-      // TODOS los clientes), ni las últimas tareas de otros: cada cliente ve lo
-      // suyo y el estado del servidor.
+      // `.credentials.yaml`), ni el motor, ni el cuaderno de actividad (lleva los
+      // encargos de TODOS los clientes): cada cliente ve lo suyo, lo que puede
+      // tocar y cómo está el servidor.
+      const { casa: _casa, motor: _motor, ...servidor } = resumen.mcp;
       return comoTexto({
-        mcp: resumen.mcp,
-        actualizado: resumen.actualizado,
-        espacios_autorizados: ajustes.workspaces.length > 0 ? ajustes.workspaces : ['(sin lista; sólo el espacio por defecto)'],
+        vivo: true,
+        version: VERSION,
+        servidor: { ...servidor, transporte: ctx.http === true ? ['stdio', 'http'] : ['stdio'] },
+        herramientas: HERRAMIENTAS.map(([nombre, soloLectura]) => ({ nombre, solo_lectura: soloLectura })),
+        carpeta_autorizada: { raiz, raices },
+        sesiones: { clientes: resumen.clientes, tareas_totales: resumen.tareas_totales, tareas_activas: resumen.tareas_activas },
         permitir_peligroso: ajustes.permitirPeligroso,
         topes: {
           tareas_por_hora: ctx.tareasPorHora,
@@ -360,15 +407,55 @@ export function registrarHerramientas(servidor, ctx) {
           timeout_por_defecto_ms: ajustes.timeoutPorDefectoMs,
           timeout_maximo_ms: ajustes.timeoutMaximoMs,
           prompt_max_caracteres: ajustes.promptMaxCaracteres,
+          entradas_por_listado: TOPE_ENTRADAS,
         },
-        nota: 'Para ver el cuaderno de actividad y las tareas de todos los clientes, míralo en la casa (o en el panel), no por MCP.',
+        avisos,
+        nota: 'Esta herramienta es de SÓLO LECTURA, como list_files y read_file. Para ver el cuaderno de actividad y las tareas de todos los clientes, míralo en la casa (o en el panel), no por MCP.',
       });
     }),
   );
+
+  // ── list_files (R26 · sólo lectura, para ChatGPT) ─────────────────────────
+  servidor.registerTool(
+    'list_files',
+    {
+      title: 'Listar una carpeta autorizada',
+      description: 'Lista lo que hay en una carpeta de las autorizadas (por defecto, la primera). Sólo lectura: no cambia nada. Si la ruta se sale de las carpetas autorizadas, la herramienta se para y lo dice. Devuelve nombre, tipo, tamaño y fecha de cada entrada.',
+      inputSchema: {
+        ruta: z.string().optional().describe('Carpeta a listar: relativa a la carpeta autorizada, o absoluta pero DENTRO de ella. Por defecto, la carpeta autorizada.'),
+      },
+      annotations: SOLO_LECTURA,
+    },
+    conRed(async ({ ruta }) => {
+      const { raices, raiz, avisos } = raicesDeLaCasa({ casa, cwdPorDefecto, http: ctx.http === true });
+      if (raices.length === 0) throw new Error('esta casa no tiene ninguna carpeta autorizada: mira los avisos en ratacode_status');
+      const listado = listarCarpeta({ ruta: ruta ?? raiz, raices, cwd: raiz });
+      return comoTexto({ ...listado, avisos });
+    }),
+  );
+
+  // ── read_file (R26 · sólo lectura, para ChatGPT) ──────────────────────────
+  servidor.registerTool(
+    'read_file',
+    {
+      title: 'Leer un fichero autorizado',
+      description: 'Devuelve el texto de un fichero que esté DENTRO de las carpetas autorizadas. Sólo lectura: no cambia nada. Si la ruta se sale, la herramienta se para y lo dice; si es binario o muy grande, también (y en ese caso devuelve el principio y avisa).',
+      inputSchema: {
+        ruta: z.string().min(1).describe('Fichero a leer: relativo a la carpeta autorizada, o absoluto pero DENTRO de ella.'),
+      },
+      annotations: SOLO_LECTURA,
+    },
+    conRed(async ({ ruta }) => {
+      const { raices, raiz, avisos } = raicesDeLaCasa({ casa, cwdPorDefecto, http: ctx.http === true });
+      if (raices.length === 0) throw new Error('esta casa no tiene ninguna carpeta autorizada: mira los avisos en ratacode_status');
+      const leido = leerFichero({ ruta, raices, cwd: raiz });
+      return comoTexto({ ...leido, raices, avisos });
+    }),
+  );
 }
 
 /**
- * Montar el servidor MCP con sus siete herramientas.
+ * Montar el servidor MCP con sus herramientas.
  * @param {{casa: string, dshBin: string, cwdPorDefecto: string, tareasPorHora?: number, http?: boolean}} opciones - la casa, el motor, el cwd, el tope y si se habla por HTTP.
  * @returns {{servidor: McpServer, tareas: Tareas, fabricaServidor: () => McpServer}}
  */
@@ -385,7 +472,7 @@ export function montarServidor({ casa, dshBin, cwdPorDefecto, tareasPorHora = 30
    * un mismo servidor a varios transportes a la vez) sin perder el estado. */
   function fabricaServidor() {
     const servidor = new McpServer(
-      { name: 'ratacode', version: '0.1.0' },
+      { name: 'ratacode', version: VERSION },
       { instructions: instrucciones() },
     );
     registrarHerramientas(servidor, { casa, dshBin, cwdPorDefecto, tareas, marcasTarea, tareasPorHora, http });

package/mcp/lib/version.js

@@ -0,0 +1,32 @@
+/**
+ * version — la versión de RATACODE, leída del manifiesto (R26).
+ *
+ * Por qué un fichero para esto: el cliente MCP (y ChatGPT, al enseñar el
+ * conector) ven el nombre y la VERSIÓN del servidor en el handshake, y
+ * `ratacode_status` la publica. Estaba escrita a mano («0.1.0») y se quedó
+ * vieja; leerla del `package.json` que de verdad se instaló es lo único que no
+ * miente.
+ *
+ * Dos sitios, en orden: el paquete del producto (`../../package.json`, que es
+ * como viaja dentro de `ratacode`) y el del MCP suelto (`../package.json`).
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** La carpeta de `mcp/lib`. */
+const AQUI = dirname(fileURLToPath(import.meta.url));
+
+/** La versión, o `0.0.0` si no hay manifiesto legible (no se inventa). */
+export const VERSION = leer();
+
+/** Leer la versión del primer manifiesto que se deje. */
+function leer() {
+  for (const relativa of ['../../package.json', '../package.json']) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(AQUI, relativa), 'utf8'));
+      if (typeof pkg.version === 'string' && pkg.version.trim() !== '') return pkg.version.trim();
+    } catch { /* se prueba el siguiente */ }
+  }
+  return '0.0.0';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ratacode",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "RATACODE · la terminal de trabajo con IA: le mandas el trabajo pesado a modelos baratos (o a los tuyos, en local) y el resultado vuelve a tu agente o a tu chat.",
   "license": "MIT",
   "author": {
@@ -20,7 +20,7 @@
   },
   "scripts": {
     "postinstall": "node bin/instalacion.js",
-    "test": "node pruebas/piel.test.mjs && node pruebas/modos.test.mjs && node pruebas/parche.test.mjs && node pruebas/mcp-espacios.test.mjs && node pruebas/mcp-cerrado.test.mjs"
+    "test": "node pruebas/piel.test.mjs && node pruebas/modos.test.mjs && node pruebas/parche.test.mjs && node pruebas/mcp-espacios.test.mjs && node pruebas/mcp-cerrado.test.mjs && node pruebas/mcp-lectura.test.mjs"
   },
   "files": [
     "bin",